> ## Content Index
> Fetch the complete content index at: https://stablecoininsider.org/llms.txt
> Use this file to discover other available public pages before exploring further.

# How to Send USDC with the CDP SDK (2026)
- URL: https://stablecoininsider.org/how-to-send-usdc-with-the-cdp-sdk/
- Published: 2026-10-12T06:01:00.000Z
- Updated: 2026-10-12T06:23:55.000Z
- Description: CDP SDK account.transfer for USDC on Base: parseUnits with 6 decimals, EOA vs Smart Account hashes, and why token usdc fails on ethereum.
- Author: Alexandra
- Tags: AI, Stablecoins

Coinbase's send-transaction docs show native ETH transfers first. Stablecoin operators need the other path: how the **CDP SDK** turns a USDC amount into an ERC-20 transfer on Base, when the usdc shortcut works, and what breaks when you leave Base.

This guide is a Stablecoin Insider package audit of @coinbase/cdp-sdk 1.58.0: install, account.transfer for EOA and Smart Account, decimals, Base vs Base Sepolia network strings, policy hooks, and the address-map footgun Stablecoin Insider reproduced from the published transfer utils. No CDP API keys were present in this environment, so no live transaction hashes were invented; live faucet and broadcast steps are labeled unavailable vs locally tested.

### Key Takeaways

- Prefer account.transfer({ token: "usdc", amount: parseUnits(..., 6) }) over hand-rolled sendTransaction for Base USDC.
- The usdc shortcut resolves only on base and base-sepolia; on ethereum or arbitrum it returns the literal string "usdc".
- EOA transfer returns transactionHash; Smart Account transfer returns userOpHash and needs waitForUserOperation.
- USDC is 6 decimals: 25.50 USDC is 25500000n, not parseEther("25.50").
- Attach CDP policies (netUSDChange, evmAddress allowlists) before agents hold production USDC.

🧭

What this guide is: an operator read of @coinbase/cdp-sdk 1.58.0 (npm latest as of 11 October 2026; published 6 October 2026 UTC), plus the Coinbase Developer Platform send-transactions and TypeScript SDK docs. Stablecoin Insider unpacked the tarball, ran getErc20Address against the published address map, and checked TransferOptions types. No mainnet or testnet funds moved; CDP API credentials were unavailable in this run.

## What the CDP SDK is (and how it differs from AgentKit)

The Coinbase Developer Platform SDK is the Node/TypeScript client for CDP Server Wallets. The [@coinbase/cdp-sdk package on npm](https://unpkg.com/browse/@coinbase/cdp-sdk@1.58.0/) describes itself as the SDK for the Coinbase Developer Platform Wallet API. You create EOA or Smart Account wallets in Coinbase's custody plane, then call sendTransaction, transfer, swap, and policies from your backend.

It is not AgentKit, not the Agentic Wallet MCP/CLI, and not Business Checkouts. Those are adjacent Coinbase surfaces Stablecoin Insider already covered: [x402 with AgentKit](https://stablecoininsider.org/how-to-pay-for-an-x402-api-with-coinbase-agentkit/), [agentic wallet for USDC](https://stablecoininsider.org/how-to-create-a-coinbase-agentic-wallet-for-usdc/), [MCP and CLI for agents](https://stablecoininsider.org/how-to-use-coinbase-for-agents-with-mcp-and-cli/), and [Business Checkouts for agentic USDC](https://stablecoininsider.org/how-to-accept-agentic-usdc-with-coinbase-business-checkouts/). This post is specifically about @coinbase/cdp-sdk account.transfer for USDC.

Python ships as [cdp-sdk on PyPI](https://pypi.org/project/cdp-sdk/) (1.48.2 when checked). The React/web path uses @coinbase/cdp-hooks, including useSendUsdc. This how-to stays on the Node TypeScript server path that agents and backends actually run.

## npm facts Stablecoin Insider checked on 11 October 2026

| Package                                                                                    | Version | Weekly downloads                                                               | Role                            |
| ------------------------------------------------------------------------------------------ | ------- | ------------------------------------------------------------------------------ | ------------------------------- |
| [@coinbase/cdp-sdk](https://unpkg.com/browse/@coinbase/cdp-sdk@1.58.0/)                    | 1.58.0  | [1,077,237](https://api.npmjs.org/downloads/point/last-week/@coinbase/cdp-sdk) | Server Wallet TypeScript SDK    |
| [@coinbase/cdp-hooks](https://api.npmjs.org/downloads/point/last-week/@coinbase/cdp-hooks) | latest  | [12,750](https://api.npmjs.org/downloads/point/last-week/@coinbase/cdp-hooks)  | React hooks (useSendUsdc, etc.) |
| [cdp-sdk (PyPI)](https://pypi.org/project/cdp-sdk/)                                        | 1.48.2  | n/a (PyPI)                                                                     | Python twin                     |

Source: npm registry metadata and the [npm downloads API](https://api.npmjs.org/downloads/point/last-week/@coinbase/cdp-sdk) for 3–9 October 2026\. Monthly downloads for @coinbase/cdp-sdk over 10 September to 9 October 2026 were [4,705,612](https://api.npmjs.org/downloads/point/last-month/@coinbase/cdp-sdk). Those counts include CI and transitive installs; they still show how widely the CDP SDK sits in agent and payments stacks versus thin agent frameworks.

Direct dependencies in the 1.58.0 package.json include viem, jose, axios, zod, bs58, @solana/kit, @solana-program/token, and @solana-program/system. Optional peer deps cover the @x402/\* stack. The package homepage points at the [coinbase/cdp-sdk GitHub repository](https://github.com/coinbase/cdp-sdk).

## Install and auth (what you need before any USDC send)

```
npm install @coinbase/cdp-sdk viem
# Optional for confirmations / parseUnits helpers: viem is already a dependency

export CDP_API_KEY_ID="YOUR_API_KEY_ID"
export CDP_API_KEY_SECRET="YOUR_API_KEY_SECRET"
export CDP_WALLET_SECRET="YOUR_WALLET_SECRET"
```

Per the [TypeScript SDK overview](https://docs.cdp.coinbase.com/sdks/cdp-sdks-v2/typescript), CdpClient() reads those three env vars, or you pass apiKeyId, apiKeySecret, and walletSecret explicitly. Without a wallet secret you can create accounts in some flows, but you cannot sign spends. Stablecoin Insider did not have live CDP credentials in this environment, so createAccount / requestFaucet / transfer against Coinbase's API are marked unavailable below; the code paths and types were verified from the published 1.58.0 tarball.

🔐

Auth note: keep CDP\_WALLET\_SECRET and API secrets in a secret manager, not in agent chat logs. Rotate if a prompt dump ever includes them. Policies (covered later) are the second control plane after secret hygiene.

## The API you actually want: account.transfer for USDC

Coinbase's [Send Transactions docs](https://docs.cdp.coinbase.com/wallets/using-wallets/send-transactions) show two USDC patterns for Node: (1) encodeFunctionData + cdp.evm.sendTransaction against the USDC contract, and (2) the higher-level account.transfer helper documented in the [TypeScript SDK transfer section](https://docs.cdp.coinbase.com/sdks/cdp-sdks-v2/typescript). Prefer transfer. It picks the ERC-20 path, encodes transfer(to, amount), and on Base resolves the usdc symbol for you.

```
import { CdpClient } from "@coinbase/cdp-sdk";
import { parseUnits } from "viem";

const cdp = new CdpClient();
const account = await cdp.evm.getOrCreateAccount({ name: "SciAgentUsdc" });

// Atomic units: USDC has 6 decimals
const { transactionHash } = await account.transfer({
  to: "0xRecipientAddressHere00000000000000000001",
  amount: parseUnits("25.50", 6), // 25500000n
  token: "usdc",
  network: "base-sepolia", // or "base" for mainnet
});
console.log("EOA USDC tx:", transactionHash);
```

TransferOptions in [types.d.ts for 1.58.0](https://unpkg.com/@coinbase/cdp-sdk@1.58.0/%5Ftypes/actions/evm/transfer/types.d.ts) requires amount as a bigint, token as "eth" | "usdc" | Hex, and network as a SendEvmTransactionBodyNetwork or EvmUserOperationNetwork string. Passing a human-readable string like "25.50" for amount is a TypeScript error on the published types, even though one older docs snippet shows a string. Stick to parseUnits.

## Decimals: the 6 vs 18 trap

Circle lists USDC as 6 decimals on every supported chain in the [USDC contract addresses reference](https://developers.circle.com/stablecoins/usdc-contract-addresses). viem's [parseUnits](https://viem.sh/docs/utilities/parseUnits) converts a decimal string into atomic units. parseEther always uses 18 decimals and is wrong for USDC.

| Human amount        | Correct (6 decimals) | Wrong (parseEther / 18 decimals)   | Ratio wrong/correct |
| ------------------- | -------------------- | ---------------------------------- | ------------------- |
| 0.01 USDC           | 10000n               | 10000000000000000n                 | 1,000,000,000,000×  |
| 25.50 USDC          | 25500000n            | 25500000000000000000n              | 1,000,000,000,000×  |
| Docs example 10000n | 0.01 USDC            | if you thought 10000 meant dollars | n/a                 |

Source: Stablecoin Insider local arithmetic against [viem parseUnits](https://viem.sh/docs/utilities/parseUnits) semantics and [Circle USDC decimals](https://developers.circle.com/stablecoins/usdc-contract-addresses).

Stablecoin Insider's take: treat every USDC amount as bigint atomic units at the boundary of your agent tool. Convert once with parseUnits(amount, 6), never float, never parseEther. The same class of bug is what made the ElizaOS EVM plugin sign ETH for a USDC request in Stablecoin Insider's [ElizaOS EVM plugin test](https://stablecoininsider.org/elizaos-evm-plugin-send-usdc/).

## EOA vs Smart Account: two transfer return types

CDP Server Wallets support classic EOAs (type evm-server) and ERC-4337 Smart Accounts (type evm-smart). The transfer helper switches strategy based on account type.

| Path          | Create                                                  | USDC send                  | Return value    | Gas                                                     |
| ------------- | ------------------------------------------------------- | -------------------------- | --------------- | ------------------------------------------------------- |
| EOA           | cdp.evm.createAccount / getOrCreateAccount              | account.transfer(...)      | transactionHash | Account pays gas in ETH/native                          |
| Smart Account | createSmartAccount / getOrCreateSmartAccount({ owner }) | smartAccount.transfer(...) | userOpHash      | Paymaster optional; Base Sepolia often gasless per docs |

From the published [accountTransferStrategy.js](https://unpkg.com/@coinbase/cdp-sdk@1.58.0/%5Fesm/actions/evm/transfer/accountTransferStrategy.js): for token !== "eth" it resolves the ERC-20 address, encodes erc20Abi.transfer(to, value), and calls sendEvmTransaction. From [smartAccountTransferStrategy.js](https://unpkg.com/@coinbase/cdp-sdk@1.58.0/%5Fesm/actions/evm/transfer/smartAccountTransferStrategy.js): the same encodeFunctionData path is wrapped in sendUserOperation with an optional paymasterUrl. That matches [ERC-4337](https://eips.ethereum.org/EIPS/eip-4337) user-operation semantics rather than a plain EIP-1559 tx.

```
const owner = await cdp.evm.getOrCreateAccount({ name: "SciOwner" });
const smart = await cdp.evm.getOrCreateSmartAccount({
  name: "SciSmartUsdc",
  owner,
});

const { userOpHash } = await smart.transfer({
  to: "0xRecipientAddressHere00000000000000000001",
  amount: parseUnits("10", 6),
  token: "usdc",
  network: "base-sepolia",
  // paymasterUrl: "https://your-paymaster.example", // optional
});

const receipt = await smart.waitForUserOperation({ hash: userOpHash });
// receipt.status === "complete" before you treat USDC as delivered
```

Do not log userOpHash as if it were a Basescan transaction hash. Wait for waitForUserOperation, then use the underlying transaction hash from the receipt when you need an explorer link.

## Base vs Base Sepolia network strings

Transfer network strings are lowercase hyphenated CDP names, not viem chain objects. For USDC sends you almost always want "base" or "base-sepolia". SendEvmTransactionBodyNetwork in the OpenAPI client also lists ethereum, ethereum-sepolia, avalanche, polygon, optimism, arbitrum, arbitrum-sepolia, world, and world-sepolia for EOA sends.

Smart Account network validation is stricter in code than the README prose. isValidNetworkForAccount requires the network to be in EvmUserOperationNetwork (base, base-sepolia, arbitrum, optimism, zora, polygon, bnb, avalanche, ethereum, ethereum-sepolia). The README still says Smart Accounts are only supported on Base and Base Sepolia today. Prefer Base for production USDC Smart Accounts until Coinbase expands that support note.

| Network string | USDC contract (Circle / CDP map)                                                                                                           | Faucet token tips                                          |
| -------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------- |
| base           | [0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913](https://basescan.org/token/0x833589fcd6edb6e08f4c7c32d4f71b54bda02913)                        | Mainnet: fund with real USDC + ETH for gas                 |
| base-sepolia   | 0x036CbD53842c5426634e7929541eC2318f3dCF7e                                                                                                 | cdp.evm.requestFaucet({ token: "usdc" \| "eth" }) per docs |
| ethereum       | [0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48](https://developers.circle.com/stablecoins/usdc-contract-addresses) (pass as Hex; see footgun) | No usdc shortcut in CDP map                                |

USDC addresses cross-checked against [Circle USDC contract addresses](https://developers.circle.com/stablecoins/usdc-contract-addresses) and CDP [transfer/utils.js](https://unpkg.com/@coinbase/cdp-sdk@1.58.0/%5Fesm/actions/evm/transfer/utils.js).

## Stablecoin Insider's test: the usdc address-map footgun

The published [getErc20Address helper in utils.js](https://unpkg.com/@coinbase/cdp-sdk@1.58.0/%5Fesm/actions/evm/transfer/utils.js) only maps usdc for two networks:

```
// @coinbase/cdp-sdk 1.58.0 _esm/actions/evm/transfer/utils.js
const addressMap = {
  base: { usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" },
  "base-sepolia": { usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e" },
};
export function getErc20Address(token, network) {
  return addressMap[network]?.[token] ?? token;
}
```

Stablecoin Insider ran that function locally against the same map (artifact nodetest/erc20\_address\_map.json). Results:

| token                                      | network      | Resolved value                             | Safe?          |
| ------------------------------------------ | ------------ | ------------------------------------------ | -------------- |
| usdc                                       | base         | 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 | Yes            |
| usdc                                       | base-sepolia | 0x036CbD53842c5426634e7929541eC2318f3dCF7e | Yes            |
| usdc                                       | ethereum     | usdc (literal string)                      | No             |
| usdc                                       | arbitrum     | usdc (literal string)                      | No             |
| usdc                                       | optimism     | usdc (literal string)                      | No             |
| usdc                                       | polygon      | usdc (literal string)                      | No             |
| 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48 | ethereum     | 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48 | Yes (pass Hex) |

Source: Stablecoin Insider local reproduction of getErc20Address from @coinbase/cdp-sdk 1.58.0 on 11 October 2026.

⚠️

Warning: token: "usdc" with network: "ethereum" (or arbitrum, optimism, polygon) does not resolve to Circle's USDC. The helper returns the string "usdc", which is not a contract address. Pass the Circle contract as Hex, or stay on base / base-sepolia for the shortcut.

This is the gap between the competitor send-transactions page (which shows Base Sepolia examples) and production multi-chain agent code. The docs are not wrong for Base. They are incomplete for everywhere else.

## Hand-rolled sendTransaction USDC (when you need it)

If you already build calldata elsewhere, or you are on a network outside the usdc map, use the pattern from the [Send Transactions USDC section](https://docs.cdp.coinbase.com/wallets/using-wallets/send-transactions):

```
import { encodeFunctionData, parseUnits } from "viem";

const USDC = {
  "base-sepolia": "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
  base: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
  ethereum: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
};

const data = encodeFunctionData({
  abi: [{
    name: "transfer",
    type: "function",
    inputs: [
      { name: "to", type: "address" },
      { name: "amount", type: "uint256" },
    ],
    outputs: [{ type: "bool" }],
  }],
  functionName: "transfer",
  args: ["0xRecipient", parseUnits("25.50", 6)],
});

const { transactionHash } = await cdp.evm.sendTransaction({
  address: account.address,
  network: "base",
  transaction: { to: USDC.base, data },
});
```

That is the same ERC-20 [transfer](https://eips.ethereum.org/EIPS/eip-20) the accountTransferStrategy encodes with viem's erc20Abi. Use network-scoped accounts (account.useNetwork("base")) when you want CDP's managed RPC and waitForTransactionReceipt without repeating the network argument, as shown in the send-transactions docs.

## Solana USDC note (same SDK, different amount rules)

Solana account.transfer accepts token: "usdc" with amount as a string like "0.01" in the TypeScript docs, and the published [solana/transfer.js](https://unpkg.com/@coinbase/cdp-sdk@1.58.0/%5Fesm/actions/solana/transfer.js) builds a transferChecked instruction after fetchMint, using on-chain decimals. That is safer than the EVM path's caller-supplied bigint. EVM still needs you to pass 6-decimal atomics yourself. For Solana agent kits Stablecoin Insider separately tested the [Solana Agent Kit USDC path](https://stablecoininsider.org/how-to-send-usdc-with-solana-agent-kit/).

## Policy limits before agents hold USDC

CDP policies are first-class in the SDK (cdp.policies.createPolicy). For USDC agent wallets, Stablecoin Insider's minimum bar is:

- **evmAddress allowlist** on signEvmTransaction / sendEvmTransaction so the agent can only hit known recipients or the USDC contract.
- **netUSDChange caps** so a single compromised prompt cannot drain the wallet in one user op.
- **Account-scoped policy IDs** passed at createAccount({ accountPolicy }) rather than only a loose project policy.
- **Separate owner vs spend keys** when using Smart Accounts: the owner signs user ops; keep that owner offline relative to the agent runtime.

Wire those before mainnet USDC. For product-level spend design patterns, see [how to set spend limits on an AI agent USDC wallet](https://stablecoininsider.org/how-to-set-spend-limits-ai-agent-usdc-wallet/) and [how to set up an AI agent wallet](https://stablecoininsider.org/how-to-set-up-an-ai-agent-wallet/).

## Worked Base Sepolia checklist (unavailable vs local)

| Step                                        | Status in this SCI run   | What you do with keys                   |
| ------------------------------------------- | ------------------------ | --------------------------------------- |
| npm install @coinbase/cdp-sdk@1.58.0        | Done (tarball unpacked)  | Pin 1.58.0 in package.json              |
| Inspect transfer utils / strategies / types | Done (local)             | Open \_esm/actions/evm/transfer/\*      |
| getErc20Address matrix                      | Done (local JSON)        | Refuse usdc shortcut off Base           |
| CdpClient createAccount                     | Unavailable (no API key) | Export CDP\_\* secrets                  |
| requestFaucet USDC+ETH on base-sepolia      | Unavailable              | Await faucet txs before transfer        |
| account.transfer 0.01 USDC                  | Unavailable              | parseUnits("0.01", 6) + token usdc      |
| Basescan confirm Transfer event             | Unavailable              | Verify token contract, not native value |

When credentials are present, the happy path is faucet → transfer → waitForTransactionReceipt (EOA) or waitForUserOperation (Smart Account) → explorer check that the [Base USDC contract](https://basescan.org/token/0x833589fcd6edb6e08f4c7c32d4f71b54bda02913) emitted Transfer. A native ETH send with empty calldata is always a failure for a USDC request.

## Named footguns (do not skip)

- **usdc shortcut is Base-only.** Everywhere else pass Circle's contract Hex.
- **amount is bigint atomic units on EVM.** Types reject human strings; docs snippets that pass "0.01" on EVM are stale relative to 1.58.0 types.
- **userOpHash ≠ transactionHash.** Smart Account operators who paste the wrong hash into support threads lose an hour.
- **EOA needs gas.** USDC alone is not enough; faucet eth on Sepolia or fund ETH on Base.
- **Policies are optional until they are not.** An agent with transfer and no allowlist is a hot wallet with a chat prompt.
- **AgentKit / MCP / CLI are different products.** Do not copy-paste those env vars into CdpClient and expect the same surface.

💡

Stablecoin Insider's take: for server-side USDC on Base, @coinbase/cdp-sdk 1.58.0 account.transfer is the right primitive. It is clearer than hand-rolled sendTransaction, and it is safer than agent frameworks that treat "USDC" as native ETH. Stay on Base for the usdc shortcut, pass parseUnits with 6 decimals, wait on the correct hash type, and put CDP policies in front of any agent that can call transfer. Treat every other network as "pass the Circle address explicitly" until Coinbase widens the address map.

---

If you are choosing rails for agents more broadly, compare this Server Wallet path with [AI agents for stablecoins in 2026](https://stablecoininsider.org/ai-agents-for-stablecoins-in-2026/), [the x402 protocol overview](https://stablecoininsider.org/x402-protocol/), and cross-chain USDC via [Circle Bridge Kit](https://stablecoininsider.org/how-to-transfer-usdc-with-circle-bridge-kit/) when the recipient is on another chain.

[Open CDP Send Transactions docs](https://docs.cdp.coinbase.com/wallets/using-wallets/send-transactions)

Paying an x402 API from a Coinbase agent stack instead of a raw Server Wallet transfer? Start with the AgentKit guide.

[How to Pay for an x402 API with Coinbase AgentKit ](https://stablecoininsider.org/how-to-pay-for-an-x402-api-with-coinbase-agentkit/) 

[How to Create a Coinbase Agentic Wallet for USDC (2026)Related Coinbase agent wallet path (distinct from CDP SDK Server Wallet transfer).![](https://stablecoininsider.org/favicon.ico)Stablecoin Insider](https://stablecoininsider.org/how-to-create-a-coinbase-agentic-wallet-for-usdc/)

## FAQ

#### What is the CDP SDK?

It is Coinbase's official TypeScript client ([@coinbase/cdp-sdk](https://unpkg.com/browse/@coinbase/cdp-sdk@1.58.0/)) for CDP Server Wallets: create EOA/Smart Accounts, send transactions, transfer tokens, swap, and manage policies from a backend.

#### How do I send USDC with the CDP SDK on Base?

Create or load an EVM account, then call account.transfer with token: "usdc", network: "base" or "base-sepolia", and amount: parseUnits("25.50", 6). Confirm with waitForTransactionReceipt (EOA) or waitForUserOperation (Smart Account).

#### Why did token "usdc" fail on Ethereum?

In 1.58.0, getErc20Address only maps usdc for base and base-sepolia. On ethereum it returns the literal string "usdc". Pass Circle's Ethereum USDC address ([contract list](https://developers.circle.com/stablecoins/usdc-contract-addresses)) as Hex instead.

#### EOA vs Smart Account for USDC: which should agents use?

EOAs are simpler (transactionHash, account pays gas). Smart Accounts add ERC-4337 user ops, optional paymasters, and a separate owner. For gasless Base Sepolia tests, Smart Accounts are convenient; for clear ops runbooks, many teams still start with EOAs plus policies.

#### How many decimals does USDC use in the CDP SDK?

Six. Use [parseUnits(amount, 6)](https://viem.sh/docs/utilities/parseUnits). Never parseEther for USDC. 0.01 USDC is 10000n atomic units.

#### Is this the same as Coinbase AgentKit?

No. AgentKit is an agent toolkit (including x402 payments). The CDP SDK is the Server Wallet API client. See Stablecoin Insider's [AgentKit x402 guide](https://stablecoininsider.org/how-to-pay-for-an-x402-api-with-coinbase-agentkit/) for that stack.

#### What were the npm download counts on 11 October 2026?

Per the [npm downloads API](https://api.npmjs.org/downloads/point/last-week/@coinbase/cdp-sdk), @coinbase/cdp-sdk recorded 1,077,237 downloads in the week 3–9 October 2026, and 4,705,612 in the prior 30 days. @coinbase/cdp-hooks recorded 12,750 weekly downloads in the same week.

#### Can Stablecoin Insider show a live transaction hash from this test?

No. This run had no CDP API credentials, so createAccount, faucet, and transfer against Coinbase's API were unavailable. The address-map and type analysis were done from the published 1.58.0 package; live hashes would require your own keys on base-sepolia.

---

This content is provided for informational and educational purposes only and does not constitute financial, investment, legal, or tax advice; no material herein should be interpreted as a recommendation, endorsement, or solicitation to buy or sell.