# SDK reference The look-it-up layer. The SDK is the primary surface, and most integrations never touch Rust or the contracts directly. **Conventions.** * **Amounts** are decimal money-unit strings, for example `"100.00"`. Never wei, never floats. * **Accounts** are referenced by address. The signing account's address is its identity; attach your own labels (a `customerId`, an invoice id) in `metadata`. * **Mutations** take an `idempotencyKey`. Reusing a key returns the original result instead of acting twice. * **Errors** are typed and carry a stable `code`. Pagination uses `cursor` and `limit`. **Initialization.** ```ts new Kakushi({ zoneId: string, environment: "sandbox" | "production", apiKey: string }) ``` **accounts** ```ts accounts.create({ account, metadata?, idempotencyKey? }) // returns { address, virtualAddress }; account signs the claim, created lazily on first deposit accounts.get(address) accounts.createVirtualAddress({ account, metadata? }) // returns { virtualAddress } accounts.listVirtualAddresses(account) // all deposit addresses for the account ``` The virtual-address methods map to the zone RPC `zone_getDepositAddress` (allocate one) and `zone_getDepositAddresses` (list all). **balances** ```ts balances.get(account, { token }) // reads as the owner; reference by account or address balances.list(account) ``` **deposits** ```ts deposits.list({ account?, virtualAddress?, cursor?, limit? }) deposits.getAttribution(depositId) ``` **transfers** ```ts transfers.create({ to, amount, token, account, idempotencyKey }) // source is account.address; `to` is a zone address transfers.batch({ transfers: [{ to, amount, token }], account, idempotencyKey }) // one source account transfers.get(transferId) transfers.list({ account?, cursor?, limit? }) transfers.prepare({ from, to, amount, token }) // split signing: no signer present, so `from` is explicit; returns { unsignedTx } transfers.submit(signedTx) // submits over the authenticated RPC ``` **withdrawals** ```ts withdrawals.create({ to, amount, token, account, idempotencyKey }) // source is account.address; `to` is a host-chain address withdrawals.get(withdrawalId) withdrawals.estimateFee({ account, amount, token }) withdrawals.prepare({ from, to, amount, token }) // split signing: `from` is explicit withdrawals.submit(signedTx) ``` **webhooks** ```ts webhooks.configure({ url, events }) webhooks.verify(rawBody, signatureHeader) // returns the typed event ``` **reconciliation** ```ts reconciliation.getLockedBalance({ token }) reconciliation.getZoneSupply({ token }) ``` **compliance** ```ts compliance.exportAuditTrail({ account?, from, to }) // from / to are dates ``` **auth** ```ts auth.createToken(account, { expiresIn? }) // signs a kzt auth token with the account you pass ``` **Signers.** A signer is a viem `Account` or an ethers `Signer`, obtained with viem: `privateKeyToAccount` for a custodial key you hold in your own secret store, or the wallet's viem account (for example `toViemAccount`) for non-custodial signing. The SDK reads the address off it and signs through it, and holds no keys of its own. You supply the account where signing happens (the account you hold for custodial, the user's account for non-custodial), never at client init. Passkey and smart-account signing arrive in V2.