Building with Stableit: 3 Powerful Use Cases to Move USDC Across Chains
At Stableit, we're reimagining how USDC moves across chains. Without friction, without middlemen, and without wrapped tokens. We’ve built directly on Circle’s Cross-Chain Transfer Protocol (CCTP), the official and native way to transfer USDC securely via burn-and-mint.
But we didn’t stop there.
Stableit wraps this powerful protocol in a production-grade SDK that does all the heavy lifting for you:
- Automatic relaying
- Smart routing
- Gas drop-off on the destination chain
- Gasless transfers
All you need to do is define your intent, source chain, destination chain, amount, and Stableit handles the rest.
Let’s walk through three use cases to see what’s possible.
1. Cross-Chain Payouts
Need to send USDC to multiple recipients across different chains? Stableit allows you to send USDC payouts across different chains from a single treasury wallet. No need to manage separate wallets per chain or worry about native gas tokens on the destination. It’s all abstracted for you.
This is a game-changer for web3 payroll, DAOs distributing bounties or grants, or creator platforms paying out in stablecoins. Stableit ensures that each payout is tracked, confirmed, and fully native on the recipient’s chain.
const payouts = [
{ recipient: "0xAlice", chain: "Arbitrum", amount: "10" },
{ recipient: "0xBob", chain: "Optimism", amount: "25" },
{ recipient: "0xCarol", chain: "Ethereum", amount: "15" },
];
for (const payout of payouts) {
const intent = {
sourceChain: "Ethereum",
targetChain: payout.chain,
amount: payout.amount,
sender,
recipient: payout.recipient,
gasDropoffDesired: 0n,
};
const routes = await sdk.findRoutes(intent);
const route = routes.all[0];
// Listen for transaction lifecycle events
route.transactionListener.on("transaction-included", (event) => {
console.log("Payment transaction included in block:", event.data);
// Store payment record or trigger next step in workflow
});
// Listen for final transfer confirmation
route.progress.on("transfer-redeemed", (event) => {
console.log("Transfer complete. USDC received by:", payout.recipient);
// Mark payout as completed in your system
});
if (await sdk.checkHasEnoughFunds(route)) {
await sdk.executeRoute(route);
} else {
console.warn(`Insufficient funds for ${payout.recipient} on ${payout.chain}`);
}
}Full code example: https://docs.stableit.com/sdk/examples-and-use-cases
2. Treasury Rebalancing
Your treasury is dynamic. Liquidity needs shift constantly between chains, protocols, and operational demands. With Stableit, you can automate the redistribution of USDC across chains to match target vault balances or liquidity requirements.
For example, you can shift idle USDC from Solana to Base to meet a sudden liquidity spike, or prepare for upcoming incentives or launches by reallocating treasury funds ahead of time.
Stableit makes rebalancing fast, gas-efficient, and programmable. You define the strategy, Stableit handles the cross-chain logic, routing, and execution.
// Simulated current vault balances
const TARGET_BALANCE = 50000;
const currentBalances = {
Base: 30000,
Arbitrum: 42000,
Optimism: 48000,
};
const chains = [
{ chain: "Base", recipient: "0xBaseVault" },
{ chain: "Arbitrum", recipient: "0xArbitrumVault" },
{ chain: "Optimism", recipient: "0xOptimismVault" },
];
// Calculate rebalancing needs
const neededTransfers = chains
.map(({ chain, recipient }) => {
const shortfall = TARGET_BALANCE - (currentBalances[chain] || 0);
return shortfall > 0 ? { chain, recipient, amount: shortfall } : null;
})
.filter(Boolean);
// Execute transfers using Stable SDK
for (const transfer of neededTransfers) {
const intent = {
sourceChain: "Ethereum",
targetChain: transfer.chain,
amount: transfer.amount.toFixed(2),
sender,
recipient: transfer.recipient,
gasDropoffDesired: 0n,
};
const routes = await sdk.findRoutes(intent);
const route = routes.all[0];
route.transactionListener.on("transaction-included", (event) => {
console.log(`[${transfer.chain}] Tx included:`, event.data);
});
route.progress.on("transfer-redeemed", () => {
console.log(`[${transfer.chain}] Rebalance complete.`);
});
if (await sdk.checkHasEnoughFunds(route)) {
await sdk.executeRoute(route);
} else {
console.warn(`Not enough funds for ${transfer.chain}`);
}
}Full code example: https://docs.stableit.com/sdk/examples-and-use-cases
3. USDC Consolidation
At the end of a week, month, or quarter, your treasury might be scattered across five or six different chains. That’s a reporting and management headache. Stableit enables you to consolidate USDC from multiple source chains into a single destination, giving you a centralized view of your stablecoin holdings and making audits and reporting seamless.
Whether you're a DAO moving funds into a main wallet, an exchange combining earnings from different chains, or a payment app organizing balances for reporting. Stableit takes care of the complexity, so you can focus on operations, not logistics.
// Simulated USDC balances from different chains
const chainsToConsolidate = [
{
chain: "Polygon",
balance: 11,
chainId: "0x13881",
},
{
chain: "Optimism",
balance: 8,
chainId: "0x45",
},
{
chain: "Arbitrum",
balance: 14,
chainId: "0x66eee",
},
];
const targetChain = "Ethereum";
// Execute consolidation from each chain into the target
for (const { chain, balance, chainId } of chainsToConsolidate) {
if (balance <= 0) {
console.log(`[${chain}] No USDC to consolidate.`);
continue;
}
const intent = {
sourceChain: chain,
targetChain,
amount: balance.toFixed(2),
sender,
recipient,
gasDropoffDesired: 0n,
};
// If using this in a browser (e.g. MetaMask), prompt the user to switch to the source chain:
// await window.ethereum.request({
// method: "wallet_switchEthereumChain",
// params: [{ chainId }],
// });
const routes = await sdk.findRoutes(intent);
const route = routes.all[0];
route.transactionListener.on("transaction-included", (event) => {
console.log(`[${chain}] Tx included:`, event.data);
});
route.progress.on("transfer-redeemed", () => {
console.log(`[${chain}] Consolidation to ${targetChain} complete.`);
});
if (await sdk.checkHasEnoughFunds(route)) {
await sdk.executeRoute(route);
} else {
console.warn(`[${chain}] Not enough funds to consolidate.`);
}
}Full code example: https://docs.stableit.com/sdk/examples-and-use-cases
The Future We’re Enabling
We believe stablecoins are the foundation of a more efficient, on-chain financial system, and USDC is leading the way.
But real utility won’t come from siloed blockchains or fragmented liquidity. It’ll come from seamless, native movement of assets between ecosystems. Without friction, wrapping, or complex infrastructure.
That’s what we’re building with Stableit: a developer platform that makes stablecoin mobility as simple as sending an email.
This is just the beginning, but the infrastructure is live. If you're building with USDC, now’s the time to go cross-chain the right way.
Get started with the SDK and build with us.
