starknet-io · Akashneelesh · Mar 17, 2026 · Mar 17, 2026 · Mar 17, 2026 · Mar 17, 2026
diff --git a/assets/starkzap/bridges.png b/assets/starkzap/bridges.png
diff --git a/assets/starkzap/confidential-transfers.png b/assets/starkzap/confidential-transfers.png
diff --git a/assets/starkzap/dca.png b/assets/starkzap/dca.png
diff --git a/assets/starkzap/lending-borrowing.png b/assets/starkzap/lending-borrowing.png
diff --git a/assets/starkzap/swapping.png b/assets/starkzap/swapping.png
diff --git a/build/starkzap/api-reference.mdx b/build/starkzap/api-reference.mdx
@@ -19,10 +19,11 @@ new StarkZap(config: SDKConfig): StarkZap
 | Method                       | Returns                    | Description                          |
 | ---------------------------- | -------------------------- | ------------------------------------ |
 | `connectWallet(options)`     | `Promise<Wallet>`          | Connect with signer + account preset |
-| `connectCartridge(options?)` | `Promise<CartridgeWallet>` | Connect via Cartridge Controller     |
+| `connectCartridge(options?)` | `Promise<CartridgeWallet>` | Connect via Cartridge (**web:** Controller popup; **RN:** native session when supported — register adapter first) |
 | `onboard(options)`           | `Promise<OnboardResult>`   | Onboard with strategy selection      |
 | `stakingTokens()`            | `Promise<Token[]>`         | Get stakeable tokens                 |
 | `getStakerPools(staker)`     | `Promise<Pool[]>`          | Get validator's delegation pools     |
+| `getBridgingTokens(chain?)`  | `Promise<BridgeToken[]>`   | Get bridgeable tokens by source chain |
 | `getProvider()`              | `RpcProvider`              | Get the underlying RPC provider      |
 
 ### Configuration
@@ -35,6 +36,7 @@ interface SDKConfig {
   paymaster?: { nodeUrl: string };
   explorer?: ExplorerConfig;
   staking?: StakingConfig;
+  bridging?: BridgingConfig;
 }
 ```
 
@@ -76,6 +78,10 @@ The wallet interface provides access to account operations, transactions, and to
 | `getChainId()`                             | `ChainId`                      | Get chain ID                 |
 | `getFeeMode()`                             | `FeeMode`                      | Get default fee mode         |
 | `disconnect()`                             | `Promise<void>`                | Disconnect wallet            |
+| `deposit(recipient, amount, token, externalWallet, options?)` | `Promise<{ hash: string }>` | Bridge deposit from external chain |
+| `getDepositBalance(token, externalWallet)` | `Promise<Amount>`              | Get source-chain available balance |
+| `getAllowance(token, externalWallet)`      | `Promise<Amount \| null>`      | Get source-chain allowance (if applicable) |
+| `getDepositFeeEstimate(token, externalWallet, options?)` | `Promise<BridgeDepositFeeEstimation>` | Estimate bridge route fees |
 
 ## Tx
 
@@ -113,6 +119,16 @@ Fluent API for building and executing batched transactions.
 | `.claimPoolRewards(pool)`          | `TxBuilder`                | Claim staking rewards                          |
 | `.exitPoolIntent(pool, amount)`    | `TxBuilder`                | Start exit process                             |
 | `.exitPool(pool)`                  | `TxBuilder`                | Complete exit after window                     |
+| `.lendDeposit(request)`            | `TxBuilder`                | Lending deposit (supply)                       |
+| `.lendWithdraw(request)`           | `TxBuilder`                | Lending withdraw                               |
+| `.lendWithdrawMax(request)`        | `TxBuilder`                | Lending max withdraw                           |
+| `.lendBorrow(request)`             | `TxBuilder`                | Lending borrow                                 |
+| `.lendRepay(request)`              | `TxBuilder`                | Lending repay                                  |
+| `.dcaCreate(request)`              | `TxBuilder`                | Create a DCA (recurring buy) order             |
+| `.dcaCancel(request)`              | `TxBuilder`                | Cancel a DCA order                             |
+| `.confidentialFund(confidential, details)` | `TxBuilder`        | Fund confidential account                      |
+| `.confidentialTransfer(confidential, details)` | `TxBuilder`   | Confidential transfer                          |
+| `.confidentialWithdraw(confidential, details)` | `TxBuilder`   | Withdraw from confidential to public address   |
 | `.calls()`                         | `Promise<Call[]>`          | Resolve all calls without sending              |
 | `.estimateFee()`                   | `Promise<EstimateFeeResponse>` | Estimate gas cost                              |
 | `.preflight()`                     | `Promise<PreflightResult>` | Simulate the transaction                       |
@@ -169,7 +185,7 @@ new PrivySigner(config: {
   walletId: string;
   publicKey: string;
   serverUrl?: string;
-  rawSign?: (walletId: string, hash: string) => Promise<Signature>;
+  rawSign?: (walletId: string, hash: string) => Promise<string>;
 }): PrivySigner
 ```
 
@@ -259,6 +275,66 @@ interface Token {
 }
 ```
 
+### BridgingConfig
+
+```typescript
+interface BridgingConfig {
+  layerZeroApiKey?: string; // required for OFT/OFT-migrated routes
+  ethereumRpcUrl?: string;
+  solanaRpcUrl?: string;
+}
+```
+
+### ExternalChain
+
+```typescript
+enum ExternalChain {
+  ETHEREUM = "ethereum",
+  SOLANA = "solana",
+}
+```
+
+### BridgeToken
+
+```typescript
+interface BridgeToken {
+  id: string;
+  name: string;
+  symbol: string;
+  decimals: number;
+  chain: ExternalChain;
+  protocol: Protocol;
+  address: ExternalAddress;      // source-chain token
+  bridgeAddress: ExternalAddress; // source-chain bridge
+  starknetAddress: Address;      // destination token on Starknet
+  starknetBridge: Address;       // destination bridge contract
+}
+```
+
+### Connected External Wallets
+
+```typescript
+ConnectedEthereumWallet.from(
+  {
+    chain: ExternalChain.ETHEREUM,
+    provider: eip1193Provider,
+    address: "0x...",
+    chainId: "0x1",
+  },
+  starknetChainId
+);
+
+ConnectedSolanaWallet.from(
+  {
+    chain: ExternalChain.SOLANA,
+    provider: solanaProvider,
+    address: "So1...",
+    chainId: "<solana-genesis-hash>",
+  },
+  starknetChainId
+);
+```
+
 ### Pool
 
 ```typescript

diff --git a/build/starkzap/bridging.mdx b/build/starkzap/bridging.mdx
@@ -0,0 +1,185 @@
+---
+title: Bridging
+description: "Bridge assets from Ethereum or Solana into Starknet using Starkzap bridge tokens, external wallet adapters, and deposit APIs"
+icon: link
+---
+
+![Bridge hero](/assets/starkzap/bridges.png)
+
+## Overview
+
+Starkzap supports **deposit bridging into Starknet** from supported external chains:
+
+- **Ethereum** (Canonical, CCTP, OFT, OFT-migrated routes)
+- **Solana** (Hyperlane routes)
+
+The bridge flow is:
+1. Configure the SDK (including optional bridging config)
+2. Fetch bridgeable tokens with `sdk.getBridgingTokens(...)`
+3. Connect an external wallet (`ConnectedEthereumWallet` or `ConnectedSolanaWallet`)
+4. Inspect balance, allowance, and estimated fees
+5. Call `wallet.deposit(...)` to submit the source-chain transaction
+
+<Info>
+  Current wallet bridge APIs are for **external chain → Starknet deposits**. Outbound Starknet → external bridge flows are not exposed through this API surface.
+</Info>
+
+## Install Optional Dependencies
+
+Install only what you use.
+
+For Ethereum routes:
+```bash
+npm install ethers
+```
+
+For Solana routes:
+
+```bash
+npm install @solana/web3.js @hyperlane-xyz/sdk @hyperlane-xyz/registry @hyperlane-xyz/utils
+```
+
+## SDK Configuration
+
+Use `bridging` config when you need custom external RPCs or OFT support.
+The SDK uses external RPCs to read source-chain state (balances/allowances), estimate bridge fees, and submit source-chain transactions reliably. Without explicit RPC URLs, these operations can be rate-limited or unavailable depending on your environment:
+
+```typescript
+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
+  },
+});
+```
+
+<Warning>
+  OFT bridging requires `bridging.layerZeroApiKey` and is supported on Starknet Mainnet routes only.
+</Warning>
+
+## Fetch Bridgeable Tokens
+
+```typescript
+import { ExternalChain } from "starkzap";
+
+// All bridgeable tokens for current Starknet environment
+const allTokens = await sdk.getBridgingTokens();
+
+// Filter by source chain
+const ethereumTokens = await sdk.getBridgingTokens(ExternalChain.ETHEREUM);
+const solanaTokens = await sdk.getBridgingTokens(ExternalChain.SOLANA);
+```
+
+## Connect External Wallets
+
+Take a look at the [Examples](/build/starkzap/examples). For WalletConnect setup details, see [WalletConnect Docs](https://docs.walletconnect.network/). In practice, you establish the external wallet session first (for example with WalletConnect), then pass its provider/account/chain into `ConnectedEthereumWallet.from(...)` or `ConnectedSolanaWallet.from(...)` for bridge calls.
+
+### Ethereum (EIP-1193)
+
+```typescript
+import { ConnectedEthereumWallet, ExternalChain } from "starkzap";
+
+const evmProvider = window.ethereum;
+const [evmAddress] = await evmProvider.request({ method: "eth_requestAccounts" });
+const evmChainId = await evmProvider.request({ method: "eth_chainId" }); // "0x1" or "0xaa36a7"
+
+const ethWallet = await ConnectedEthereumWallet.from(
+  {
+    chain: ExternalChain.ETHEREUM,
+    provider: evmProvider,
+    address: evmAddress,
+    chainId: evmChainId, // evm wallet's chain id
+  },
+  wallet.getChainId() // starknet wallet's chain id
+);
+```
+
+### Solana
+
+```typescript
+import { ConnectedSolanaWallet, ExternalChain } from "starkzap";
+
+const solWallet = await ConnectedSolanaWallet.from(
+  {
+    chain: ExternalChain.SOLANA,
+    provider: solanaProvider, // must implement signAndSendTransaction()
+    address: solanaAddress,
+    chainId: solanaChainId, // e.g. mainnet/testnet genesis hash from wallet adapter
+  },
+  wallet.getChainId()
+);
+```
+
+<Warning>
+  External wallet network and Starknet network must match by environment:
+  Ethereum Mainnet with Starknet Mainnet, Ethereum Sepolia with Starknet Sepolia, Solana Mainnet with Starknet Mainnet, and Solana Testnet with Starknet Sepolia.
+
+  | External Network | Identifier | Starknet Network |
+  | --- | --- | --- |
+  | Ethereum Mainnet | `1` | Starknet Mainnet |
+  | Ethereum Sepolia | `11155111` | Starknet Sepolia |
+  | Solana Mainnet | `5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp` | Starknet Mainnet |
+  | Solana Testnet | `4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z` | Starknet Sepolia |
+</Warning>
+
+## Estimate and Deposit
+
+```typescript
+import { Amount, fromAddress } from "starkzap";
+
+const token = ethereumTokens[0];
+if (!token) throw new Error("No bridge token available");
+
+// 1) Source-chain available balance
+const available = await wallet.getDepositBalance(token, ethWallet);
+
+// 2) ERC20 allowance (null for native/non-allowance routes)
+const allowance = await wallet.getAllowance(token, ethWallet);
+
+// 3) Fee estimation (fastTransfer only applies to CCTP)
+const fees = await wallet.getDepositFeeEstimate(token, ethWallet, {
+  fastTransfer: true,
+});
+
+// 4) Submit deposit tx on source chain
+const recipient = fromAddress(
+  "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef"
+); // Starknet recipient
+
+const tx = await wallet.deposit(
+  recipient,
+  Amount.parse("25", token.decimals, token.symbol),
+  token,
+  ethWallet,
+  { fastTransfer: true }
+);
+
+console.log(tx.hash);
+```
+
+## Protocol Notes
+
+| Protocol | Chain | Notes |
+| --- | --- | --- |
+| `canonical` | Ethereum | Standard bridge flow; approval may be required for ERC20 tokens. |
+| `cctp` | Ethereum | Supports `fastTransfer`; fee estimate includes CCTP fast transfer bp fee. |
+| `oft` / `oft-migrated` | Ethereum | Requires `bridging.layerZeroApiKey`; mainnet-only route availability. |
+| `hyperlane` | Solana | Requires Solana + Hyperlane optional dependencies. |
+
+## Common Errors
+
+- **Chain mismatch**: token source chain and connected external wallet chain must match.
+- **Missing LayerZero key**: OFT routes require `bridging.layerZeroApiKey`.
+- **Unsupported chain pair**: Ethereum mainnet must pair with Starknet mainnet; testnet pairings must match.
+
+For additional issues, see [Troubleshooting](/build/starkzap/troubleshooting).
+
+## Next Steps
+
+- [Configuration](/build/starkzap/configuration) — full `SDKConfig` options
+- [API Reference](/build/starkzap/api-reference) — exact method signatures
+- [Examples](/build/starkzap/examples) — web example with bridge UI flow