PCL로 규제 준수 ERC20 토큰 만들기 — 처음부터 끝까지

import { createPublicClient, http } from "viem";

const EAS_PRECOMPILE = "0x1000000000000000000000000000000000000009";
const easPrecompileAbi = [{
  name: "getParams", type: "function", stateMutability: "view",
  inputs: [],
  outputs: [{
    type: "tuple", components: [
      { name: "schemaRegistry", type: "address" },
      { name: "eas",            type: "address" },
      { name: "indexer",        type: "address" },
    ],
  }],
}] as const;

const publicClient = createPublicClient({ transport: http("https://rpc-testnet.maroo.io") });
const { eas: EAS_ADDR, indexer: INDEX_ADDR, schemaRegistry: SCHEMA_REG } =
  await publicClient.readContract({
    address: EAS_PRECOMPILE,
    abi: easPrecompileAbi,
    functionName: "getParams",
  });

스키마 등록, attestation 발급, 인덱싱

const { EAS, SchemaEncoder, SchemaRegistry } =
  require("@ethereum-attestation-service/eas-sdk");
const { ethers } = require("hardhat");

async function main() {
  const [issuer, kycUser] = await ethers.getSigners();

  // 1) 스키마 등록
  const registry = new SchemaRegistry(SCHEMA_REG);
  await registry.connect(issuer);
  const schemaUID = await (await registry.register({
    schema: "bool kycVerified",
    revocable: true,
  })).wait();

  // 2) kycUser에게 attestation 발급
  const eas = new EAS(EAS_ADDR);
  await eas.connect(issuer);
  const enc = new SchemaEncoder("bool kycVerified");
  const attUID = await (await eas.attest({
    schema: schemaUID,
    data: {
      recipient: kycUser.address,
      expirationTime: 0,
      revocable: true,
      data: enc.encodeData([{ name: "kycVerified", value: true, type: "bool" }]),
    },
  })).wait();
  console.log("attestationUID =", attUID);

  // 3) 인덱싱합니다. PCL의 EAS_POLICY는 EAS Indexer에서만 attestation을 조회합니다
  const indexer = new ethers.Contract(INDEX_ADDR, [
    "function indexAttestation(bytes32 attestationUID)",
    "function isAttestationIndexed(bytes32 attestationUID) view returns (bool)",
  ], issuer);
  await (await indexer.indexAttestation(attUID)).wait();
  console.log("indexed:", await indexer.isAttestationIndexed(attUID));
}
main().catch(console.error);

최소 구현체: initialize()로 초기화하는 일반 ERC20

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.28;

import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Initializable} from "@openzeppelin/contracts/proxy/utils/Initializable.sol";

/// PCL 프록시 뒤에 놓이는 토큰 로직입니다. 컴플라이언스 코드가 없는 일반 ERC20입니다.
/// 프록시 뒤에서는 생성자가 프록시의 스토리지에서 실행되지 않으므로, 이름·심볼·초기 공급량은
/// 프록시가 배포되는 동안 한 번 호출하는 `initialize`에서 설정합니다.
contract MyToken is ERC20, Initializable {
    string private _tokenName;
    string private _tokenSymbol;

    constructor() ERC20("", "") {
        _disableInitializers(); // 구현 컨트랙트 자체는 초기화하지 않습니다
    }

    function initialize(address holder) external initializer {
        _tokenName = "My Token";
        _tokenSymbol = "MYT";
        _mint(holder, 1_000_000 ether);
    }

    function name() public view override returns (string memory) {
        return _tokenName;
    }

    function symbol() public view override returns (string memory) {
        return _tokenSymbol;
    }
}

import { createWalletClient, http, encodeAbiParameters, encodeFunctionData, parseEventLogs } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { iPclAbi as pclAbi } from "@maroo-chain/contracts/abi/precompiles/pcl/IPcl";

const PCL = "0x1000000000000000000000000000000000000005" as const;

const owner = privateKeyToAccount(process.env.OWNER_KEY as `0x${string}`);
const wallet = createWalletClient({
  account: owner,
  transport: http("https://rpc-testnet.maroo.io"),
});

// 1) 평소 Hardhat / viem 배포로 구현체(위의 MyToken)를 배포합니다.
//    `implAddress`에 배포되었다고 가정합니다.
// TODO: 배포 후 실제 구현체 주소로 교체하십시오.
const implAddress = "0x8F3ac2B1d9E74c05A6B18FE27Dc4913e5A0F7b62";
// TODO: 프로덕션 배포 전 실제 업그레이드 admin(멀티시그)으로 교체하십시오.
const initialOwner = "0x2c7f09B81a6D3FF1e5A0d4c6bC2a8f7E19dc3a4B";
// TODO: 2단계에서 attestation을 발급한 지갑(`kycUser`)으로 교체하십시오.
const kycUser = "0x3a9C71E4B8D2F6A05C7e19B4d3F82a6C5e0B9d47";

// 2) initializer calldata를 만듭니다. initialize(kycUser)는 초기 공급량을
//    attestation을 받은 지갑에 발행합니다. 프록시가 배포 중에 이 calldata를
//    실행하므로 초기화된 상태는 프록시에 저장됩니다. 비워 둘 수 없습니다.
//    "0x"를 넘기면 프록시 생성자가 revert되고 deployPclProxy도 revert됩니다.
const implAbi = [
  { type: "function", name: "initialize", stateMutability: "nonpayable",
    inputs: [{ name: "holder", type: "address" }], outputs: [] },
] as const;
const initializer = encodeFunctionData({
  abi: implAbi,
  functionName: "initialize",
  args: [kycUser],
});

// 3) Transparent 프록시 initData를 ABI 인코딩합니다: (logic, initialOwner, initializer)
const initData = encodeAbiParameters(
  [
    { type: "address" },
    { type: "address" },
    { type: "bytes" },
  ],
  [implAddress, initialOwner, initializer],
);

// 4) PCL 등록 프록시를 배포합니다. writeContract는 트랜잭션 해시를 반환하므로
//    프록시 주소는 영수증의 PclProxyDeployed 이벤트에서 읽습니다.
const hash = await wallet.writeContract({
  address: PCL,
  abi: pclAbi,
  functionName: "deployPclProxy",
  args: [1 /* Transparent */, 0n, initData],
});
const receipt = await publicClient.waitForTransactionReceipt({ hash });
const [deployed] = parseEventLogs({ abi: pclAbi, eventName: "PclProxyDeployed", logs: receipt.logs });
if (!deployed) throw new Error(`deployPclProxy did not deploy a proxy (status: ${receipt.status})`);
// 사용자가 호출할 주소이자 정책을 바인딩할 주소입니다.
const proxyAddress = deployed.args.proxy;

// 등록되어 있으면 PolicyTemplate struct 반환; 아니면 PolicyTemplateNotFound revert.
const template = await publicClient.readContract({
  address: PCL,
  abi: pclAbi,
  functionName: "policyTemplate",
  args: ["EAS_POLICY"],
});
console.log("templateId:", template.templateId);

import { encodeAbiParameters, toHex } from "viem";

const easPolicyBytes = encodeAbiParameters(
  [
    { type: "address", name: "easContract" },
    { type: "address", name: "indexContract" },
    { type: "bytes32", name: "schemaUid" },
  ],
  [EAS_ADDR, INDEX_ADDR, schemaUID],
);

const policySet = {
  templateId: "EAS_POLICY",
  policy:     easPolicyBytes,
  selector:   toHex("", { size: 0 }),  // empty bytes → 모든 호출에 적용
};

// 3단계에서 deployPclProxy를 호출한 지갑(`wallet`)에서 보냅니다.
// deployPclProxy가 그 지갑을 이 프록시의 정책 admin으로 정했으므로, 다른 발신자는
// `Unauthorized`로 거절됩니다. 페이로드의 `admin`이 다음에 이 프록시에 대해
// `changeContractPolicies` / `removeContractPolicies`를 호출할 수 있는 주소입니다.
// TODO: 프로덕션 배포 전 실제 admin 주소로 교체하십시오.
const ownerAddress = "0x2c7f09B81a6D3FF1e5A0d4c6bC2a8f7E19dc3a4B";

await wallet.writeContract({
  address: PCL,
  abi: pclAbi,
  functionName: "changeContractPolicies",
  args: [{
    _contract: proxyAddress,
    admin:     ownerAddress,
    policies:  [policySet],
  }],
});

import { BaseError, ContractFunctionRevertedError, decodeErrorResult, erc20Abi, parseEther } from "viem";

try {
  await wallet.writeContract({
    address: proxyAddress,
    abi: erc20Abi,
    functionName: "transfer",
    // TODO: 프로덕션 배포 전 실제 수신자 주소로 교체하십시오.
    args: ["0x5AB7c1e40b8DA46F9C7E29d3fA614e97b8F0ac21", parseEther("100")],
  });
} catch (err) {
  // viem은 revert를 감싸서 던집니다. 원본 revert 데이터는 던져진 오류(`data` 없음)가
  // 아니라 cause 체인의 ContractFunctionRevertedError에 있습니다.
  const reverted = err instanceof BaseError
    ? err.walk((e) => e instanceof ContractFunctionRevertedError)
    : null;
  if (!(reverted instanceof ContractFunctionRevertedError) || !reverted.raw) throw err;
  const decoded = decodeErrorResult({ abi: pclAbi, data: reverted.raw });
  console.log("PCL ReasonCode:", decoded.errorName, decoded.args);
  // 예: 거부된 발신자 주소를 담은 EasNoAttestationReceived
}