Tokenizing Real-World Assets with Circle Contracts

Tokenizing real-world assets (RWAs) requires predictable infrastructure, reliable settlement assets, and smart contract standards that developers can build with confidence. Arc, an open L1 blockchain, provides these foundations through full EVM compatibility and a design focused on supporting economic activity on the internet. Developers can deploy Solidity contracts, reuse established patterns from the Ethereum ecosystem, and integrate directly with Circle-issued assets such as USDC, EURC, and USYC.

This guide demonstrates how to deploy an ERC-20 contract on Arc using Circle Contracts, Circle Templates, and Circle Wallets, minting tokens, and monitoring contract activity in real-time. Templates allow the deployment of pre-audited smart contracts without writing Solidity, while maintaining full compatibility with EVM tooling on Arc. Follow the step-by-step tutorials for deploying contracts, interacting with contracts, and monitoring contract events on Arc.

Setting Up a Dev-Controlled Wallet on Arc Testnet

Before deploying a contract with Contracts, you need a dev-controlled wallet. This wallet will act as the administrator for your ERC-20 contract and submit transactions on Arc. Wallets belong to a wallet set, so the first step is to create a wallet set, then create a wallet in it.

import { initiateDeveloperControlledWalletsClient } from "@circle-fin/developer-controlled-wallets";

const dcw = initiateDeveloperControlledWalletsClient({
  apiKey: "<CIRCLE_API_KEY>",
  entitySecret: "<CIRCLE_ENTITY_SECRET>",
});

// Create a wallet set
const walletSet = await dcw.createWalletSet({
  name: "My Wallet Set",
});

// Create a wallet on Arc Testnet
const wallets = await dcw.createWallets({
  blockchains: ["ARC-TESTNET"],
  count: 1,
  walletSetId: walletSet.data.walletSet.id,
  accountType: "SCA",
});

Example Response:

{
  "data": {
    "wallets": [
      {
        "id": "45692c3e-2ffa-5c5b-a99c-61366939114c",
        "state": "LIVE",
        "walletSetId": "ee58db40-22b4-55cb-9ce6-3444cb6efd2f",
        "custodyType": "DEVELOPER",
        "address": "0xbcf83d3b112cbf43b19904e376dd8dee01fe2758",
        "blockchain": "ARC-TESTNET",
        "accountType": "SCA",
        "updateDate": "2026-01-20T09:39:16Z",
        "createDate": "2026-01-20T09:39:16Z",
        "scaCore": "circle_6900_singleowner_v3"
      }
    ]
  }
}

You will use the following values later when deploying and transferring tokens:

• Wallet ID: <WALLET_ID>
• Wallet Address: <WALLET_ADDRESS>
• Wallet Set ID: <WALLET_SET_ID>

​​Funding the Wallet with Testnet USDC on Arc Testnet

Arc Testnet uses testnet USDC for transaction fees, so the dev-controlled wallet must hold testnet USDC before deploying or interacting with contracts. Funds can be added through:

• Circle Console Faucet
• Circle Faucet

Once funded, the wallet can submit deployments, token mints, and other contract calls on Arc Testnet.

Deploying an ERC-20 Contract on Arc

With a dev-controlled wallet ready, you can deploy an ERC-20 contract using Templates. Templates allow developers to deploy pre-audited smart contracts without writing Solidity, while still exposing the full ABI for interaction. The ERC-20 template is the standard for fungible tokens and provides a foundation for representing tokenized assets.

After configuring the deployment parameters, you can deploy the contract to Arc Testnet using the Contracts SDK:

import { initiateSmartContractPlatformClient } from "@circle-fin/smart-contract-platform";

const scp = initiateSmartContractPlatformClient({
  apiKey: "<CIRCLE_API_KEY>",
  entitySecret: "<CIRCLE_ENTITY_SECRET>",
});

const deployment = await scp.deployContractTemplate({
  id: "a1b74add-23e0-4712-88d1-6b3009e85a86",
  blockchain: "ARC-TESTNET",
  name: "MyTokenContract",
  walletId: "<WALLET_ID>",
  templateParameters: {
    name: "MyToken",
    symbol: "MTK",
    defaultAdmin: "<WALLET_ADDRESS>",
    primarySaleRecipient: "<WALLET_ADDRESS>",
  },
  fee: {
    type: "level",
    config: { feeLevel: "MEDIUM" }
  }
});

Example Response:

{
  "data": {
    "contractIds": ["<CONTRACT_ID>"],
    "transactionId": "<DEPLOYMENT_TX_ID>"
  }
}

Once the transaction reaches a COMPLETE state, the contract is deployed on Arc. The contract starts with 0 token supply. To create tokens, use the mintTo function to mint tokens to addresses as needed.

Minting Tokens from the Deployed Contract on Arc

Once your ERC-20 contract is deployed, you can mint tokens using the mintTo function. This creates new tokens and assigns them to a specified address.

const mint = await dcw.createContractExecutionTransaction({
  walletId: "<WALLET_ID>",
  contractAddress: "<CONTRACT_ADDRESS>",
  abiFunctionSignature: "mintTo(address,uint256)",
  abiParameters: [
    "<WALLET_ADDRESS>",
    "100000000000000000000"  // 100 tokens (with 18 decimals)
  ],
  fee: {
    type: "level",
    config: { feeLevel: "MEDIUM" }
  }
});

Example Response (Mint):

{
  "data": {
    "id": "<MINT_TX_ID>",
    "state": "INITIATED"
  }
}

When the mint transaction finishes with a COMPLETE status, tokens are successfully created and assigned to your wallet address, and the event log includes a Transfer entry showing the zero address as the from address, your wallet as the to address, and the minted amount.

{
  "status": "SUCCESS",
  "events": [
    {
      "event": "Transfer",
      "from": "0x0000000000000000000000000000000000000000",
      "to": "<WALLET_ADDRESS>",
      "value": "100000000000000000000"
    }
  ]
}

At this point:

• Tokens have been minted to your wallet
• Your wallet's balance has been updated
• The transaction is recorded on Arc Testnet

Monitoring Contract Events on Arc

Once your contract is deployed and minting tokens, production applications need real-time visibility into contract activity. Circle provides webhook-based event monitoring that pushes notifications whenever specified events occur on your contracts. This enables you to track mints, transfers and other contract events as they happen on Arc, without polling or managing indexing infrastructure.

To monitor events, you create an event monitor that watches for a specific event signature on your deployed contract. When that event is emitted, Circle sends a webhook notification to your specified endpoint.

import { initiateSmartContractPlatformClient } from "@circle-fin/smart-contract-platform";

const scp = initiateSmartContractPlatformClient({
  apiKey: "<CIRCLE_API_KEY>",
  entitySecret: "<CIRCLE_ENTITY_SECRET>",
});

const eventMonitor = await scp.createEventMonitor({
  blockchain: "ARC-TESTNET",
  contractAddress: "<CONTRACT_ADDRESS>",
  eventSignature: "Transfer(address,address,uint256)",
  webhookUrl: "<WEBHOOK_URL>",
  idempotencyKey: crypto.randomUUID()
});

Once the event monitor is created, any Transfer event from your ERC-20 contract will trigger a webhook notification to that endpoint. 

When a transfer occurs, you'll receive a webhook payload like this:

{
  "subscriptionId": "f0332621-a117-4b7b-bdf0-5c61a4681826",
  "notificationId": "5c5eea9f-398f-426f-a4a5-1bdc28b36d2c",
  "notificationType": "contracts.eventLog",
  "notification": {
    "contractAddress": "0x4abcffb90897fe7ce86ed689d1178076544a021b",
    "blockchain": "ARC-TESTNET",
    "txHash": "0xe15d6dbb50178f60930b8a3e3e775f3c022505ea2e351b6c2c2985d2405c8ebc",
    "userOpHash": "0x78c3e8185ff9abfc7197a8432d9b79566123616c136001e609102c97e732e55e",
    "blockHash": "0x0ad6bf57a110d42620defbcb9af98d6223f060de588ed96ae495ddeaf3565c8d",
    "blockHeight": 22807198,
    "eventSignature": "Transfer(address,address,uint256)",
    "eventSignatureHash": "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
    "topics": [
      "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
      "0x0000000000000000000000000000000000000000000000000000000000000000",
      "0x000000000000000000000000bcf83d3b112cbf43b19904e376dd8dee01fe2758"
    ],
    "data": "0x0000000000000000000000000000000000000000000000000de0b6b3a7640000",
    "firstConfirmDate": "2026-01-21T06:53:12Z"
  },
  "timestamp": "2026-01-21T06:53:13.194467201Z",
  "version": 2
}

The webhook payload includes the transaction hash, block height, block hash, and decoded event parameters. This structure allows you to build real-time dashboards, trigger downstream workflows, or maintain offchain records of onchain activity.

Event monitoring completes the deployment workflow: deploy a contract with Templates, mint tokens with Wallets, and monitor activity with event webhooks. This combination provides the visibility and automation required for production tokenization systems on Arc.

Try Deploying Your Own Contract

Contracts, Templates, and Wallets provide a consistent workflow for deploying smart contracts, creating asset representations, and monitoring activity in real-time on Arc. Templates eliminate the need to write Solidity while maintaining full compatibility with EVM tooling and established development patterns. Arc uses USDC for transaction fees, enabling deployments and contract calls to operate within a stable, dollar-denominated cost model without the need to manage a volatile native gas token.

Arc is designed to support a wide range of tokenized asset and economic workflows. Native assets such as USDC, EURC, and USYC integrate directly with contracts deployed through Templates, enabling developers to build structured systems that benefit from predictable settlement behavior and stable execution costs.

Developers interested in exploring further can experiment directly on Arc, review the reference documentation for Contracts, Templates, and Wallets, or follow step-by-step tutorials for deploying contracts, interacting with contracts, and monitoring contract events. Join the Arc Community Hub, Arc Discord, or Circle Discord to collaborate with other builders and get support as they work through testnet or prepare production workflows.

‍

^{USYC is a digital asset token. Each USYC token serves as a digital representation of a share of the Hashnote International Short Duration Fund Ltd. (the “Fund”), a Cayman Islands registered mutual fund. The Fund has appointed Circle International Bermuda Limited (“CIBL”), a Bermuda Monetary Authority licensed digital asset business, as its token administrator, responsible for the management of USYC on behalf of the Fund.  As used herein, the term “near-instant” and “always” is intended to signify that, under ordinary operating conditions, redemption requests are filled on a near-real-time basis, subject to factors including, without limitation, blockchain network congestion and the Fund’s then-current liquidity position.} 

^{Shares of the Fund and USYC are only available to non-U.S. Persons, as defined under the Securities Act of 1933, as amended. Additional eligibility restrictions may apply.  The information provided herein is solely for educational and informational purposes and should not be construed as an offer to sell or a solicitation of an offer to buy any security, financial instrument, or other product.} 

^{Arc Testnet is offered by Circle Technology Services, LLC (“CTS”). CTS is a software provider and does not provide regulated financial or advisory services. You are solely responsible for services you provide to users, including obtaining any necessary licenses or approvals and otherwise complying with applicable laws.}

^{Arc has not been reviewed or approved by the New York State Department of Financial Services.}

^{The product features described in these materials are for informational purposes only. All product features may be modified, delayed, or cancelled without prior notice, at any time and at the sole discretion of Circle Technology Services, LLC. Nothing herein constitutes a commitment, warranty, guarantee or investment advice.}