Forem

Cover image for Starkzap v2: The money toolkit to plug Bitcoin and stablecoins in any app, in one TypeScript SDK
Victor Sizaret
Victor Sizaret

Posted on

Starkzap v2: The money toolkit to plug Bitcoin and stablecoins in any app, in one TypeScript SDK

TL;DR: Starkzap just shipped five new DeFi primitives as first-class TypeScript APIs: token swaps (AVNU + Ekubo), dollar-cost averaging, lending/borrowing (Vesu), multi-chain bridging (Ethereum + Solana), and ZK-powered confidential transfers (Tongo). Every feature works with the same wallet abstraction the SDK already used for staking and gasless transactions.

What Starkzap Is

Starkzap is a TypeScript SDK that abstracts the rough edges of building on Starknet. The first release covered wallet onboarding, ERC20 transfers, STRK staking, a fluent transaction builder, AVNU paymaster support for gasless transactions, and social login via Privy and Cartridge.

This release adds the DeFi layer: everything an app needs to let users swap, accumulate positions over time, lend idle assets, bridge in from Ethereum or Solana, and send funds without revealing amounts.

1. Token Swaps

Two swap providers ship out of the box: AVNU (a DEX aggregator that routes across multiple protocols) and Ekubo (Starknet's concentrated liquidity AMM). Both implement a common SwapProvider interface, so you can swap providers or combine them without changing your app code.

Register providers 

import { StarkZap, AvnuSwapProvider, EkuboSwapProvider } from "starkzap";

const sdk = new StarkZap({ network: "mainnet" });
const wallet = await sdk.connectWallet({
  account: { signer, accountClass: ArgentPreset },
  swapProviders: [new AvnuSwapProvider(), new EkuboSwapProvider()],
  defaultSwapProviderId: "avnu",
});
Enter fullscreen mode Exit fullscreen mode

Get a quote 

import { getPresets, Amount } from "starkzap";

const { STRK, USDC } = getPresets(wallet.getChainId());

const quote = await wallet.getQuote({
  tokenIn: STRK,
  tokenOut: USDC,
  amountIn: Amount.parse("100", STRK),
});

console.log(quote.amountOutBase);   // bigint in USDC base units
console.log(quote.priceImpactBps);  // basis points, e.g. 12n = 0.12%
console.log(quote.provider);        // "avnu" or "ekubo"
Enter fullscreen mode Exit fullscreen mode

Execute a swap 

const tx = await wallet.swap(
  {
    tokenIn: STRK,
    tokenOut: USDC,
    amountIn: Amount.parse("100", STRK),
    slippageBps: 50n, // 0.5% max slippage
  },
  { feeMode: "sponsored" }, // optional
);

await tx.wait();
Enter fullscreen mode Exit fullscreen mode

Batching a swap with other calls

Swaps execute via wallet.swap(). To combine a swap with follow-up actions atomically, run the swap first then chain further operations with the tx builder:

// 1. Execute swap
const txSwap = await wallet.swap({
  tokenIn: STRK,
  tokenOut: USDC,
  amountIn: Amount.parse("100", STRK),
});
await txSwap.wait();

// 2. Batch follow-up actions (e.g. deposit received USDC into lending)
const tx = await wallet
  .tx()
  .lendDeposit({ token: USDC, amount: Amount.parse("50", USDC) })
  .send();
await tx.wait();
Enter fullscreen mode Exit fullscreen mode

What this unlocks for your users: Any in-app marketplace, token sale, or reward claiming flow can now offer a "swap to desired token" step without sending users to an external DEX. Showing quote.amountOutBase and quote.priceImpactBps before execution gives users a clear preview before they commit.

2. Dollar-Cost Averaging (DCA)

DCA lets users schedule recurring swaps at the protocol level. Two providers ship out of the box:

  • AvnuDcaProvider discrete periodic swaps executed on a schedule via AVNU's DCA contracts. Supports optional minBuyAmountBase / maxBuyAmountBase price guards per cycle.
  • EkuboDcaProvider continuous streaming via Ekubo's TWAMM (Time-Weighted AMM) extension. Tokens are sold continuously over the order window rather than in discrete cycles. Does not support per-cycle price guards.

Orders use ISO 8601 duration strings for frequency ("P1D" = daily, "P1W" = weekly, "PT12H" = every 12 hours).

Register DCA providers 

import {
  StarkZap,
  AvnuSwapProvider,
  EkuboSwapProvider,
  AvnuDcaProvider,
  EkuboDcaProvider,
} from "starkzap";

const sdk = new StarkZap({ network: "mainnet" });

const wallet = await sdk.connectWallet({
  account: { signer, accountClass: ArgentPreset },
  swapProviders: [new AvnuSwapProvider(), new EkuboSwapProvider()],
  defaultSwapProviderId: "avnu",
  dcaProviders: [new AvnuDcaProvider(), new EkuboDcaProvider()],
  defaultDcaProviderId: "avnu",
});
Enter fullscreen mode Exit fullscreen mode

Create a DCA order (AVNU, discrete, with price guard) 

const { USDC, ETH } = getPresets(wallet.getChainId());

const tx = await wallet.dca().create({
  tokenIn:          USDC,
  tokenOut:         ETH,
  amountInPerCycle: Amount.parse("50", USDC),
  frequency:        "P1W", // weekly
  // AVNU only: optional price guard (raw bigint base units)
  maxBuyAmountBase: 50000000000000000n, // don't buy above this ETH amount per cycle
});

await tx.wait();
Enter fullscreen mode Exit fullscreen mode

Create a DCA order (Ekubo TWAMM, continuous streaming)

Switch to EkuboDcaProvider and tokens sell in a continuous stream instead of discrete cycles:

const tx = await wallet.dca().create({
  tokenIn:          USDC,
  tokenOut:         ETH,
  amountInPerCycle: Amount.parse("50", USDC),
  frequency:        "P1W",
  provider:         "ekubo",
  // pricingStrategy is NOT supported for Ekubo TWAMM
});

await tx.wait();
Enter fullscreen mode Exit fullscreen mode

Preview what a single cycle would return at current prices 

const quote = await wallet.dca().previewCycle({
  tokenIn:          USDC,
  tokenOut:         ETH,
  amountInPerCycle: Amount.parse("50", USDC),
  provider:         "avnu", // optional; uses default if omitted
});

console.log(`Each cycle buys ~${quote.amountOutBase} ETH base units`);
Enter fullscreen mode Exit fullscreen mode

List and cancel active orders 

const orders = await wallet.dca().getOrders({ provider: "avnu" });

for (const order of orders) {
  console.log(order.id, order.tokenIn.symbol, order.tokenOut.symbol, order.frequency);
}

// Cancel by order ID
const tx = await wallet.dca().cancel({ orderId: orders[0].id });
await tx.wait();
Enter fullscreen mode Exit fullscreen mode

What this unlocks for your users: Savings products, subscription-style accumulation ("stack sats weekly"), automated portfolio rebalancing, and loyalty reward programs that convert protocol tokens to stables on a schedule.

3. Lending and Borrowing

The lending module integrates with Vesu, Starknet's permissionless lending protocol. You can deposit collateral, borrow against it, repay, and withdraw, all through the same wallet-centric API. Vesu is registered automatically when the wallet is created; no extra configuration needed.

Deposit to earn yield 

const { USDC } = getPresets(wallet.getChainId());

const tx = await wallet.lending().deposit({
  token:  USDC,
  amount: Amount.parse("500", USDC),
  // receiver defaults to wallet.address
});
await tx.wait();
Enter fullscreen mode Exit fullscreen mode

Borrow against collateral 

const { ETH, USDC } = getPresets(wallet.getChainId());

const tx = await wallet.lending().borrow({
  collateralToken: ETH,
  debtToken:       USDC,
  amount:          Amount.parse("400", USDC), // amount of debt to borrow
});
await tx.wait();
Enter fullscreen mode Exit fullscreen mode

Check position health 

const health = await wallet.lending().getHealth({
  collateralToken: ETH,
  debtToken:       USDC,
});

console.log("Collateralized:", health.isCollateralized);   // false = liquidation risk
console.log("Collateral value:", health.collateralValue);
console.log("Debt value:", health.debtValue);

const position = await wallet.lending().getPosition({
  collateralToken: ETH,
  debtToken:       USDC,
});

console.log(position.collateralAmount, position.debtAmount);
console.log("Collateralized:", position.isCollateralized);
Enter fullscreen mode Exit fullscreen mode

Repay debt 

const tx = await wallet.lending().repay({
  collateralToken:    ETH,
  debtToken:          USDC,
  amount:             Amount.parse("200", USDC),
  withdrawCollateral: false, // optional, keep collateral deposited
});
await tx.wait();
Enter fullscreen mode Exit fullscreen mode

What this unlocks for your users: In-app yield on idle stablecoins, leveraged positions without leaving your app, and "borrow against your token rewards" flows that were previously only possible on standalone lending frontends.

4. Multi-Chain Bridging

The bridge module lets users move tokens from Ethereum or Solana to Starknet. Under the hood it handles four Ethereum protocols (Canonical, CCTP for USDC fast transfers, OFT/LayerZero, and OFT-migrated) and Solana via Hyperlane, you write the same wallet.deposit(...) call regardless.

Configure the SDK 

import { StarkZap } from "starkzap";

const sdk = new StarkZap({
  network: "mainnet",
  bridging: {
    ethereumRpcUrl: "https://eth-mainnet.g.alchemy.com/v2/<key>",
    solanaRpcUrl:   "https://solana-mainnet.g.alchemy.com/v2/<key>",
    layerZeroApiKey: "<layerzero-key>", // required for OFT/OFT-migrated routes
  },
});
Enter fullscreen mode Exit fullscreen mode

Discover bridgeable tokens 

import { ExternalChain } from "starkzap";

// All tokens bridgeable to the current Starknet environment
const allTokens     = await sdk.getBridgingTokens();

// Filter by source chain
const ethTokens = await sdk.getBridgingTokens(ExternalChain.ETHEREUM);
const solTokens = await sdk.getBridgingTokens(ExternalChain.SOLANA);
Enter fullscreen mode Exit fullscreen mode

Bridge from Ethereum 

import { ConnectedEthereumWallet, ExternalChain, Amount, fromAddress } from "starkzap";

const evmProvider = window.ethereum;
const [evmAddress] = await evmProvider.request({ method: "eth_requestAccounts" });
const evmChainId   = await evmProvider.request({ method: "eth_chainId" });

const ethWallet = await ConnectedEthereumWallet.from(
  {
    chain:    ExternalChain.ETHEREUM,
    provider: evmProvider,
    address:  evmAddress,
    chainId:  evmChainId,
  },
  wallet.getChainId(), // Starknet chain ID
);

// Estimate fees before committing
const fees = await wallet.getDepositFeeEstimate(selectedToken, ethWallet, {
  fastTransfer: true,
});

// Execute the bridge
const tx = await wallet.deposit(
  fromAddress(wallet.address),
  Amount.parse("100", selectedToken.decimals, selectedToken.symbol),
  selectedToken,
  ethWallet,
  { fastTransfer: true }, // CCTP fast path (~20 min vs ~8 h)
);

console.log(`Bridge tx: ${tx.hash}`);
Enter fullscreen mode Exit fullscreen mode

Bridge from Solana 

import { ConnectedSolanaWallet, ExternalChain } from "starkzap";

const solWallet = await ConnectedSolanaWallet.from(
  {
    chain:    ExternalChain.SOLANA,
    provider: solanaProvider, // must implement signAndSendTransaction()
    address:  solanaAddress,
    chainId:  solanaChainId,
  },
  wallet.getChainId(),
);

const tx = await wallet.deposit(
  fromAddress(wallet.address),
  Amount.parse("50", solBridgeToken.decimals, solBridgeToken.symbol),
  solBridgeToken,
  solWallet,
);
Enter fullscreen mode Exit fullscreen mode

What this unlocks for your users: Onboarding from any chain in a single flow. A user coming from Coinbase with USDC on Ethereum, or a Solana native, can bridge directly inside your app without navigating to a separate bridge UI.

5. Confidential Transfers

The confidential module wraps the Tongo protocol, which uses zero-knowledge proofs to hide transfer amounts on-chain. All ZK proof generation happens locally in the SDK before submitting transactions, the chain never sees the amount in plaintext.

The Tongo private key is separate from the Starknet wallet key. Your app must create and hold a TongoConfidential instance with the user's Tongo key and the correct Tongo contract address for the chain.

Set up a confidential account 

import { StarkZap, TongoConfidential } from "starkzap";

const sdk = new StarkZap({ network: "mainnet" });
const wallet = await sdk.connectWallet({ account: { signer, accountClass } });

const confidential = new TongoConfidential({
  privateKey:      tongoPrivateKey,   // separate from the wallet signing key
  contractAddress: TONGO_CONTRACT,    // Tongo deployment address for this chain
  provider:        wallet.getProvider(),
});

// Share recipientId with senders, it's the EC public key { x, y }, not the wallet address
const recipientId = confidential.recipientId;
Enter fullscreen mode Exit fullscreen mode

Check encrypted balance 

const state = await confidential.getState();

console.log("Active balance:", state.balance);   // spendable
console.log("Pending balance:", state.pending);  // needs rollover to become active
console.log("Nonce:", state.nonce);
Enter fullscreen mode Exit fullscreen mode

Fund the confidential account 

const { USDC } = getPresets(wallet.getChainId());

const tx = await wallet
  .tx()
  .confidentialFund(confidential, {
    amount: Amount.parse("100", USDC),
    sender: wallet.address,
  })
  .send();
await tx.wait();
Enter fullscreen mode Exit fullscreen mode

Send a confidential transfer

The amount is hidden from all on-chain observers. The recipient is identified by their recipientId ({ x, y }), not their wallet address.

const tx = await wallet
  .tx()
  .confidentialTransfer(confidential, {
    amount: Amount.parse("50", USDC),
    to:     recipientConfidential.recipientId, // { x, y }
    sender: wallet.address,
  })
  .send();
await tx.wait();
Enter fullscreen mode Exit fullscreen mode

Withdraw back to public ERC20 

const tx = await wallet
  .tx()
  .confidentialWithdraw(confidential, {
    amount: Amount.parse("25", USDC),
    to:     wallet.address,
    sender: wallet.address,
  })
  .send();
await tx.wait();
Enter fullscreen mode Exit fullscreen mode

Rollover and ragequit

Pending balances (received transfers not yet spendable) become active via rollover:

// Activate pending → active balance
const rolloverCalls = await confidential.rollover({ sender: wallet.address });
const tx = await wallet.tx().add(...rolloverCalls).send();
await tx.wait();
Enter fullscreen mode Exit fullscreen mode

To exit the entire confidential balance in one call:

const ragequitCalls = await confidential.ragequit({
  to:     wallet.address,
  sender: wallet.address,
});
const tx = await wallet.tx().add(...ragequitCalls).send();
await tx.wait();
Enter fullscreen mode Exit fullscreen mode

What this unlocks for your users: Payroll and B2B payments where amounts are sensitive, private tipping and donations, confidential DAO compensation, any flow where "how much" is as sensitive as "to whom."

Putting It Together: A Complete Onboarding Flow

All five modules work with the same Wallet instance. Here's how to wire everything up from a single onboard() call:

import {
  StarkZap,
  OnboardStrategy,
  AvnuSwapProvider,
  EkuboSwapProvider,
  AvnuDcaProvider,
  EkuboDcaProvider,
} from "starkzap";

const sdk = new StarkZap({ network: "mainnet" });

// 1. Onboard with Privy (social login)
const onboard = await sdk.onboard({
  strategy:      OnboardStrategy.Privy,
  privy:         { resolve: getPrivyContext },
  accountPreset: "argentXV050",
  deploy:        "if_needed",
});

const wallet = onboard.wallet;

// 2. Register swap and DCA providers
wallet.registerSwapProvider(new AvnuSwapProvider());
wallet.registerSwapProvider(new EkuboSwapProvider());
wallet.setDefaultSwapProvider("avnu");

wallet.dca().registerProvider(new AvnuDcaProvider());
wallet.dca().registerProvider(new EkuboDcaProvider());
wallet.dca().setDefaultDcaProvider("avnu");

// 3. Now the wallet can use all modules
await wallet.swap({ ... });
await wallet.dca().create({ ... });
await wallet.lending().deposit({ ... });
await wallet.deposit(recipient, amount, bridgeToken, ethWallet);
// Confidential transfers use TongoConfidential independently (see section 5)
Enter fullscreen mode Exit fullscreen mode

Getting Started 

npm install starkzap
Enter fullscreen mode Exit fullscreen mode

Optional dependencies (install only what you use):

# Ethereum bridging
npm install ethers

# Solana bridging
npm install @solana/web3.js @hyperlane-xyz/sdk @hyperlane-xyz/registry @hyperlane-xyz/utils

# Confidential transfers
npm install @fatsolutions/tongo-sdk
Enter fullscreen mode Exit fullscreen mode

The full feature set, staking, ERC20, tx builder, paymaster, social login, swaps, DCA, lending, bridging, and confidential transfers, runs on both mainnet and Sepolia testnet.

Top comments (0)