Zap in from USDC

The core never sees USDC. Zap swaps along the registry route, deposits into USDGPool, and returns leftovers. Addresses: Addresses. ABI: Zap.json. Confirm the USDC route with RiskRegistry.zapRoute(usdc) before you send.

Check the route

zapRoute(token).allowed must be true. route[0] == token and route[last] == USDG. Slippage is maxSlippageBps from the registry, not from the caller.

import { parseAbi } from "viem"
import { addresses } from "./addresses" // Addresses, testnet

const registryAbi = parseAbi([
  "function zapRoute(address token) view returns (address[] route, uint16 maxSlippageBps, bool allowed)",
])

const usdc = "0x0000000000000000000000000000000000000000" // fill from Addresses / registry, not from this line
const route = await client.readContract({
  address: addresses.registry,
  abi: registryAbi,
  functionName: "zapRoute",
  args: [usdc],
})
if (!route.allowed) throw new Error("USDC is not allowlisted")

Approve and zapSupply

const zapAbi = parseAbi([
  "function zapSupply(address token, uint256 amountIn) payable",
])
const erc20Abi = parseAbi([
  "function approve(address spender, uint256 amount) returns (bool)",
])

const amountIn = 100n * 10n ** 6n // mainnet USDC is 6 decimals; testnet mocks may be 18

await wallet.writeContract({
  address: usdc,
  abi: erc20Abi,
  functionName: "approve",
  args: [addresses.zap, amountIn],
})

await wallet.writeContract({
  address: addresses.zap,
  abi: zapAbi,
  functionName: "zapSupply",
  args: [usdc, amountIn],
})

interface IZap {
    function zapSupply(address token, uint256 amountIn) external payable;
    function zapRepay(uint16 bookId, address token, uint256 amountIn) external payable;
}

// IERC20(usdc).approve(zap, amountIn);
// IZap(zap).zapSupply(usdc, amountIn);

ETH path

Send msg.value. _resolveIn wraps that ETH to WETH and ignores the token argument. Passing token = address(0) with no value reverts ZeroAddress. Outbound borrowTo / zapWithdraw accept address(0) or the WETH address to pay ETH.

Intent	Function
Repay a book from USDC	`zapRepay(bookId, usdc, amountIn)` (always live)
Borrow USDG and take USDC out	`borrowTo(bookId, usdgAmount, usdc)` (LIVE, operator)
Exit sUSDG to USDC	`zapWithdraw(usdgAmount, usdc)`

What can go wrong

InvalidRoute if the asset is not allowlisted or the path does not end in USDG.
Slippage revert inside SwapLib when the pool moves more than maxSlippageBps.
Decimal mixup: testnet faucet USDG is 18. Mainnet USDG is 6. USDC is usually 6. Read decimals().
zapSupply does not bypass pause on USDG withdraw, but depositing is live. borrowTo still needs LIVE and an operator grant.
The Zap must hold nothing after the call. If a sweep ETH transfer fails, the tx reverts ZeroAmount.

The core never sees USDC. Zap swaps along the registry route, deposits into USDGPool, and returns leftovers. Confirm RiskRegistry.zapRoute(usdc).allowed before you send. Slippage is maxSlippageBps from the registry, not from the caller. That is intentional. A frontend cannot widen slippage past governance. ETH in: send msg.value. _resolveIn wraps to WETH and ignores the token argument. Passing token = address(0) with no value reverts ZeroAddress. ETH out: borrowTo and zapWithdraw accept address(0) or WETH.

Functions

Function	Direction	Needs LIVE	Needs operator grant
`zapSupply(token, amountIn)`	USDC, USDT, or ETH in, sUSDG out	No	No
`zapRepay(bookId, token, amountIn)`	USDC, USDT, or ETH in, debt down	No	No
`borrowTo(bookId, usdgAmount, token)`	Borrow USDG, receive USDC, USDT, or ETH	Yes	Yes
`zapWithdraw(usdgAmount, token)`	sUSDG in, USDC, USDT, or ETH out	No, but USDG withdraw can be paused	No

Next: Repay and withdraw, Reserve and fees.

Introduction

Using Stockline

Concepts

Developers

Ecosystem

Resources

What can go wrong

Functions

​Related calls

​What can go wrong

​Functions

Related calls

What can go wrong

Functions