EIP-2612 permit support on USDC not documented — critical for gasless DApp development

[osr21]

Summary

The USDC contract deployed on Arc Testnet (0x3600000000000000000000000000000000000000) supports EIP-2612 permit — the off-chain approval mechanism that enables gasless token transfers. This capability is not mentioned anywhere in the Arc Network developer documentation.

Why This Matters

EIP-2612 permit is the foundation of gasless DApp UX on EVM chains. It allows:

• Users to approve token transfers with an off-chain signature (no gas required for the approval)
• A relayer to call transferFrom on the user's behalf using that signature
• True "sign once, send" UX where users never need a separate approval transaction

This is especially significant on Arc because USDC is the gas token. A DApp that uses permit + relay can offer completely gasless UX — users only need USDC (which they already have), not a separate gas token.

Discovery Method

We discovered permit support by reading the USDC contract ABI directly on the block explorer. There was no documentation, tutorial, or mention of EIP-2612 in any Arc Network resource.

What We Built

Based on this discovery, we implemented a full EIP-2612 relay in Arc Pay:

• User signs a permit message off-chain (free)
• Our relay server calls transferFrom using the permit signature
• Full flow documented in docs/RELAY.md

This works correctly on Arc Testnet. The permit domain separator, nonce, and deadline all behave as per the EIP-2612 spec.

Suggested Documentation Addition

Add a section to the USDC contract documentation confirming:

• EIP-2612 permit is supported on the Arc Testnet USDC contract
• The domain separator parameters (name, version, chainId, verifyingContract)
• A minimal code example showing how to sign and submit a permit
• Guidance on building gasless relays on Arc

Context

This is one of Arc's strongest differentiators — the ability to build fully gasless DApps using only USDC. It should be front and center in the developer docs, not a hidden implementation detail.

[osr21]

Verified: permit() works on Arc Testnet USDC

Confirmed that Arc Testnet USDC (0x3600000000000000000000000000000000000000) supports EIP-2612.

Working ethers.js v6 implementation:

import { ethers } from "ethers";

const USDC_ARC = "0x3600000000000000000000000000000000000000";
const PERMIT_ABI = [
  "function nonces(address) view returns (uint256)",
  "function name() view returns (string)",
  "function version() view returns (string)",
  "function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s)",
];

async function buildPermit(
  signer: ethers.Signer,
  spender: string,
  value: bigint,
  ttlSeconds = 3600
) {
  const usdc     = new ethers.Contract(USDC_ARC, PERMIT_ABI, signer);
  const owner    = await signer.getAddress();
  const nonce    = await usdc.nonces(owner);
  const deadline = BigInt(Math.floor(Date.now() / 1000) + ttlSeconds);
  const chainId  = (await signer.provider!.getNetwork()).chainId;

  const sig = await signer.signTypedData(
    {
      name: await usdc.name(),
      version: await usdc.version(),
      chainId,
      verifyingContract: USDC_ARC,
    },
    {
      Permit: [
        { name: "owner",    type: "address" },
        { name: "spender",  type: "address" },
        { name: "value",    type: "uint256" },
        { name: "nonce",    type: "uint256" },
        { name: "deadline", type: "uint256" },
      ],
    },
    { owner, spender, value, nonce, deadline }
  );

  const { v, r, s } = ethers.Signature.from(sig);
  return { owner, spender, value, deadline, v, r, s };
}

// Usage — gasless approval before a transferFrom:
const p = await buildPermit(signer, contractAddress, ethers.parseUnits("10", 6));
const tx = await contract.depositWithPermit(p.value, p.deadline, p.v, p.r, p.s);

Note on version: The USDC contract's version() must be called at runtime, not hardcoded.
Some EIP-2612 implementations hardcode "1" — this will produce an invalid signature if the
deployed contract uses a different version string.