Base USDC Contract Address 0x833589FCD6EDB6E08F4C7C32D4F71B54BDA02913: Circle Docs and On-Chain Verification

USDC on Base is actually native, so it hasn't been bridged over. Hey there! This post is designed to help decision-makers and engineering leads like you learn how to verify the canonical contract address using Circle’s documentation and the on-chain data. We'll also dive into how to avoid those pesky integration mistakes and set up best-practice flows--think permit, EIP-3009, and CCTP--with all the latest and most accurate info out there.

---

TL;DR (description)

If you're looking for the official native USDC on Base, you can find it at this address: 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913. Make sure to double-check it before you make any moves! Hey, could you take a minute to cross-reference this with Circle's documentation, Basescan, and the proxy storage slots? Thanks! Don’t forget to incorporate the EIP‑2612 permit, EIP‑3009, and CCTP V2 into your setup. This way, you can make sure your business deployments are not only strong but also future-proof! For more info, just check this out here.

---

Who this is for

Hey there! So, we've got founders, CTOs, and product people gearing up to handle USDC transactions on Base. Exciting stuff!

• Engineering managers are stepping up to oversee custody, treasury, and payment systems.
• The security and compliance teams are putting in a lot of effort to evaluate the risks associated with stablecoin contracts.

---

The canonical address (and how to verify it in 60 seconds)

Sure thing! The mainnet address for Base is 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913. Just a heads up if you need it! You can check out this exact address on Circle's USDC Contract Addresses page. (developers.circle.com).

If you take a look at Basescan, you'll notice that this address is labeled as a verified proxy, specifically the FiatTokenProxy, and it comes with 6 decimal places. Hey, just a quick heads up! The explorer flagged a name mismatch with the Name function in the contract, and that’s pretty crucial for EIP-2612. (basescan.org).

So, if you're looking to dig into the Base mainnet, the chain ID you need to remember is 8453. Just a heads up, double-check that your RPC is actually showing 0x2105 when you run eth_chainId. (docs.base.org).

Quick Checks You Can Script into CI:

Adding quick checks to your Continuous Integration (CI) process can really help you avoid a lot of hassle later on. Here’s a quick list of some useful checks you might want to think about adding to your scripts.

1. Linting

Keep your code nice and organized! Using linting is a great way to spot those pesky little mistakes and make sure you're sticking to coding standards. It really helps keep everything in check! You can definitely use tools like ESLint for JavaScript or Flake8 for Python to help you out. They're super handy for catching those sneaky bugs and keeping your code neat!

# Example for JavaScript
npx eslint .

2. Unit Tests

Unit tests are super important for making sure your code does what it's supposed to do. Hey, make sure you set those up to run automatically! Frameworks like Jest for JavaScript or unittest for Python really simplify the process. Trust me, it’ll save you a lot of time and hassle!

# Example for JavaScript
npm test

3. Code Coverage

Take a moment to see how much of your code is actually being tested! Tools like Istanbul or Coverage.py can really help you out with this. They'll show you what’s covered and where you might need to add a few more tests. It’s super useful for improving your code quality!

# Example for JavaScript
npx istanbul cover npm test

4. Dependency Checks

Staying on top of your dependencies is really crucial for keeping things secure. Make sure to check out tools like npm outdated or pip list --outdated to keep your packages up to date. You definitely don’t want to fall behind on the latest versions!

# Example for npm
npm outdated

5. Building the Project

Make sure your project is building correctly every time. It’s super important! You might just need to run a build script to catch any errors. It's that easy!

# Example for a generic build command
npm run build

6. Format Checks

Make sure your code is always looking sharp! Using tools like Prettier can really help keep things neat and tidy throughout your project. Trust me, it makes a big difference!

# Example for JavaScript
npx prettier --check .

7. Security Scans

Hey, don’t forget about security! It’s super important. Running security scans with tools like Snyk or npm audit is a great way to spot vulnerabilities before they turn into big headaches. Trust me, a little prevention goes a long way!

# Example for npm audit
npm audit

8. Performance Tests

Check how your app is doing by using tools like Lighthouse or WebPageTest. They're great for seeing where your app shines and where it might need a little boost! You definitely want to make sure your app works like a charm for your users!

9. Integration Tests

These tests are all about seeing how different parts of your application play nice with each other. Set them up to run automatically so everything flows smoothly.

10. Notifications

Alright, here's the scoop: you definitely want to stay in the loop! So, go ahead and set up some notifications to give you a heads-up whenever there’s a hiccup in your CI pipeline. That way, you won't be blindsided when things go sideways!

By automating these quick checks, you'll really simplify your CI process. You'll be able to spot issues early on, which means you can deliver a much better product in the end. Happy coding!.

# 1) Confirm you’re on Base mainnet
curl -s https://mainnet.base.org -H 'content-type: application/json' \
  --data '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}' \
| jq -r .result  # expect "0x2105"

# 2) Read decimals/symbol/name directly on-chain
cast call 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 "decimals()(uint8)"      # expect 6
cast call 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 "symbol()(string)"       # "USDC"
cast call 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 "name()(string)"         # often "USD Coin"

Explainer

So, if you check out Basescan's token page, you'll see that it mentions "6 Decimals." It’s also labeled as a proxy called "FiatTokenProxy." Pretty straightforward, right? "Just a heads up, the name you see on the user interface might not exactly match what’s listed in the contract's Name function." Just a quick heads-up: always remember to check name() before you dive into setting up your EIP‑712 domains. It's a smart move! Feel free to take a look at it here!

---

Native USDC vs bridged USDbC on Base (do not confuse them)

• Native USDC (from Circle): 0x833589…2913. Bridged USDC from Ethereum (“USDbC”): Check it out at 0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA.

Hey, just wanted to give you a quick heads-up! Circle's launch notes for Base and the help center from Coinbase really emphasize that these are actually two distinct assets.
Hey there! If you're diving into enterprise treasury or Circle APIs, just a quick tip: it’s best to stick with the native USDC. Trust me, you’ll want to keep it simple! Hey, take a look at the details right here! You’ll find all the info you need.

Practical Guardrails

• Don’t forget to add the native address to your allowlist in the config! Consider treating USDbC like a separate asset altogether and make sure you clearly set up those risk flags. If you’re looking into price routing and AMMs, I’d recommend sticking with USDC pools rather than USDbC ones. Hey, just a quick tip: make sure you take a moment to check your DEX list. You want to be sure you’re picking the right token! Once we launched, we saw that a bunch of DEX interfaces were automatically defaulting to the bridged token. (cointelegraph.com).

---

Deep verification: prove you’re calling the authentic implementation

USDC runs on a proxy system. Feel free to take a look at the EIP-1967 implementation slot and the admin slot if you want to stay updated on any upgrades that might be going on.

• EIP‑1967 implementation slot:
  • Slot key: 0x360894A13BA1A3210667C828492DB98DCA3E2076CC3735A920A3CA505D382BBC If you want to find the implementation address, just take a look at the last 20 bytes of the slot. (eips.ethereum.org).

# Read the implementation slot from the proxy
cast storage 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 \
  0x360894A13BA1A3210667C828492DB98DCA3E2076CC3735A920A3CA505D382BBC
# -> parse the last 20 bytes as the implementation address

# Optional: also watch the admin slot for governance changes
# Admin slot: bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)
cast storage 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 \
  0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103

When you check out Basescan, you'll notice that the proxy is verified as FiatTokenProxy. This totally matches up with what’s detailed in Circle’s stablecoin-evm repo since FiatTokenProxy is linked to the FiatTokenV2_x logic. Make sure to watch out for the "Upgraded(address implementation)" events to catch any updates or changes happening. (basescan.org).

---

The details that bite teams in production

1) Decimals are 6, not 18

So, when it comes to USDC on Base, it actually only uses 6 decimal places. But here’s the catch: a lot of pricing, accounting, and vault strategies often assume it has 18 decimals instead. This mix-up can create some pretty tricky scaling issues with balances. Before jumping into any transfer calculations, it’s a smart move to check that decimals() == 6. This little step will help make sure everything lines up nicely across various chains. Trust me, it’s worth taking the time to do! You can check this out on Basescan's token page too; it clearly shows that the setup has 6 decimals. (basescan.org).

2) EIP‑2612 domain must use the contract’s Name and version “2”

FiatToken V2 sets up the EIP‑712 domain using some key parameters: it includes the name, version "2", and the chainId. When you're working on Base, just a quick reminder: make sure to use the name() from the contract for your typed data. So, instead of writing "USDC," go with "USD Coin." Also, don't forget to set the version to "2." It’s a little thing, but it makes a big difference! "Just a heads up--if you don’t do it, your signatures might get held up." Take a look at this: (holesky.etherscan.io). You might find it interesting!

// viem example: building a permit for USDC on Base
import { createWalletClient, http, parseAbi } from "viem";
import { base } from "viem/chains";

const USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const erc20 = parseAbi([
  "function name() view returns (string)",
  "function nonces(address) view returns (uint256)"
]);

const client = createWalletClient({ chain: base, transport: http("https://mainnet.base.org") });

const [tokenName, nonce] = await Promise.all([
  client.readContract({ address: USDC, abi: erc20, functionName: "name" }),
  client.readContract({ address: USDC, abi: erc20, functionName: "nonces", args: ["0xYourOwner"] })
]);

// EIP-712 domain: name from chain, version "2", chainId 8453, verifyingContract USDC
const domain = { name: tokenName, version: "2", chainId: 8453, verifyingContract: USDC };
// Proceed to sign Permit per EIP-2612

Hey there! So, I just wanted to share some info from Circle's Paymaster documentation. It talks about a few methods based on EIP‑2612 that let you handle gas payments with USDC. It’s pretty neat! If you're considering adopting a gas abstraction model, it's a good idea to align your domain with the specific fields in the contract. Just a little heads-up! Take a look at this: circle.com. You won't want to miss it!

3) Prefer EIP‑3009 for “pull‑free” transfers where it fits

USDC's FiatToken V2 is rolling out EIP-3009, which includes some exciting features: “transferWithAuthorization” and “receiveWithAuthorization.” This cool feature lets you send transfers without any gas fees, thanks to off-chain signed authorizations. If you’re working on contract-to-contract transactions, using receiveWithAuthorization is definitely a good call. It can really help you steer clear of any front-running issues. If you want to dive deeper into it, just click here: eips.ethereum.org. Happy exploring!

// Minimal interface for EIP-3009 functions in USDC
interface IUSDC3009 {
  function transferWithAuthorization(
    address from, address to, uint256 value,
    uint256 validAfter, uint256 validBefore,
    bytes32 nonce, uint8 v, bytes32 r, bytes32 s
  ) external;

  function receiveWithAuthorization(
    address from, address to, uint256 value,
    uint256 validAfter, uint256 validBefore,
    bytes32 nonce, uint8 v, bytes32 r, bytes32 s
  ) external;
}

4) Pay gas in USDC (account abstraction)

Hey everyone! Exciting news--Circle's Paymaster has now got your back with EIP‑2612 permits. This means you can easily set up allowances and even cover user gas fees using USDC. How cool is that? This is a total game-changer! It's going to make the user experience so much smoother by getting rid of the whole hassle of having to top up with ETH. Hey, just a quick reminder to keep those allowance scopes as tight as possible! Take a look at this: (circle.com). It’s pretty cool!

5) Permit2 is a viable alternative for generalized allowance management

So, if you choose Permit2, all you need to do is give it a one-time thumbs up. After that, you’ll be able to use EIP-712 messages for any future transfers. It’s pretty straightforward! Circle has just shared their latest tips and code directions for using USDC with Permit2. Take a look at this: (developers.circle.com). You’ll find some good info there!

---

Cross‑chain flows: CCTP V2 on Base

By 2025-2026, CCTP V2 has really emerged as the top choice for Circle's cross-chain protocol. It's awesome to see that Base is now recognized as domain 6! Plus, it brings along some cool features like Standard Transfer, Fast Transfer, and Hooks. If you’re working with transactions that need to happen quickly, Fast Transfer is a total game changer. It seriously cuts down on settlement latency, making everything flow much smoother! For more info, just head over here: (developers.circle.com). You’ll find all the details you need!

• If you’re still using CCTP V1 (the Legacy version), now's a good time to consider making the switch. They've officially announced that the phase-out will kick off in July 2026. Hey, don’t miss out! Make sure you check out all the latest info over at (circle.com). You’ll find everything you need there!

Pointers for Architects:

Make sure to stick with CCTP as your top choice for moving USDC around. It's really the best way to go! If CCTP isn't an option for a specific chain, that's when you might want to consider using third-party bridges. If you want to dive deeper into it, just check this out: docs.wanchain.org. It’s got all the details you need!

When you're diving into setting up cross-chain intents, just think of it like this: you’ve got a “source” where you burn something, and then there's a “destination” where you mint it. It’s pretty straightforward! Oh, and make sure to keep in mind the gas fees for getting to your destination! With Hooks, you can effortlessly set up post-mint workflows on the destination chain. It's super simple and a great way to streamline your process!

---

Test environments you can trust

Hey, if you're interested, go take a look at the Sepolia test USDC. You can find it at this address: 0x036CbD53842c5426634e7929541eC2318f3dCF7e. Let me know what you think! It's just right for your integration tests and continuous integration. If you want to dive deeper into it, check out the details over at developers.circle.com. Just a heads up, the Base Sepolia chain ID is 84532. Don't forget to keep your mainnet and testnet addresses separate in your settings. It's super important to keep them organized! This will definitely help you steer clear of any accidental mix-ups. If you want more info, check out the details over at docs.base.org. You’ll find everything you need there!

---

Operationalizing USDC on Base: a production checklist

1. Keeping Your Contract Identity and Managing Proxy Hygiene. Make sure to double-check the address with Circle's documentation whenever you're deploying, releasing, or doing a cold start on those important services. It's a good habit to get into! Check out the details here. It's all laid out for you! Hey, don't forget to take a look at the EIP-1967 implementation and double-check those admin slots! It's important to make sure everything's in order. It’s smart to set up alerts for any changes and have a real person give them a thumbs up. If you're looking for more info, you can check it out here. Hey, make sure you subscribe to the Upgraded(address) events! It's a good idea to stay updated on any ownership or role changes related to FiatToken. Keep an eye out for roles like owner, masterMinter, pauser, blacklister, and rescuer. You won’t want to miss any of that action! It’s really important to keep everything documented in an append-only audit log. If you're curious about Circle's stablecoin and want to dive deeper into how everything works, you can check out their documentation right here. It’s got some great insights on the different roles involved!

2) Token Mechanics

As soon as your service kicks off, don’t forget to check that decimals() is equal to 6. It’s a quick step, but super important! This is really important because it helps you keep a “scale” abstraction in your code. Believe me, it’s super important to steer clear of any tricky 18↔6 mismatches. If you want to dive deeper into it, you can check it out here!

Make sure to always use SafeERC20. Don’t just think that approve(…) means the same thing as setting it to zero. It's a good habit to get into! It's definitely a good idea to go with permit or Permit2 to make the experience a whole lot easier for your users. Trust me, it really helps streamline things! If you want to dive deeper into this, take a look at this super helpful guide here. It’s got all the info you need!

1. Signing and EIP-712 Domains.

Alright, let’s dive into the whole signing and EIP-712 domains thing. This is where it gets interesting! Basically, signing is all about creating a digital signature that verifies the authenticity of your data. EIP-712 comes into play to help ensure that our messages and transactions are not just secure, but also easy to read and understand. It introduces a structured way to sign data, making everything super clear. So, whether you’re sending a message or executing a transaction, EIP-712 has got your back by keeping things safe and straightforward. Pretty cool, right? Alright, let’s dive in! First things first, take a look at the name() function on the blockchain. You'll want to set up the EIP-2612 domain with the version labeled as "2" and don’t forget to include the chainId, which should be 8453. Happy coding! Hey, just wanted to give you a quick heads up! It’s probably not a great idea to stick with “USDC” as the name because some explorers might actually display the symbol instead. Feel free to check it out right here: (holesky.etherscan.io). Hey, just a heads up! If you're working with EIP-3009, don’t forget to add receiveWithAuthorization in your contract calls. It's a key step you won't want to skip! This will help you avoid any problems with front-running. Take a look at the details right here: (eips.ethereum.org).

4) Cross-chain

If you're looking into native burn/mint transfers, definitely choose CCTP V2 (that's domain 6 for Base). We're planning to gradually move away from V1, so V2 is the way to go!
For more info, you can click here!

5) Asset Selection and Routing

• Alright, let’s definitely implement a strict ban on USDbC for those crucial USDC transactions. If you choose to back it, just be sure to tag it as “bridged” everywhere, and definitely keep those risk limits and liquidity pools distinct from each other. If you want to dive deeper into it, you can find more info here.

---

Example: on‑chain verification with one script (Node + viem)

import { createPublicClient, http, parseAbi, getAddress } from "viem";
import { base } from "viem/chains";

const USDC = getAddress("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913");
const IMPLEMENTATION_SLOT =
  "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc";
const ADMIN_SLOT =
  "0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103";

const abi = parseAbi([
  "function decimals() view returns (uint8)",
  "function symbol() view returns (string)",
  "function name() view returns (string)",
  "function nonces(address) view returns (uint256)"
]);

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

async function main() {
  // 1) Chain ID check
  const chainId = await client.getChainId();
  if (chainId !== 8453) throw new Error(`Unexpected chainId ${chainId}`); // Base mainnet

  // 2) ERC-20 identity
  const [dec, sym, nm] = await Promise.all([
    client.readContract({ address: USDC, abi, functionName: "decimals" }),
    client.readContract({ address: USDC, abi, functionName: "symbol" }),
    client.readContract({ address: USDC, abi, functionName: "name" })
  ]);
  if (dec !== 6) throw new Error("USDC decimals mismatch; expected 6");

  // 3) EIP-1967 slots
  const implRaw = await client.getStorageAt({ address: USDC, slot: IMPLEMENTATION_SLOT });
  const adminRaw = await client.getStorageAt({ address: USDC, slot: ADMIN_SLOT });
  const impl = `0x${implRaw.slice(26)}`; // last 20 bytes
  const admin = `0x${adminRaw.slice(26)}`;

  console.log({ chainId, symbol: sym, name: nm, implementation: impl, proxyAdmin: admin });
}

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

So, why are we running these checks? Well, they follow the EIP‑1967 spec and are all about keeping you safe. This way, you won’t accidentally send tokens to a scammy address, miscalculate your amounts, or sign off on those sketchy EIP‑712 domains. It's really just about looking out for you! (eips.ethereum.org).

---

Example: gasless allowance and payments with USDC on Base

Implement EIP‑2612 Permit for a Smooth User Experience

To make things easier for users, why not go ahead and add the EIP-2612 permit? It'll definitely help streamline the experience! This lets users approve transactions without needing to pay any gas fees! Super convenient, right?.

Use a Paymaster for Gas Sponsorship in USDC

Whenever it fits into your experience, consider using a Paymaster to take care of those pesky gas fees with USDC. It can really simplify things! That way, your users can enjoy interacting with your dApp without stressing over Ethereum gas prices. It's really all about keeping things simple and fun!

// Pseudocode: sign a Permit for a spender to pull USDC on Base
const domain = {
  name: await client.readContract({ address: USDC, abi, functionName: "name" }),
  version: "2",
  chainId: 8453,
  verifyingContract: USDC,
};
const types = {
  Permit: [
    { name: "owner", type: "address" },
    { name: "spender", type: "address" },
    { name: "value", type: "uint256" },
    { name: "nonce", type: "uint256" },
    { name: "deadline", type: "uint256" },
  ],
};
// Sign and submit permit(...) per Circle Paymaster guidance

If you're diving into Circle's Paymaster documentation, you're in for a treat! They've laid out some really handy code paths that make it super easy to integrate EIP-2612 permits and Account Abstraction (AA). You'll find everything you need right there to get started! So, if you choose to go with Permit2, Circle offers a really safe way to get that one-time approval you need. Take a look at this: circle.com.

---

If you handle cross‑chain USDC: use CCTP V2 patterns

Just a heads up--Base has now moved to domain 6 in CCTP. The good news is that both Fast Transfer and Hooks are fully operational! Hey there! If you're making the switch from V1, definitely take a look at Circle’s migration guide. It'll help make your transition a breeze! Many apps are really focusing on V2 right now since it provides quicker responses and makes it easier to work with other tools. (developers.circle.com).

Operational Advice:

Don't forget to jot down the source burn transaction and the destination mint transaction with their correlation IDs! It's super important to keep track of those. Make sure to keep track of gas prices at your destination, and don’t forget to check out Circle’s new forwarding services and the Bridge Kit. They’re designed to really simplify things for developers, which is pretty cool! Feel free to take a look at it here. You'll find all the info you're looking for!

---

Reference: addresses you’ll actually use

• Base USDC (native): Check it out at 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913! (developers.circle.com).
• Base USDbC (the bridged version, not the one from Circle): Check out this address: 0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA. (circle.com).
• Base Sepolia USDC (testnet): Check it out at 0x036CbD53842c5426634e7929541eC2318f3dCF7e! (developers.circle.com).
• Base chain ID: 8453; Base Sepolia: 84532. (docs.base.org).

---

Emerging best practices we recommend to clients

Hey there! Just a quick reminder to make sure you add USDC (Base) to the global “asset registry.” But don’t forget to follow those strict checks we talked about! Just a heads-up, make sure the chainId is set to 8453!

• Make sure to set the decimals to 6! Make sure the address is 0x8335…2913 and that it's in checksummed format. Just a heads up, make sure that the EIP-2612 domain name matches the on-chain name() exactly. Oh, and don’t forget to check that the version is set to "2" before you dive into signing! Make sure to keep an eye on the proxy setup and the admin slots. It’s a good idea to set up alerts for your on-call team so they can stay in the loop. If you're looking for more info, just head over to eips.ethereum.org for all the details! Hey there! Just a quick tip for when you're dealing with contract-initiated pulls: it's better to use receiveWithAuthorization rather than transferWithAuthorization. Trust me, it’ll make things smoother! This is a solid strategy for guarding against those pesky mempool frontruns. And don’t forget to keep your nonces stored in a central location! If you're looking for more details, check out this link: eips.ethereum.org. It's a great resource! Think of USDbC as its own unique bridged asset, separate from everything else. It’s super important to have clear liquidity and risk policies set up so you know exactly where you stand. For sure, don't just auto-upgrade or mix balances without giving me a heads-up first! If you’re curious for more details, feel free to check this out: circle.com. It’s got some great insights! When you're handling a multi-chain treasury, it's a good idea to go with CCTP V2. Just make sure to note any backup plans and keep an eye on when V1 is being phased out. For the newest updates, just check out circle.com. You’ll find all the latest info there!

---

Conclusion

If you're diving into Base, definitely make sure to check out the native USDC contract. The one you really want to keep on your radar is 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913. Trust me, it’s a key player! Just a heads up, it's a good idea to cross-reference this info with Circle's documentation. Don’t forget to check out Basescan's proxy verification too and take a look at the EIP-1967 slots while you’re at it. Better to be safe than sorry! Once you’ve got that figured out, you can move forward with confidence by keeping it simple with 6-decimal math. Just make sure you’re using the correct EIP-712 domain--go with version “2” for the best results. And don’t forget to use CCTP V2 for those cross-chain transactions. You’ve got this!

Hey there! If you could use a bit of help with your setups or want someone to take a close look at your USDC payment stack, don’t hesitate to get in touch with 7Block Labs. They’ve got your back! They’re here to support you, ensuring everything goes smoothly for your rollout while also being ready for any audits that might come up. Take a look at this link: (developers.circle.com). You'll find some really useful info there!

---

Sources cited

Hey, why not take a look at the USDC contract addresses and some of the docs from Circle? They’ve got some good info there! If you're looking for what you need, check it out here! Hey there! If you want to check out the Base token page for USDC, where you can find all the juicy details like the proxy, decimals, and name notes, just click here. Happy exploring!

• Curious about Base chain IDs and RPC references? Check out this link for everything you need to know! If you're looking for some technical details, take a peek at the EIP-1967 proxy slots and the security notes for EIP-3009. You can find them right here.
• Want to dive into the differences between USDbC and USDC on Base? You can find all the details you need in the Coinbase help section and check out Circle’s announcement here. Give it a look! If you're looking to get into Circle Paymaster permits or need some tips on using Permit2, check out these awesome resources here. They’ve got some pretty useful info that might help you out! Check out all the juicy details about CCTP V2 support for Base, plus some handy migration tips and domain info. You can find everything you need right here.
• Finally, if you're interested in the FiatToken V2 domain versioning (EIP‑2612), you can take a look at it right here.