Summary: This practical integration guide is here to help both decision-makers and engineers navigate the world of native USDC on Base. You'll be working with the main contract found at 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913. We've loaded up on some solid production-grade code examples, handy migration tips straight from USDbC, and insights about CCTP V2 fast transfers. Plus, we’ve thrown in some best practices for operations to help you out! On top of that, it connects to trustworthy sources, so your team can keep pushing ahead with confidence.

Base USDC Contract Address 0x833589: Integration Guide for Developers

USDC is directly issued on Base, and if you're looking for its verified proxy contract, you can check it out at 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913. So, what we’ve got here is the "FiatTokenProxy" for USD Coin. It's run by Circle and is specifically set up for the Base mainnet. Just a quick heads up--make sure you don’t confuse this with the older bridged USDbC token! If you want to dive deeper into this, just head over to the official link: developers.circle.com. Happy exploring!

The short version:

Hey there! So, if you’re on the hunt for native USDC on Base (that’s the one with the symbol USDC), you can track it down at this address: 0x833589…2913. Happy searching! Hey, if you want to dive deeper into the details, just hop over to developers.circle.com. There’s a ton of info waiting for you! If you're looking for bridged USDC on Base (which goes by the symbol USDbC), you can find it at this address: 0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA. Happy trading! A lot of apps have already made the jump, but there’s still some liquidity floating around here and there. If you're looking for more details, check out circle.com. They've got you covered! Hey there! Just a quick note: the Base mainnet has a chainId of 8453, which you might also see as 0x2105. Hey, just wanted to give you a quick heads-up! The public RPC you’ll find at https://mainnet.base.org is really just for development purposes. Hey, if you're working on live apps, don’t forget to choose a solid production node provider. It's really important! If you want to dig into the nitty-gritty details, check out docs.base.org. It'll give you all the info you need about building on-chain nodes!

Your Go-To Playbook for Using USDC on Base

I've put together a really useful playbook to guide you through the process of integrating, testing, bridging, and managing USDC on Base. The goal here is to help you do all of this while keeping risks to a minimum. So, let’s get started!

1. Integration

Alright, let’s dive in and get USDC integrated into your Base setup without a hitch.

Get your space ready: First things first, grab your tools and tidy up your workspace. You want everything organized and within reach!
Get the right libraries installed: You’re going to need a few packages for this. Feel free to take a look at the documentation for some helpful tips!
Link Up with Base: Go ahead and use the official API to make that connection! Here's a little code snippet to kick things off for you:

const baseAPI = require('base-api');
const client = baseAPI.connect({ apiKey: 'YOUR_API_KEY' });

2. Testing

Now that you’ve got everything ready to go, it’s time to see how it all works!

Come up with test cases: Take some time to brainstorm all the different situations you might run into.
Run tests: Start off by using a testnet environment. It’s a great way to experiment without any real risks! It's a really awesome way to make sure everything's running smoothly and you don't have to worry about a thing.
Watch out for bugs: Make sure to keep an eye open for any hiccups in your transactions.

3. Bridging

Next up, we're going to bridge USDC, which means you'll have a smooth and simple way to transfer it across different networks.

Pick Your Bridge: Go ahead and choose a trustworthy bridge that can handle USDC. Don’t forget to check out their fees and how long transactions take. It's super important to know what you're getting into!
Stick to the bridging instructions: Each bridge comes with its own specific steps, so make sure to pay attention and follow them closely.
Check your transactions: Make sure to double-check that your USDC actually arrived on the right network. It’s always a good idea to confirm!

4. Operational Management

Now that we've wrapped up the fun stuff, let’s dive into how we can keep everything running smoothly.

Keep an eye on your transactions: Make sure to use some handy tools to track your USDC transactions. It really helps in finding any oddities.
Stay in the loop: Make sure to check out the latest news from Base and USDC. You don’t want to miss anything important! Changes can really affect how you run things.
Community resources: Feel free to dive into forums and community channels when you're looking for tips and advice. There’s a wealth of knowledge out there, and you might just find exactly what you need!

With this playbook in hand, you're ready to dive into using USDC on Base and keep your risk in check!

1) Verify you’re talking to the right chain and contract

Chain and RPC
chainId: 8453, which is the same as hex 0x2105. Before you jump into any sensitive tasks, it's a smart move to double-check things with eth_chainId or net_version. Better safe than sorry, right? If you want to dive deeper into the details, check it out here. Hey there! If you're diving into development, you'll want to check out the public endpoints. For the main network, you can use mainnet.base.org, and for testing purposes, sepolia.base.org is your go-to. Happy coding! When you're set to start your project, you might want to check out some providers like CDP, Alchemy, QuickNode, and a few others. They've got a solid reputation and can really help you out! If you're interested, you can find all the details right here. Take a look!
USDC Addresses
Base Mainnet: 0x833589…2913 (This is the native version brought to you by Circle). Feel free to check it out on BaseScan! (basescan.org).
Base Sepolia: 0x036CbD53842c5426634e7929541eC2318f3dCF7e (Just a heads up, this is a test token, meaning it doesn’t hold any real cash value). You can check out more details right here. (developers.circle.com).
If you're working with any older setups, you can use USDbC (Bridged) at this address: 0xd9aAEc86…0b6CA. Hey, just a quick tip: it’s a good idea to start using the native USDC from here on out. Trust me, you’ll want to switch to that! You can check it out on BaseScan! (basescan.org).
You should definitely think about hard-coding the token metadata.
- Symbol: “USDC”
Decimals: 6 (All the EVM USDC versions keep it consistent with 6 decimals). (eth.tokenview.io).

Quick tip: Before you go ahead and sign or send out any user transactions, double-check the chainId and token address in your backend. It’s an easy step that can save you from a lot of hassle later on! Taking this easy step can help you avoid getting lost on the way to USDbC and steer clear of those annoying chain replay errors. (chainnodes.org).

2) Understand the proxy pattern and admin controls (why it matters for ops)

So, the 0x833589… proxy is really focused on making those calls to an upgradable FiatToken setup. So, the USDC contracts do have a few centralized roles, like the owner, masterMinter, pauser, and blacklister. This means they can be paused or updated when needed. It's a smart move to have your monitoring and incident playbooks track these events. Take a look at this: basescan.org. You might find it interesting!

What to Keep an Eye On (Programmatically)

Proxy Events: Make sure to take a look at the “Upgraded” and “AdminChanged” events! Here are a few telltale signs that something is getting an upgrade. If you want to dig a little deeper, you can check out more info here.
Pause/Unpause Events: It's really important to keep an eye on these events. If the contract gets paused, you'll definitely want to stop any transfers from going through. Want to know the details? Check it out here!
Blacklist Updates: Make sure to stay updated on any modifications to the blacklist. Just a heads-up: USDC can actually block certain addresses. So, it's a good idea to keep yourself in the loop! If you're looking for more details, you can check it out here.

USDC is here to support you with the latest authorization flows! Check out all the cool things you can do:

EIP-2612 permit: This nifty feature lets you give approvals without using any gas. How convenient is that? Alright, so here's the deal: you just need to create a domain using these details: { name: "USDC", version: "2", chainId, verifyingContract }. It's pretty straightforward! If you want to dive deeper into it, you can find more info here. Give it a look!
EIP‑3009 transferWithAuthorization/receiveWithAuthorization: This nifty feature lets you handle pull or push transfers without the hassle of getting approval ahead of time. How convenient is that? If you want to learn more, just click here. It's got all the details you need!

These features can really make a difference in how you experience things and keep your setup secure. So, definitely take advantage of them!

3) Minimal, production‑ready code snippets

A) Read/Write with Ethers v6 (TypeScript)

If you’re diving into Ethereum and smart contracts, you can’t go wrong with the Ethers library. It's really handy for interacting with the blockchain using TypeScript. Alright, let’s jump right in and explore how you can interact with the blockchain using Ethers v6. We’re going to look at both reading from and writing to it, so let’s get started!

1. Setting Up Your Project

To kick things off, double-check that you’ve got Ethers set up in your TypeScript project. You can totally handle this with npm! It's super simple.

npm install ethers

2. Connecting to Ethereum

Alright, the next step is to hook up to an Ethereum provider. It could be a wallet such as MetaMask or just any JSON-RPC endpoint out there. Alright, let me show you how to get this set up!

import { ethers } from 'ethers';

// Connect to the Ethereum network
const provider = new ethers.InfuraProvider('mainnet', 'YOUR_INFURA_PROJECT_ID');
// or for local development
// const provider = new ethers.JsonRpcProvider('http://localhost:8545');

3. Reading Data from the Blockchain

If you want to read data from a smart contract, you'll need the ABI (that's short for Application Binary Interface) and the address where it's deployed. Alright, imagine you're diving into a straightforward ERC20 token contract.

const tokenAddress = '0xYourTokenAddress';
const tokenABI = [
  'function balanceOf(address owner) view returns (uint256)',
  'function name() view returns (string)',
];

const tokenContract = new ethers.Contract(tokenAddress, tokenABI, provider);

async function getTokenDetails(address: string) {
  const balance = await tokenContract.balanceOf(address);
  const name = await tokenContract.name();
  
  console.log(`Token Name: ${name}`);
  console.log(`Balance: ${ethers.utils.formatUnits(balance, 18)}`);
}

getTokenDetails('0xYourWalletAddress');

4. Writing Data to the Blockchain

When you're looking to send a transaction or jot down some data, you’re going to need a signer--think of it like a wallet--to put your signature on that transaction. So, here’s a simple way to get started:

// Connect to a wallet
const privateKey = 'YOUR_PRIVATE_KEY';
const wallet = new ethers.Wallet(privateKey, provider);

// Create a contract instance with a signer
const contractWithSigner = tokenContract.connect(wallet);

async function transferTokens(to: string, amount: string) {
  const tx = await contractWithSigner.transfer(to, ethers.utils.parseUnits(amount, 18));
  console.log(`Transaction hash: ${tx.hash}`);

  // Wait for the transaction to be mined
  await tx.wait();
  console.log('Transaction mined!');
}

transferTokens('0xRecipientAddress', '10'); // Transfer 10 tokens

5. Conclusion

And that's a wrap! You've just picked up the skills to read from and write to the Ethereum blockchain using Ethers v6 in TypeScript. Pretty awesome, right? Once you've got these basics down, you’ll be ready to tackle more complex interactions and really explore the exciting world of decentralized applications! Happy coding!.

import { ethers } from "ethers";

const BASE_CHAIN_ID = 8453n;
const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" as const;

// Public RPC is rate‑limited; use a provider like CDP/Alchemy in production.
const provider = new ethers.JsonRpcProvider("https://mainnet.base.org");

async function ensureNetwork() {
  const id = await provider.send("eth_chainId", []);
  if (BigInt(id) !== BASE_CHAIN_ID) throw new Error(`Wrong chain: ${id}`);
}

const erc20Abi = [
  "function name() view returns (string)",
  "function symbol() view returns (string)",
  "function decimals() view returns (uint8)",
  "function balanceOf(address) view returns (uint256)",
  "function transfer(address,uint256) returns (bool)",
  "function permit(address owner,address spender,uint value,uint deadline,uint8 v,bytes32 r,bytes32 s)",
  "function nonces(address) view returns (uint256)"
];

export async function getUsdcBalance(addr: string) {
  await ensureNetwork();
  const usdc = new ethers.Contract(USDC_BASE, erc20Abi, provider);
  const [sym, dec, bal] = await Promise.all([
    usdc.symbol(), usdc.decimals(), usdc.balanceOf(addr)
  ]);
  if (sym !== "USDC" || dec !== 6) throw new Error("Unexpected USDC metadata");
  return bal; // in 6‑decimals units
}

This step involves checking the chainId, contract address, and metadata--super straightforward yet really effective. These quick checks can help steer you clear of about 99% of those pesky misconfiguration problems. (docs.base.org).

B) You can get gasless approval by using the EIP-2612 permit on Base Sepolia. Just remember to tweak the chainId and address if you're planning to switch it to the mainnet!

import { TypedDataDomain } from "ethers";

const domain: TypedDataDomain = {
  name: "USDC",
  version: "2",
  chainId: 8453, // Base mainnet; use 84532 for Base Sepolia
  verifyingContract: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
};

const types = {
  Permit: [
    { name: "owner", type: "address" },
    { name: "spender", type: "address" },
    { name: "value", type: "uint256" },
    { name: "nonce", type: "uint256" },
    { name: "deadline", type: "uint256" }
  ],
};

// get nonce via USDC.nonces(owner) then sign the typed data with wallet._signTypedData(domain, types, message)

Hey there! Just a heads up: Circle has released some info about the “USDC v2” EIP‑2612 domain shape. Make sure you're using version “2” to keep your signatures valid. Trust me, it’s really important! Feel free to take a look at it here: circle.com. You won’t want to miss it!

C) Solidity: Always Use SafeERC20 and Handle 6 Decimals

If you’re diving into ERC20 tokens in your Solidity contracts, definitely make sure to use the SafeERC20 library. It’s a game-changer! This handy tool is a lifesaver when it comes to transferring tokens. It helps you dodge those pesky common mistakes, making sure everything goes off without a hitch.

Oh, and don’t forget about that 6-decimal precision! A lot of tokens use 6 decimal places, so when you're checking token balances or doing any calculations, it's super important to pay attention to that. This way, you’ll avoid any annoying rounding errors or inaccuracies. Just a little heads up!

Let me show you a simple way to use SafeERC20 in your contract. It’s pretty straightforward!

import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

contract YourContract {
    using SafeERC20 for IERC20;

    IERC20 public token;

    constructor(IERC20 _token) {
        token = _token;
    }

    function transferTokens(address to, uint256 amount) external {
        token.safeTransfer(to, amount);
    }
}

If you stick to these tips, you'll be sure to keep your token interactions nice and secure! Happy coding!.

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

import {IERC20, SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";

contract PayWithUSDC {
    using SafeERC20 for IERC20;

    IERC20 constant USDC_BASE = IERC20(0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913);

    function pay(address to, uint256 amount6dp) external {
        // amount6dp is in 6‑decimals; e.g., 1 USDC = 1_000_000
        USDC_BASE.safeTransferFrom(msg.sender, to, amount6dp);
    }
}

Just a heads up: USDC has 6 decimal places, so don’t make the mistake of assuming it has 18 like some other tokens. Just a heads-up: you’ll want to keep the amounts consistent across different chains to avoid any sneaky mis-scaling. It’s all about making sure everything lines up properly! Take a look at this: (eth.tokenview.io). You might find it really interesting!

4) Native vs. bridged on Base: avoid USDbC in new builds

Guess what? Native USDC officially launched on Base on September 5, 2023! It's pretty exciting! Circle and Base have been all about helping everyone transition from USDbC to USDC. Hey there! If you need the official addresses, I've got them for you: USDC is 0x833589… and USDbC is 0xd9aAEc86…. Hope that helps! (cointelegraph.com).

Many DEXs have successfully made the switch, but you might still spot a few of those old-school legacy pools lingering around. Just a quick reminder: be sure to set up your token lists and routers to give priority to the native USDC. It’ll help keep everything running smoothly! (cointelegraph.com).

If your app is still running on USDbC, it's definitely smart to think about putting together a migration plan. Oh, and don’t forget to tweak the UI text so it gives a heads-up to users if they happen to pick USDbC by mistake. That's super important! If you're curious to dive deeper into the details, you can find everything you need here. Happy reading!

5) Moving USDC across chains with CCTP V2 (Fast Transfer on Base)

If you're looking to transfer USDC between different chains, Circle's Cross-Chain Transfer Protocol V2 (CCTP V2) is your best bet. It's super reliable and makes the whole process a breeze! So, here's how it works: you burn USDC on the source chain, and then you can mint it right at the destination. It's pretty straightforward--no need for any kind of pool or wrapped asset involved. Easy peasy! Base gives you the choice between Standard and Fast Transfer options, so you can pick what works best for you! Take a look at this: circle.com. It's worth checking out!

What’s New in V2:

Quick Transfers: Say goodbye to long waits! You can now get your settlements in just a few seconds. This is a huge upgrade compared to the usual finality times for L1 and L2 transactions. This feature started out on Ethereum, Avalanche, and Base. If you want to dive deeper into it, check it out here. There’s a lot of interesting stuff you won't want to miss!
Hooks: So, here’s the deal--hooks are a pretty neat feature! They allow you to tag metadata onto actions that take place after a transfer happens at the destination. It’s like adding a little extra info that can help streamline things. We're talking about stuff like auto-swaps and treasury rules here. If you want to dive deeper into this, just click on this link: circle.com. It’s got all the info you need!
Fees: So, the Base Fast Transfer fee is currently sitting at a super low rate of just 1 basis point (0. 01%). Just a quick heads up! Make sure to take a peek at the API before you make each call, since the fees can change. If you’re looking for more details, just check this out here.

Developer Notes:

Hey, just a quick tip! When you’re looking to get accurate fee quotes, definitely use the V2 APIs. They’ll give you the best info. Also, think about whether you want the Fast or Standard options. It really depends on what you’re after in terms of user experience and how much you’re willing to spend. Take a look at this link: (developers.circle.com).

So, you'll still see V1 contracts hanging around for a little while (you can find the Base TokenMessenger V1 at 0x1682Ae6375C4E4A97e4B583BC394c861A46D8962), but honestly, it's a smart move to focus on V2 when you’re working on any new integrations. If you’re looking for more details, check this out: developers.circle.com. It’s got everything you need!

On an operational level, CCTP really helps tackle the problem of fragmented wrapped liquidity. Whenever users show up with native USDC on Base, they first hit the 0x833589… contract. If you want to dive deeper into the topic, check it out here. You'll find some great info!

6) Best‑practice UX: approvals, permits, and paying gas in USDC

Kick things off with the permit first, and if you hit any snags, just revert to getting the approval. Start with the EIP-2612 permit--it's definitely the way to go! It saves us from having to deal with a whole separate approval process.
If you’re using wallets that don’t support typed data, no worries! Just stick with the classic approve option instead. (circle.com). If you're just looking to withdraw funds once and don't really need ongoing access, you should definitely take a look at EIP-3009's receiveWithAuthorization feature. It could be just what you need! It's a really effective way to reduce the chances of getting your approval denied. (circle.com).

Hey, have you considered using Permit2 for your multi-token processes? It could really streamline things for you!

Permit2 makes it super easy to handle your allowances and one-time transfers. Circle has really been advocating for Permit2 in their newest payment systems, aiming to simplify things for developers. (blockchain.news).
You can find gas fees in USDC on the Base platform. Hey there! Great news--thanks to Circle Paymaster, you can now pay your gas fees in USDC while using Base! Just a little heads-up, though: from July 1, 2025, there will be a 10% surcharge on gas fees for regular users, but if you're a developer, you won’t have to worry about that extra cost. You should really think about the ups and downs of using native ETH for your audience. It's definitely something to consider! Take a look at this: circle.com. You might find it interesting!

7) Security, compliance and monitoring checklist for enterprises

USDC actually has some handy admin features that go beyond the usual ERC-20 stuff, and these can be really beneficial for risk management teams.

Pausable: With this feature, you can hit the brakes on all transfers if anything goes sideways. Make sure to keep track of whether things are paused or unpaused. Check it out here.
Blacklist: This feature lets you block any transfers to and from specific addresses that you want to keep away from. Hey team, just a quick reminder to keep an eye on the Blacklisted and UnBlacklisted statuses. If you notice any customers getting affected, please give the support team a heads-up. Thanks! If you want to dig deeper into the details, check this out here.
Upgrades: Thanks to proxy upgrades, you can switch up the way things work behind the scenes. Make sure to link your alerts to the proxy's Upgraded event so you don’t miss out on any updates! If you want to dive deeper into the details, just click here for more info!

Observability Tasks to Program

1. Sign up for BaseScan APIs or Node Logs to keep tabs on USDC events! Make sure to watch out for a few key events: Transfers, Approvals, Pauses and Unpauses, Blacklists and Unblacklists, and Upgrades. If you're looking for all the info you need, just hop on over to basescan.org. You'll find everything there!

2. Get Alerts for These Important Changes:

So, there have been some updates to the implementation address (yep, you guessed it, that's a proxy upgrade!).
In case the contract is put on hold.
Whenever your treasury or key user addresses show up in any blacklist events.

Context for Policy Teams

Alright, let me break it down for you: Circle handles the management of supported chains, and they've actually decided to stop supporting a few of them in the past. One notable example is Tron, which they cut off back in 2024. It's really crucial to ensure that your treasury policies are in sync with what Circle is backing right now. Take a look at their newest chain support matrix to keep yourself updated! If you want to dive deeper into this, you can check it out here. It's definitely worth a read!

8) Migration guide: USDbC to native USDC on Base

Hey there! If you've still got some USDbC chilling in your treasury or pools, there are a few things you might want to consider:

Hey! If you want to take a look at the inventory balances and allowances for USDbC, just head over to this link: 0xd9aAEc86… (basescan.org). Happy exploring!

If you're looking to send native USDC to Base, the way to go is with CCTP--especially V2 if you have that option. It's best not to depend on any third-party wrapped bridges when it comes to USDC. If you're looking for more details, check this out: (circle.com).

Hey, just a quick reminder to update your token allowlist or registry and make sure to mark USDbC as “legacy.” Hey, just a quick heads-up! Don’t forget to prioritize the 0x833589… address in your UI auto-complete and router settings. It'll make things run smoother! If you want to dive deeper into this topic, check it out here: (circle.com).

9) Testing and staging

Feel free to use Base Sepolia (chainId 84532) along with the test USDC address: 0x036CbD5384…f3dCF7e. You can easily set up test wallets with a faucet, but keep in mind that those tokens don’t really hold any value in regular money. (docs.base.org). Hey, just a heads up--let's make sure to double-check the permit flows on Sepolia first. Just a heads up: it's super important that the EIP‑712 domain matches the chainId and verifyingContract perfectly. If they don't line up, you might find your signatures getting rejected. Trust me, you don’t want to deal with that hassle! (circle.com).

10) Common pitfalls we see at 7Block Labs (and how to avoid them)

Combining USDC and USDbC in routers and pools.
Fix: Just remember to stick with one main address for each chain in your token registry and make sure to sign it while you're building.
Let’s make sure to leave USDbC out of the default lists, okay? (circle.com).
Just to clarify, let's go with 18 decimal places for this. Alright, here's the deal: we need to make sure we're normalizing the amounts according to the token decimals because, remember, USDC has 6 decimal points. Let’s throw in some unit tests for those common amounts, like 1 million and 10 million. It'll help us cover the basics! Check it out here.
Skipping the chainId checks on the client side. Hey, just a quick reminder! Before you start building the call data, double-check that eth_chainId is equal to 0x2105. It’s super important to catch any mismatches and reject them right away. This helps us avoid any potential replay issues or routing problems. Better safe than sorry, right? (chainnodes.org).
Using Public RPCs in Real-World Scenarios.
Tip: Consider choosing a dedicated provider like CDP, Alchemy, or QuickNode. It’s also a good idea to set up some backup options just in case! Hey, just a quick heads up! Base's public RPCs are designed for development purposes, so keep in mind that they do have some rate limits. If you're looking for more info, you can dive into the details here.
Ignoring cross-chain UX Here’s the plan: let’s roll out the CCTP V2. We can give people the option to choose between Standard and Fast services based on what they’re willing to pay and how quickly they want things done. Just a heads up--Fast on Base is currently sitting at 1 bps. Don't forget to include those estimated arrival times and fees when you're sharing the info!
(developers.circle.com).

11) Copy‑paste snippets you can ship today

A) Viem Example: Reading Balance and Performing Permit

In this part, we're going to take a look at a straightforward example of how to use Viem. We'll see how to check an account balance and also go through a permit action. Let's dive in!

Step 1: Reading the Balance

Alright, let’s take a look at the balance for a particular address. Here's a handy little code snippet you can use to check your balance:

import { createClient } from 'viem';

// Create a new client instance
const client = createClient({
  // Add your provider details here
});

// Replace with the address you want to check
const address = '0xYourAddressHere';

async function getBalance() {
  const balance = await client.getBalance(address);
  console.log(`Balance for ${address}: ${balance}`);
}

getBalance();

Step 2: Performing a Permit

Alright, let’s dive into the process of getting a permit. Make sure you have the contract details and all the essential parameters ready. Here's a basic example:.

const permitParams = {
  owner: '0xOwnerAddressHere',
  spender: '0xSpenderAddressHere',
  value: '1000000000000000000', // Amount in wei
  deadline: Math.floor(Date.now() / 1000) + 60 * 60, // 1 hour from now
};

async function performPermit() {
  const tx = await client.permit(permitParams);
  console.log(`Permit transaction sent: ${tx}`);
}

performPermit();

Wrap Up

Awesome! You’ve made it! Now you should feel pretty confident about checking your balances and handling permit actions with Viem. Just a quick reminder to swap out those placeholders with your real addresses and contract details! Happy coding!.

import { createPublicClient, http, erc20Abi as viemErc20 } from "viem";
import { base } from "viem/chains";

const client = createPublicClient({ chain: base, transport: http("https://mainnet.base.org") });
const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" as const;

export async function usdcBalance(owner: `0x${string}`) {
  const [symbol, decimals, balance] = await Promise.all([
    client.readContract({ address: USDC_BASE, abi: viemErc20, functionName: "symbol" }),
    client.readContract({ address: USDC_BASE, abi: viemErc20, functionName: "decimals" }),
    client.readContract({ address: USDC_BASE, abi: viemErc20, functionName: "balanceOf", args: [owner] }),
  ]);
  if (symbol !== "USDC" || decimals !== 6) throw new Error("Unexpected USDC metadata");
  return balance;
}

B) Here’s the CCTP V1 contract address on Base--this is where you’ll find everything you need for your legacy migrations and scripts!

Hey there! If you’re still working with V1 flows, like those operations scripts, you’ll want to jot down the Base TokenMessenger (V1) address: 0x1682Ae… But hey, it’s definitely time to think about upgrading to V2. Trust me, it’ll be worth it! Swing by the V2 docs to find the latest addresses and check out the API flow. Happy upgrading! If you're looking for all the info you need, just hop on over to developers.circle.com. It's all there waiting for you!

12) Decision‑maker checklist

If you're planning to launch USDC on Base for your business, here are some important things to keep in mind:

Make sure to have a straightforward list of “canonical tokens” in your code. Just stick with USDC at 0x833589… and that’s it. Keep it simple! Feel free to take a look at it here!

Let's go ahead and integrate CCTP V2 with fee quoting, and we'll also throw in a runtime switch so users can easily choose between Fast and Standard options. Sounds good? Oh, and don’t forget to jot down any decisions you make about the minFinalityThreshold. It's super important for auditing later on! If you want to dive deeper into the details, just check it out here. Happy exploring!

Make sure you keep an eye on stuff like proxy upgrades, pause or blacklist events, and any weird spikes in allowances--like when Permit2 gets misused. It’s super important to stay in the loop on these things! Check it out here for an example!

Create your gas strategy: You can either top up your ETH to cover the fees or go with Circle Paymaster, which allows users to pay using USDC. Hey, just a heads-up! There’s going to be a 10% surcharge starting on July 1, 2025. Thought it’d be good to let you know in advance! If you're looking for more info, you can check it out here.

If you're still working with USDbC, make sure you've got a good migration plan ready to go. Don't forget to share the info clearly, update those UI warnings, and tweak the router priorities as needed! If you're curious to dive deeper, you can check it out here. It’s definitely worth a read!

13) Reference facts at a glance

The mainnet chain ID is 8453, which you can also see as 0x2105 in hexadecimal. Feel free to take a look at it over on chainnodes.org. Hey there! Just wanted to share the USDC Base (native) address with you: it's 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913. Hope that helps! If you’re looking for more info, check out developers.circle.com. They’ve got all the details you need! Hey! Just a heads up, if you’re looking for the address for the Base Sepolia USDC (test), here it is: 0x036CbD53842c5426634e7929541eC2318f3dCF7e. Hope that helps! Take a look at this: developers.circle.com. It's worth checking out!
Just so you know, the USDbC address is 0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA. If you’re looking for more details, check out basescan.org. They’ve got a ton of info there! Hey, great news! CCTP V2: Fast Transfer is officially up and running on Base. The fees are typically around just 1 bps from Base when you’re using it as the source. Pretty cool, right? If you want to dive deeper into that, check out circle.com. There’s some really interesting info over there! By the way, just so you know, USDC has six decimal places. Feel free to take a look for yourself at eth.tokenview.io. It's a great resource to double-check that information!

14) Why Base + native USDC is a strong default

Base offers super low fees, integrates smoothly with EVM, and has a really exciting roadmap for the OP-Stack! And the best part? When you hold native USDC, you can wave goodbye to the headaches that come with wrapped assets. Plus, with CCTP V2, transferring your funds across different chains is a breeze and happens almost instantly. If your team is thinking about settling on a dollar stablecoin, you should definitely consider going with the Base + USDC combo. It's a great option! It gives you a really smooth experience when you’re using it. Plus, it’s easy to combine with other services, and there’s a bunch of cool tools popping up in the ecosystem, like node providers, paymasters, and APIs. Take a look at it here: docs.base.org. You might find it really helpful!

Appendix: links you’ll use repeatedly

Hey, if you're looking for the official USDC contract addresses for the Base mainnet and Base Sepolia, make sure to swing by the Circle docs. They'll have all the details you need! You can check it out here.

Check out the official BaseScan page for the Base USDC proxy! It’s all verified and ready for you to explore. Hey, check this out right here!
Curious about CCTP V2? It's got the lowdown on everything you need to know, including APIs, supported chains, and the fees involved. Check out the full scoop over on Circle’s blog! You can find all the juicy details right here. Looking for the Base RPC and chain settings? You can get all the details you need right here. Hey there! If you're curious about EIP-2612 and want to dive into the details about domains, you should definitely take a look at Circle’s guide on permits. You can find it right here. Happy exploring!

Hey there! If your team needs a hands-on integration review, 7Block Labs has got your back! We can dive deep into your token list, check out router priorities, explore permit flows, and take a good look at your CCTP integration. Let’s make sure everything’s running smoothly! By doing it this way, we’ll help you cut down on risks before you launch and get you to production faster.