메타트랜잭션 구현 및 검증 (EIP-2612, EIP-3009, Avalanche Mainnet)

const { ethers } = require("hardhat");
const axios = require("axios");

const TOKEN_ADDRESS = "0x370DA190a3e39338c78f65E67cBD1D38e5592EbA";
const VAULT_ADDRESS = "0x22F1F84B385B5cDf4A9b9Ad097eb2114D81E09E8";
const RELAYER_API_URL = "http://localhost:3000";

async function main() {
  const [deployer, relayer, user] = await ethers.getSigners();
  const metaTokenFactory = await ethers.getContractFactory("MetaToken");
  const tokenContract = metaTokenFactory.attach(TOKEN_ADDRESS);
  const vaultFactory = await ethers.getContractFactory("Vault");
  const vaultContract = vaultFactory.attach(VAULT_ADDRESS);

  // EIP-712 설정 (vrs)
  const { chainId } = await ethers.provider.getNetwork();
  const typedDataDomain = {
    name: "MetaToken",
    version: "1",
    chainId,
    verifyingContract: TOKEN_ADDRESS,
  };

  // 유저 지갑으로 메타토큰 전송
  await (
    await tokenContract
      .connect(deployer)
      .transfer(user.address, ethers.parseEther("1000"))
  ).wait();

  async function getBalances() {
    const relayerBalance = await ethers.provider.getBalance(relayer.address);
    const userBalance = await ethers.provider.getBalance(user.address);
    return { relayerBalance, userBalance };
  }

  // -----------------------------------------------------
  //  전송 테스트
  // -----------------------------------------------------
  console.log(`\n[전송 테스트]`);

  const startBalances = await getBalances();

  // 1. 일반 전송 (유저가 가스비 지불)
  console.log(`transfer`);
  const directTransferTx = await tokenContract
    .connect(user)
    .transfer(deployer.address, ethers.parseEther("10"));
  await directTransferTx.wait();
  const afterDirectTransferBalances = await getBalances();

  console.log(
    `유저가 지불한 가스비: ${ethers.formatEther(
      startBalances.userBalance - afterDirectTransferBalances.userBalance
    )} AVAX`
  );

  // 2. 3009 활용한 전송 (릴레이어가 가스비 지불)
  console.log(`transfer + 3009`);
  const metaTransferAmount = ethers.parseEther("10");
  const metaTransferNonce = ethers.hexlify(ethers.randomBytes(32));
  const metaTransferMessage = {
    from: user.address,
    to: deployer.address,
    value: metaTransferAmount,
    validAfter: 0,
    validBefore: Math.floor(Date.now() / 1000) + 3600,
    nonce: metaTransferNonce,
  };
  const metaTransferSignature = await user.signTypedData(
    typedDataDomain,
    {
      TransferWithAuthorization: [
        { name: "from", type: "address" },
        { name: "to", type: "address" },
        { name: "value", type: "uint256" },
        { name: "validAfter", type: "uint256" },
        { name: "validBefore", type: "uint256" },
        { name: "nonce", type: "bytes32" },
      ],
    },
    metaTransferMessage
  );
  const {
    v: metaTransferV,
    r: metaTransferR,
    s: metaTransferS,
  } = ethers.Signature.from(metaTransferSignature);

  // 릴레이어에게 vrs 전달
  await axios.post(`${RELAYER_API_URL}/relay/transfer`, {
    from: user.address,
    to: deployer.address,
    value: metaTransferAmount.toString(),
    validAfter: 0,
    validBefore: metaTransferMessage.validBefore,
    nonce: metaTransferNonce,
    signature: { v: metaTransferV, r: metaTransferR, s: metaTransferS },
  });

  const afterMetaTransferBalances = await getBalances();
  console.log(
    `유저가 지불한 가스비: ${ethers.formatEther(
      afterDirectTransferBalances.userBalance -
        afterMetaTransferBalances.userBalance
    )} AVAX`
  );
  console.log(
    `릴레이어가 지불한 가스비: ${ethers.formatEther(
      afterDirectTransferBalances.relayerBalance -
        afterMetaTransferBalances.relayerBalance
    )} AVAX`
  );

  console.log(`\n----------------------------------------`);

  // -----------------------------------------------------
  // 예치 테스트
  // -----------------------------------------------------
  console.log(`[예치 테스트]`);

  const beforeDepositBalances = await getBalances();

  // 1. 일반 예치 (approve 후 deposit)
  console.log(`deposit`);
  const standardDepositAmount = ethers.parseEther("10");
  await (
    await tokenContract
      .connect(user)
      .approve(VAULT_ADDRESS, standardDepositAmount)
  ).wait();
  await (
    await vaultContract.connect(user).deposit(standardDepositAmount)
  ).wait();

  const afterStandardDepositBalances = await getBalances();

  console.log(
    `유저가 지불한 가스비: ${ethers.formatEther(
      beforeDepositBalances.userBalance -
        afterStandardDepositBalances.userBalance
    )} AVAX`
  );

  // 2. permit + deposit  (릴레이어가 가스 지불)
  console.log(`permit + deposit`);
  const metaDepositAmount = ethers.parseEther("10");
  const permitNonce = await tokenContract.nonces(user.address);
  const permitDeadline = Math.floor(Date.now() / 1000) + 3600;

  const permitSignature = await user.signTypedData(
    typedDataDomain,
    {
      Permit: [
        { name: "owner", type: "address" },
        { name: "spender", type: "address" },
        { name: "value", type: "uint256" },
        { name: "nonce", type: "uint256" },
        { name: "deadline", type: "uint256" },
      ],
    },
    {
      owner: user.address,
      spender: VAULT_ADDRESS,
      value: metaDepositAmount,
      nonce: permitNonce,
      deadline: permitDeadline,
    }
  );
  const {
    v: permitV,
    r: permitR,
    s: permitS,
  } = ethers.Signature.from(permitSignature);

  // 릴레이어에게 vrs 전달
  await axios.post(`${RELAYER_API_URL}/relay/deposit`, {
    owner: user.address,
    amount: metaDepositAmount.toString(),
    deadline: permitDeadline,
    signature: { v: permitV, r: permitR, s: permitS },
  });

  const afterMetaDepositBalances = await getBalances();
  console.log(
    `유저가 지불한 가스비: ${ethers.formatEther(
      afterStandardDepositBalances.userBalance -
        afterMetaDepositBalances.userBalance
    )} AVAX`
  );
  console.log(
    `릴레이어가 지불한 가스비: ${ethers.formatEther(
      afterStandardDepositBalances.relayerBalance -
        afterMetaDepositBalances.relayerBalance
    )} AVAX`
  );

  console.log(`\n----------------------------------------`);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});