Build a Multichain Treasury System on Arc: The Arc Fintech Starter

Moving your treasury onchain can be straightforward in some cases. Managing funds across multiple wallets and chains is where operational complexity shows up.

USDC balances quickly become fragmented across networks. Users, vendors, and employees expect to get paid on different chains. Teams end up moving funds constantly just to stay operational.

Onchain treasury management is essentially the set of tools and processes to: 

• Create and manage operational wallets
• Move USDC between chains when needed 
• Consolidate balances so they’re usable for day-to-day operations 
• Execute payouts with logging and basic controls

To make these workflows easier to understand end-to-end, we built the Arc Fintech Starter, an open-source sample app that demonstrates how a multichain treasury system can be built on Arc.

Who this is for

This starter is designed for builders working on:

• Fintech apps (wallets, neobanks, payment platforms)
• Marketplaces with cross-chain payouts
• Payroll or remittance systems
• AI agents that need to move and manage money

If your product needs to hold, move, or pay USDC across chains, this is a practical place to start.

What you’ll get in ~15 minutes

By running this app locally and following the guided flow, you’ll:

• Create and manage wallets across multiple chains
• Move USDC between chains using Bridge Kit and Gateway
• Consolidate balances into a unified Gateway balance
• Execute a real payout across chains

Get started

1. Clone the repo: https://github.com/akelani-circle/fintech-starter
2. Run the app locally
3. Follow the “create → fund → rebalance → unify → pay” flow

What the starter app demonstrates

This is a minimal fintech dashboard that acts like a treasury operations console.

It uses:

• Circle Developer-Controlled Wallets
  
  • Create and manage wallets programmatically
• Circle Bridge Kit + Forwarding Service
  
  • Rebalance funds across chains
• Circle Gateway
  
  • Consolidate balances into a unified, spendable pool

This is not meant to be a finished product. It’s a reference architecture you can run, inspect, and extend.

The core workflow

The app follows a simple but realistic flow:

Create → Fund → Rebalance → Unify → Pay

1) Create wallets on multiple chains

Start by creating a few Developer Controlled Wallets across different supported testnets (for example, Arc Testnet plus one or more other chains). 

This sets up the basic “multichain treasury” state.

import { initiateDeveloperControlledWalletsClient } from '@circle-fin/developer-controlled-wallets';

// Initialize Circle Wallets SDK
export const circleDeveloperSdk = initiateDeveloperControlledWalletsClient({
  apiKey: process.env.CIRCLE_API_KEY,
  entitySecret: process.env.CIRCLE_ENTITY_SECRET,
});

// Create Wallets
const response = await circleDeveloperSdk.createWallets({
  walletSetId: walletSetId,
  blockchains: [blockchain],
  count: 1,
  accountType: 'SCA',
});

app/api/wallet/route.ts

2) Fund your primary wallet

Deposit testnet USDC into your Arc wallet using the Circle Testnet Faucet. 

This becomes your initial treasury balance.

3) Rebalance from Arc to other chains

Use the Rebalance feature to distribute USDC from the Arc wallet to wallets on other chains.

Under the hood, this uses Bridge Kit + Forwarding Service.

import { BridgeKit } from '@circle-fin/bridge-kit';
// Initialize Bridge Kit
const kit = new BridgeKit();

// Create Circle Wallets adapter
const adapter = createCircleWalletsAdapter({
  apiKey: process.env.CIRCLE_API_KEY,
  entitySecret: process.env.CIRCLE_ENTITY_SECRET,
});

// Validate the transfer parameters early by running an estimate
// This catches errors like insufficient balance before we commit to the transfer
const estimateResult = await kit.estimate({
  from: {
    adapter,
    chain: bridgeSourceChain as any,
    address: sourceAddress,
  },
  to: {
    adapter,
    chain: bridgeDestChain as any,
    address: destAddress,
  },
  amount: amountString,
  config: {
    transferSpeed: transferSpeed as 'FAST' | 'SLOW',
  },
});

// Execute the bridge transfer
const result = await kit.bridge({
  from: {
    adapter,
    chain: bridgeSourceChain as any,
    address: sourceAddress,
  },
  to: {
    adapter,
    chain: bridgeDestChain as any,
    address: destAddress,
    useForwarder: true, // Enable Circle Forwarding Service for automatic attestation and minting
  } as any,
  amount: amountString,
  config: {
    transferSpeed: transferSpeed as 'FAST' | 'SLOW',
  },
});

app/api/bridge/rebalance/route.ts

4) Consolidate into Gateway

Use Add Funds to deposit USDC from multiple wallets into Gateway, creating a single consolidated gateway balance.

This is what enables simplified spending across chains.

// Deposits USDC into Gateway by calling Wallets SDK createContractExecutionTransaction function
const depositChallengeId = await initiateContractInteraction(
  walletId,
  GATEWAY_WALLET_ADDRESS as Address,
  'deposit(address,uint256)',
  [usdcAddress, amountInAtomicUnits.toString()],
);

app/api/gateway/deposit/route.ts

5) Execute a payout from the Gateway balance

Once funds are consolidated, you can use Payout to send USDC to recipients on different chains using the Gateway balance.

This is useful for cases like paying vendors or employees with wallets on various networks.

// Step 1: Sign and submit burn intent on source chain - full implementation in lib/circle/gateway-sdk.ts
const { transferId, attestation, attestationSignature } = await signAndSubmitGatewayBurnIntent(
  user.id,
  amountInAtomicUnits,
  sourceWallet.chain,
  destinationChain,
  recipientAddress as Address,
  depositorWallet.address as Address, // Pass the depositor address
);

// Step 2: Execute mint on destination chain - full implementation in lib/circle/gateway-sdk.ts
mintTx = await executeGatewayMint(
  walletAddress,
  destinationChain,
  attestation,
  attestationSignature,
);

app/api/payout/route.ts

What you can build from this

You can extend this into:

• Cross-border payroll systems
• Stablecoin neobank backends
• Marketplace payout engines
• AI-native financial agents
• Treasury automation tools for startups

From demo → production

As you extend this, think in terms of:

• Reliability (retry logic, monitoring)
• Security (permissions, approvals)
• Observability (logs, audit trails)

Build something with it

If you end up building on top of this starter, we’d love to see it.

This repo is meant to be forked, modified, and turned into real products.

👉 https://github.com/circlefin/arc-fintech

‍

Sample apps provided for demonstration and educational purposes only, is intended for testnet use only, and is not production-ready.

Arc testnet is offered by Circle Technology Services, LLC (“CTS”). CTS is a software provider and does not provide regulated financial or advisory services. You are solely responsible for services you provide to users, including obtaining any necessary licenses or approvals and otherwise complying with applicable laws.

Arc has not been reviewed or approved by the New York State Department of Financial Services.

The product features described in these materials are for informational purposes only. All product features may be modified, delayed, or cancelled without prior notice, at any time and at the sole discretion of Circle Technology Services, LLC. Nothing herein constitutes a commitment, warranty, guarantee or investment advice.

USDC is issued by regulated affiliates of Circle. See Circle’s list of regulatory authorizations.

Circle Technology Services, LLC (“CTS”) is a software provider and does not provide regulated financial or advisory services. You are solely responsible for services you provide to users, including obtaining any necessary licenses or approvals and otherwise complying with applicable laws. For additional details, refer to the Circle Developer terms of service.