Skip to main content
This quickstart walks you through deploying an ERC-1155 Multi-Token contract using Contract Templates and minting your first token. Contract Templates make it easy to integrate smart contracts into your application without writing Solidity code. Deploy contracts in minutes using curated and audited templates that support popular onchain use cases.
Note: This quickstart provides all the code you need to deploy an ERC-1155 contract and mint tokens. You can deploy using either the Console or API.

​
Prerequisites

Before you begin, ensure you have:

​
Evaluate templates

To learn more about the ERC-1155 template or other templates, visit:
  • Console: View templates, their use cases, ABI functions, events, and code.
  • Templates Glossary: Review all templates and their configuration options.

​
Console path

Use the Console and a Console Wallet to deploy a smart contract template and mint a token. This is the preferred method for those new to smart contracts.

​
Step 1: Set up your Console Wallet

Console Wallets are Smart Contract Accounts designed for use within the Console. They leverage Gas Station, eliminating the need to maintain gas for transaction fees. If you don’t have a Console Wallet, you’ll be prompted to create one during deployment.
Console Wallet Deploy Cost: Unlike EOAs, SCAs cost gas to deploy. With lazy deployment, you won’t pay the gas fee at wallet creation as it’s charged when you initiate your first outbound transaction.

​
Step 2: Deploy the smart contract

In the Console:
  1. Navigate to the Templates tab.
  2. Select Multi-Token ERC-1155.
  3. Fill in the deployment parameters:
ParameterDescription
NameThe offchain name of the contract, only visible in Circle’s systems. Use MyERC1155Contract.
Contract NameThe onchain name for the contract. Use MyERC1155Contract.
Default AdminThe address with admin permissions to execute permissioned functions. Use your Console Wallet address.
Primary Sale RecipientThe address that receives first-time sale proceeds. Use your Console Wallet address.
Royalty RecipientThe address that receives royalties from secondary sales. Use your Console Wallet address.
Royalty PercentThe royalty share as a decimal (for example, 0.05 for 5% of secondary sales). Use 0.
NetworkThe blockchain network to deploy onto. Select Arc Testnet.
Select WalletThe wallet to deploy the smart contract from. Select your Console Wallet.
Deployment SpeedThe fee level affecting transaction processing speed (FAST, AVERAGE, SLOW). Select AVERAGE.
  1. Select Deploy.
Console Wallet Creation: After selecting a network, you’ll be prompted to create a Console Wallet. This wallet is automatically created on all available networks. On testnet, a Gas Station Policy is also created.
Once deployed, you’ll return to the Contracts dashboard. The deployment status will initially show Pending, then change to Complete after a few seconds.

​
Step 3: Mint a token

In the Console:
  1. Navigate to the Contracts tab.
  2. Select your MyERC1155Contract.
  3. Select the ABI Functions tab → Write → mintTo.
  4. Fill in the parameters:
ParameterDescription
_toThe wallet address to receive the minted token. Use your Console Wallet address.
_tokenIdThe token ID to mint, identifying the token type in ERC-1155. Use max uint256 (115792089237316195423570985008687907853269984665640564039457584007913129639935) to create token ID 0. For subsequent tokens, use 0 for ID 1, 1 for ID 2, etc.
_uriThe URI for the token metadata, such as an IPFS CID or CDN URL.
_amountThe quantity of tokens to mint. Use 1.
  1. Select Execute Function → ensure your Console Wallet is selected → Execute.
Select View Transaction History to monitor the transaction. Once the state shows Complete, the token has been minted successfully.
Inbound Transaction: You’ll also see an inbound transfer indicating the token was minted to your Console Wallet.

​
API path

Use APIs to deploy a smart contract template and mint a token programmatically. This option requires an API key and a Dev-Controlled Wallet.

​
Step 1: Set up your environment

​
1.1. Get your wallet information

Retrieve your wallet ID using the GET /wallets API. Ensure:
  • Wallet custody type is Dev-Controlled
  • Blockchain is Arc Testnet
  • Account type is SCA (recommended—removes need for gas)
Note your wallet’s address for subsequent steps.

​
1.2. Understand deployment parameters

ParameterDescription
idempotencyKeyA unique value for request deduplication.
nameThe offchain contract name. Use MyERC1155Contract.
walletIdThe ID of the wallet deploying the contract. Use your dev-controlled wallet ID.
templateIdThe template identifier. Use aea21da6-0aa2-4971-9a1a-5098842b1248 for ERC-1155. See Templates.
blockchainThe network to deploy onto. Use ARC-TESTNET.
entitySecretCiphertextThe re-encrypted entity secret. See Entity Secret Management.
feeLevelThe fee level for transaction processing. Use MEDIUM.
templateParametersThe onchain initialization parameters (see below).

​
1.3. Template parameters

ParameterDescription
nameThe onchain contract name. Use MyERC1155Contract.
defaultAdminThe address with admin permissions. Use your Dev-Controlled Wallet address.
primarySaleRecipientThe address for first-time sale proceeds. Use your Dev-Controlled Wallet address.
royaltyRecipientThe address for secondary sale royalties. Use your Dev-Controlled Wallet address.
royaltyPercentThe royalty share as a decimal (for example, 0.05 for 5%). Use 0.

​
Step 2: Deploy the smart contract

Deploy by making a request to POST /templates/{id}/deploy: 
import { initiateDeveloperControlledWalletsClient } from "@circle-fin/developer-controlled-wallets";
import { initiateSmartContractPlatformClient } from "@circle-fin/smart-contract-platform";

const circleDeveloperSdk = initiateDeveloperControlledWalletsClient({
  apiKey: "<API_KEY>",
  entitySecret: "<ENTITY_SECRET>",
});

const circleContractSdk = initiateSmartContractPlatformClient({
  apiKey: "<API_KEY>",
  entitySecret: "<ENTITY_SECRET>",
});

const response = await circleContractSdk.deployContractTemplate({
  id: "aea21da6-0aa2-4971-9a1a-5098842b1248",
  blockchain: "ARC-TESTNET",
  name: "MyERC1155Contract",
  walletId: "<WALLET_ID>",
  templateParameters: {
    name: "MyERC1155Contract",
    defaultAdmin: "<WALLET_ADDRESS>",
    primarySaleRecipient: "<WALLET_ADDRESS>",
    royaltyRecipient: "<WALLET_ADDRESS>",
    royaltyPercent: 0,
  },
  fee: {
    type: "level",
    config: {
      feeLevel: "MEDIUM",
    },
  },
});
Response: 
{
  "data": {
    "contractIds": ["b7c35372-ce69-4ccd-bfaa-504c14634f0d"],
    "transactionId": "601a0815-f749-41d8-b193-22cadd2a8977"
  }
}
A successful response indicates deployment has been initiated, not completed. Use the transactionId to check status.

​
2.1. Check deployment status

Verify deployment with GET /transactions/{id}: 
const response = await circleDeveloperSdk.getTransaction({
  id: "601a0815-f749-41d8-b193-22cadd2a8977",
});
Response: 
{
  "data": {
    "transaction": {
      "id": "601a0815-f749-41d8-b193-22cadd2a8977",
      "blockchain": "ARC-TESTNET",
      "state": "COMPLETE"
    }
  }
}

​
Step 3: Mint a token

Use the mintTo function to mint tokens. The wallet must have MINTER_ROLE. 
const response = await circleDeveloperSdk.createContractExecutionTransaction({
  walletId: "<WALLET_ID>",
  abiFunctionSignature: "mintTo(address,uint256,string,uint256)",
  abiParameters: [
    "<WALLET_ADDRESS>",
    "115792089237316195423570985008687907853269984665640564039457584007913129639935",
    "ipfs://bafkreibdi6623n3xpf7ymk62ckb4bo75o3qemwkpfvp5i25j66itxvsoei",
    "1",
  ],
  contractAddress: "<CONTRACT_ADDRESS>",
  fee: {
    type: "level",
    config: {
      feeLevel: "MEDIUM",
    },
  },
});
Response: 
{
  "data": {
    "id": "601a0815-f749-41d8-b193-22cadd2a8977",
    "state": "INITIATED"
  }
}
Check the transaction status using GET /transactions/{id} as shown above.

​
Summary

After completing this quickstart, you’ve successfully:
  • Deployed an ERC-1155 Multi-Token contract on Arc Testnet
  • Minted your first token using either the Console or API

​
Next steps