Forem: Victor Sizaret

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

Victor Sizaret — Tue, 24 Mar 2026 15:59:35 +0000

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",
});

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"

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();

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();

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",
});

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();

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();

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`);

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();

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();

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();

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);

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();

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
  },
});

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);

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}`);

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,
);

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;

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);

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();

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();

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();

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();

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();

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)

Getting Started

npm install starkzap

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

Docs: starkzap.io/docs
GitHub: github.com/keep-starknet-strange/starkzap
Examples: awesome-starkzap
Website: starknet.io

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.

I Added BTC Staking to a Stock Trading App in 200 Lines of Code

Victor Sizaret — Tue, 03 Mar 2026 13:09:59 +0000

What if your users could earn 3.3% APY on Bitcoin without ever knowing they're using a blockchain?

That's what we built with SmoothYield — a traditional finance mobile app (stocks, cash, portfolio) with a hidden superpower: passive BTC yield powered by Starknet. The user signs in with their email (6-digit code) or Google, taps "Stake BTC now", and starts earning. No wallet address. No gas fees.

The entire blockchain layer is built with Starkzap, the official Starknet developer toolkit. This post walks through exactly how we integrated it — step by step — so you can do the same in your own app.

What the user sees vs. what actually happens

From the user's perspective, SmoothYield looks like any fintech app:

Sign in with email (OTP code) or Google
View stocks (AAPL, TSLA, NVDA) and crypto prices
Tap "BTC Yield" and stake for 3.33% APY
See "Earning" status on the portfolio screen

What the user never sees: a wallet address, a seed phrase, a gas fee prompt, or the word "Starknet".

Behind the scenes, a lot is happening:

User taps "Stake BTC now"
       │
       ▼
Backend creates a Starknet wallet (Privy)
       │
       ▼
Backend onboards wallet into Starkzap
       │
       ▼
Starkzap finds an LBTC staking pool
       │
       ▼
Starkzap builds the staking transaction
       │
       ▼
Privy signs it server-side (no user interaction)
       │
       ▼
AVNU paymaster pays the gas (user pays nothing)
       │
       ▼
Transaction lands on Starknet
       │
       ▼
App shows "Earning 3.33% APY"

All of that is about 200 lines of backend TypeScript across two files. Let me show you.

The stack

Four npm packages handle the entire crypto layer:

Package	What it does
`starkzap`	Starknet SDK — wallet onboarding, staking, token presets, paymaster
`@privy-io/node`	Server-side embedded wallet creation + signing
`@privy-io/expo`	Client-side auth (email OTP + Google OAuth)
`starknet`	Low-level Starknet RPC provider

The app itself is:

Mobile: Expo React Native (tabs for Stocks, Crypto, Portfolio, Profile)
Backend: Express + SQLite (auth, wallet management, staking endpoints). For production, swap SQLite for PostgreSQL with encrypted columns and session expiry.

Step 1: Initialize Starkzap with the paymaster

The paymaster is the key to the "no gas fees" experience. You get an API key from portal.avnu.fi, and every transaction your app sends is free for the user.

const starkzap = await import("starkzap");

const sdk = new starkzap.StarkZap({
  network: "mainnet",
  rpcUrl: "https://starknet-mainnet.g.alchemy.com/v2/YOUR_KEY",

  // This makes every transaction gasless
  paymaster: {
    nodeUrl: "https://starknet.paymaster.avnu.fi",
    headers: { "x-paymaster-api-key": process.env.AVNU_PAYMASTER_API_KEY },
  },
});

That's it. Every wallet.execute() call from this point forward is sponsored. The user never needs to hold ETH or STRK.

Docs: Starkzap Paymasters and AVNU integration

Step 2: Create invisible wallets with Privy

When a user signs in (email OTP or Google), the backend creates a Starknet wallet for them. One API call:

import { PrivyClient } from "@privy-io/node";

const privy = new PrivyClient({
  appId: process.env.PRIVY_APP_ID,
  appSecret: process.env.PRIVY_APP_SECRET,
});

const wallet = await privy.wallets().create({
  chain_type: "starknet",
});

// wallet.id         → used for signing later
// wallet.address    → Starknet address (stored in DB, never shown to user)
// wallet.public_key → needed for Starkzap onboard

The wallet is "server-managed" — the backend holds it, the mobile app never touches it. This means signing happens entirely on the server, which is exactly what we want for a TradFi experience.

Docs: Starkzap Privy Integration

Step 3: Onboard the wallet into Starkzap

This is where Privy and Starkzap meet. The sdk.onboard() call connects the Privy wallet to the Starkzap SDK so you can execute staking transactions through it:

const wallet = await sdk.onboard({
  strategy: "privy",
  privy: {
    resolve: async () => ({
      walletId: privyWalletId,
      publicKey: publicKey,
      serverUrl: "https://your-api.com/api/wallet/sign",
    }),
  },
  deploy: "never",
  feeMode: "sponsored",
});

Two things to note:

serverUrl — Starkzap will call this endpoint whenever it needs a signature. Your backend handles it with Privy's rawSign:

app.post("/api/wallet/sign", async (req, res) => {
  const { walletId, hash } = req.body;
  const result = await privy.wallets().rawSign(walletId, {
    params: { hash },
  });
  res.json({ signature: result.signature });
});

deploy: "never" — we skip deployment during the onboard step. Instead, the backend deploys the account explicitly via deployAccountIfNeeded() when the user initiates their first action (the /wallet/init call). This keeps onboarding fast and the deploy sponsored by the paymaster. Reading token balances works even before deployment since balance_of is a read-only call on the token contract.

Docs: Starkzap Connecting Wallets

Step 4: Stake LBTC for yield

This is the payoff. With the wallet onboarded, staking LBTC is a handful of lines:

const { Staking, Amount, ChainId, getStakingPreset } = await import("starkzap");

// Get the staking config for this network
const stakingConfig = getStakingPreset(ChainId.MAINNET);

// Connect to a validator's LBTC pool
const staking = await Staking.fromPool(poolAddress, provider, stakingConfig);

// Build the staking transaction
const amount = Amount.fromRaw("100000000", 8, "LBTC"); // 1 LBTC
const isMember = await staking.isMember(wallet);

const calls = isMember
  ? staking.populateAdd(walletAddress, amount)    // add to existing stake
  : staking.populateEnter(walletAddress, amount); // first-time stake

// Execute — gasless, server-signed, on-chain
const tx = await wallet.execute(calls, { feeMode: "sponsored" });

How does the backend know which pool to use? Starkzap ships a validator registry. You iterate it once to find an LBTC pool:

const validators = starkzap.mainnetValidators;

for (const validator of Object.values(validators)) {
  const pools = await Staking.getStakerPools(
    provider,
    validator.stakerAddress,
    stakingConfig,
  );
  const lbtcPool = pools.find((p) => p.token.symbol === "LBTC");
  if (lbtcPool) {
    return lbtcPool.poolContract; // cache this
  }
}

We cache the pool address for the lifetime of the process. No need to look it up on every request.

Step 5: Unstake (when the user wants out)

Starknet staking has a two-phase exit. Starkzap handles both:

// Phase 1: "I want to withdraw" (exit intent)
const exitIntentCall = staking.populateExitIntent(amount);
await wallet.execute([exitIntentCall], { feeMode: "sponsored" });

// Phase 2: After cooldown passes, finalize
const exitCall = staking.populateExit(walletAddress);
await wallet.execute([exitCall], { feeMode: "sponsored" });

Both calls are gasless. The user just taps a button.

How the mobile app ties it together

On the frontend, the user has no idea any of this exists. The mobile app uses Privy for auth (email OTP or Google) and talks to the backend with a simple session ID:

// app/_layout.tsx — wrap the app in PrivyProvider
<PrivyProvider appId={appId}>
  <AuthProvider>
    <App />
  </AuthProvider>
</PrivyProvider>

The AuthProvider exchanges the Privy token for a backend session:

const privyToken = await getAccessToken();
const { sessionId } = await api.post("/api/auth/session", { privyToken });

From then on, every API call uses x-session-id as a header. The staking flow is two REST calls:

// 1. Initialize wallet (creates + deploys if needed)
await api.post("/api/wallet/init");

// 2. Stake
const result = await api.post("/api/yield/stake", {
  amountLbtc: "100000000",
});

// result.txHash     → "0x04a3..."
// result.explorerUrl → "https://voyager.online/tx/0x04a3..."

The YieldScreen component shows a simple input for the amount, a "Stake BTC now" button, and an "Earning X% APY" card after success. Standard React Native — nothing crypto-specific in the UI layer.

The three API keys you need

Service	Free tier	Get it at
Privy	Yes	dashboard.privy.io
AVNU	Yes	portal.avnu.fi
Alchemy (optional)	Yes	dashboard.alchemy.com

Set them in your backend .env:

PRIVY_APP_ID=your-privy-app-id
PRIVY_APP_SECRET=your-privy-app-secret
AVNU_PAYMASTER_API_KEY=your-avnu-key
ALCHEMY_STARKNET_API_KEY=your-alchemy-key
STARKNET_NETWORK=mainnet

Why this matters if you're a web2 developer

You already have the skills. If you can build an Express API, call a REST endpoint, and wire up React Native screens, you can ship a crypto-powered feature. Starkzap works like any other npm SDK — install it, call functions, get results. The staking flow is Staking.fromPool() → populateEnter() → wallet.execute(). No Solidity, no ABIs, no local nodes.

Your users never deal with gas. The AVNU paymaster sponsors every transaction. You add an API key, pass { feeMode: "sponsored" }, and gas is invisible. Think of it like Stripe absorbing the payment processing fee — your user just sees the result.

Auth stays familiar. Privy handles wallets the same way you'd handle any server-side resource. The user signs in with their email and a 6-digit code. No MetaMask, no browser extensions, no "approve this transaction" popups. The wallet lives on your backend, managed through a simple API. And it's not a lock-in: Starknet is a Privy Tier 2 chain, so users can export their private keys at any time if they want to self-custody.

No blockchain knowledge required. You don't need to write Cairo or understand Starknet internals. Starkzap's token presets give you the right contract addresses, the Staking module builds the transactions, and the paymaster handles the fees. The blockchain is just an infrastructure layer — the same way you use PostgreSQL without understanding B-trees.

The ramp-up is minimal. The only new concepts are three API keys (Privy, AVNU, Alchemy) and how Privy tokens flow between client and server. Once that's wired up, adding new on-chain features is just calling more Starkzap functions. If you can build a Node.js backend, you can build this.

Try it yourself

The full source code is on GitHub: smoothyield

git clone https://github.com/starkience/smoothyield
cd smoothyield/backend
cp .env.example .env  # add your API keys
npm install && npm run dev

cd ../mobile
cp .env.example .env
npm install && npm start

Set DEV_MODE=true in the backend .env to test the full flow with mocked transactions before you add real API keys.

Resources

If you're building a fintech app and want to add crypto yield without turning it into a "crypto app", Starkzap + Privy + AVNU paymaster is the stack. Four packages. Two hundred lines. Zero blockchain UX for your users.