kokio-sdk 3.0.2 → 3.2.0

package/dist/esm/logic/paymentAdapter.js

@@ -1,4 +1,4 @@
-import { _getChainSpecificConstants } from "./constants.js";
+import { _chainId, _getChainSpecificConstants } from "./constants.js";
 import { PaymentAdapter } from "../abis/index.js";
 // Every function here is a view. The adapter's only writes reachable from a
 // userOp are `settle` (`onlyESIMWallet`, called from inside
@@ -10,7 +10,7 @@ import { PaymentAdapter } from "../abis/index.js";
  * The registry this adapter reads `vault()` and `isESIMWalletValid()` from.
  */
 export const _registry = async (client) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -22,7 +22,7 @@ export const _registry = async (client) => {
 };
 /** The ERC-20 registered under the `USDC` symbol at configure time. */
 export const _settlementToken = async (client) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -38,7 +38,7 @@ export const _settlementToken = async (client) => {
  * from "registered but withdrawn" (`allowed: false`).
  */
 export const _assets = async (client, symbol) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     const [allowed, isDollarUnit, decimals, token] = await client.readContract({
@@ -56,7 +56,7 @@ export const _assets = async (client, symbol) => {
  * purchase will revert with `AssetNotTransferable`.
  */
 export const _resolveAsset = async (client, symbol) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -74,7 +74,7 @@ export const _resolveAsset = async (client, symbol) => {
  * but the contract will not assume that on the caller's behalf.
  */
 export const _quote = async (client, symbol, priceUSDCents) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -92,7 +92,7 @@ export const _quote = async (client, symbol, priceUSDCents) => {
  * still reads the adapter's own record from before that move.
  */
 export const _usedReferences = async (client, paymentReference) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -104,7 +104,7 @@ export const _usedReferences = async (client, paymentReference) => {
 };
 /** The address holding upgrade authority over this adapter (its owner). */
 export const _upgradeManager = async (client) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({

package/dist/esm/logic/registry.js

@@ -1,5 +1,5 @@
 import { encodeFunctionData } from "viem";
-import { _getChainSpecificConstants } from "./constants.js";
+import { _chainId, _getChainSpecificConstants } from "./constants.js";
 import { Registry } from "../abis/index.js";
 import { MissingSmartWalletError } from "./errors.js";
 // A userOp from a device wallet arrives at the registry with msg.sender set to the
@@ -27,7 +27,7 @@ import { MissingSmartWalletError } from "./errors.js";
 export const _bindESIMWallet = async (client, eSIMWalletAddress) => {
     if (!client.account)
         throw new MissingSmartWalletError();
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.sendUserOperation({
@@ -53,7 +53,7 @@ export const _bindESIMWallet = async (client, eSIMWalletAddress) => {
 export const _toggleESIMWalletStandbyStatus = async (client, eSIMWalletAddress, isOnStandby) => {
     if (!client.account)
         throw new MissingSmartWalletError();
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.sendUserOperation({
@@ -75,7 +75,7 @@ export const _toggleESIMWalletStandbyStatus = async (client, eSIMWalletAddress,
  * deployed.
  */
 export const _isDeviceIdentifierAlreadyUsed = async (client, deviceUniqueIdentifier) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     // A `view` - read it directly instead of spending a userOp.
@@ -92,7 +92,7 @@ export const _isDeviceIdentifierAlreadyUsed = async (client, deviceUniqueIdentif
  * purchase.
  */
 export const _paused = async (client) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -108,7 +108,7 @@ export const _paused = async (client) => {
  * failure to carry the protocol's own revert reason.
  */
 export const _requireNotPaused = async (client) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     await client.readContract({
@@ -125,7 +125,7 @@ export const _requireNotPaused = async (client) => {
  * holds it now. Ask `deviceWallet.isValidESIMWallet` for that.
  */
 export const _isESIMWalletValid = async (client, eSIMWalletAddress) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -144,7 +144,7 @@ export const _isESIMWalletValid = async (client, eSIMWalletAddress) => {
  * association to still name the device wallet that raised the flag.
  */
 export const _isESIMWalletOnStandby = async (client, eSIMWalletAddress) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -156,7 +156,7 @@ export const _isESIMWalletOnStandby = async (client, eSIMWalletAddress) => {
 };
 /** Whether a device wallet is registered with the protocol. */
 export const _isDeviceWalletValid = async (client, deviceWalletAddress) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -168,7 +168,7 @@ export const _isDeviceWalletValid = async (client, deviceWalletAddress) => {
 };
 /** The device wallet registered for a device identifier, zero if none. */
 export const _uniqueIdentifierToDeviceWallet = async (client, deviceUniqueIdentifier) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -180,7 +180,7 @@ export const _uniqueIdentifierToDeviceWallet = async (client, deviceUniqueIdenti
 };
 /** Whether an eSIM identifier is already held by a wallet. */
 export const _isESIMIdentifierClaimed = async (client, eSIMUniqueIdentifier) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -196,7 +196,7 @@ export const _isESIMIdentifierClaimed = async (client, eSIMUniqueIdentifier) =>
  * belongs to the wallet rather than to whichever device is holding it.
  */
 export const _eSIMWalletForIdentifier = async (client, eSIMUniqueIdentifier) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -208,7 +208,7 @@ export const _eSIMWalletForIdentifier = async (client, eSIMUniqueIdentifier) =>
 };
 /** The fallback price ceiling in USD cents for a wallet holding no cap of its own. */
 export const _defaultPriceCapUSDCents = async (client) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -220,7 +220,7 @@ export const _defaultPriceCapUSDCents = async (client) => {
 };
 /** The payment adapter this registry currently points at. */
 export const _paymentAdapter = async (client) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -236,7 +236,7 @@ export const _paymentAdapter = async (client) => {
  * the contract keys `usedPaymentReferences` by, not the bare reference.
  */
 export const _usedPaymentReferences = async (client, scopedReference) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -252,7 +252,7 @@ export const _usedPaymentReferences = async (client, scopedReference) => {
  * calling it first only turns that revert into a typed error ahead of a userOp.
  */
 export const _requireLazyHistoryCopied = async (client, eSIMWallet) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     await client.readContract({
@@ -269,7 +269,7 @@ export const _requireLazyHistoryCopied = async (client, eSIMWallet) => {
  * all then refuse it.
  */
 export const _requireDeviceIdentifierNotReserved = async (client, deviceUniqueIdentifier) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     await client.readContract({

package/dist/esm/logic/utils.js

@@ -1,6 +1,4 @@
-import { isHex, toHex } from "viem";
-import { AsnParser } from "@peculiar/asn1-schema";
-import { ECDSASigValue } from "@peculiar/asn1-ecc";
+import { isHex } from "viem";
 import { NullOrUndefinedValueError } from "./errors.js";
 export const _add0x = (data) => {
     if (!data) {
@@ -8,12 +6,6 @@ export const _add0x = (data) => {
     }
     return (data.indexOf('0x') !== -1) ? isHex(data) ? data : `0x${data}` : `0x${data}`;
 };
-export const _remove0x = (data) => {
-    if (!data) {
-        throw new NullOrUndefinedValueError();
-    }
-    return (data.indexOf('0x') !== -1) ? data.slice(2) : data;
-};
 export function _shouldRemoveLeadingZero(bytes) {
     return bytes[0] === 0x0 && (bytes[1] & (1 << 7)) !== 0;
 }
@@ -27,75 +19,3 @@ export function _concatUint8Arrays(arrays) {
     });
     return toReturn;
 }
-export function base64UrlToBuffer(base64url) {
-    const base64 = base64url
-        .replace(/-/g, "+")
-        .replace(/_/g, "/")
-        .padEnd((base64url.length + 3) & ~3, "=");
-    return Buffer.from(base64, "base64");
-}
-export function decodeClientDataJSON(base64url) {
-    const base64 = base64url
-        .replace(/-/g, "+")
-        .replace(/_/g, "/")
-        .padEnd((base64url.length + 3) & ~3, "=");
-    const jsonString = Buffer.from(base64, "base64").toString("utf-8");
-    return JSON.parse(jsonString);
-}
-export function hexToArrayBuffer(hexString) {
-    const cleanHex = hexString.startsWith("0x") ? hexString.slice(2) : hexString;
-    const bytes = new Uint8Array(cleanHex.length / 2);
-    for (let i = 0; i < bytes.length; i++) {
-        bytes[i] = parseInt(cleanHex.substr(i * 2, 2), 16);
-    }
-    return bytes.buffer;
-}
-export function parseDEREncodedSignature(signature) {
-    let offset = 0;
-    if (signature[offset++] !== 0x30)
-        throw new Error("Invalid DER sequence");
-    // Sequence length byte. Skipped, because r and s each carry their own length.
-    offset++;
-    if (signature[offset++] !== 0x02)
-        throw new Error("Expected integer for r");
-    const rLen = signature[offset++];
-    const r = signature.slice(offset, offset + rLen);
-    offset += rLen;
-    if (signature[offset++] !== 0x02)
-        throw new Error("Expected integer for s");
-    const sLen = signature[offset++];
-    const s = signature.slice(offset, offset + sLen);
-    return {
-        r: Buffer.from(r).toString("hex"),
-        s: Buffer.from(s).toString("hex"),
-    };
-}
-export function shouldRemoveLeadingZero(bytes) {
-    return bytes[0] === 0x0 && (bytes[1] & (1 << 7)) !== 0;
-}
-export function concatUint8Arrays(arrays) {
-    let pointer = 0;
-    const totalLength = arrays.reduce((prev, curr) => prev + curr.length, 0);
-    const toReturn = new Uint8Array(totalLength);
-    arrays.forEach((arr) => {
-        toReturn.set(arr, pointer);
-        pointer += arr.length;
-    });
-    return toReturn;
-}
-export function parseSignature(signature) {
-    const parsedSignature = AsnParser.parse(signature, ECDSASigValue);
-    let rBytes = new Uint8Array(parsedSignature.r);
-    let sBytes = new Uint8Array(parsedSignature.s);
-    if (shouldRemoveLeadingZero(rBytes)) {
-        rBytes = rBytes.slice(1);
-    }
-    if (shouldRemoveLeadingZero(sBytes)) {
-        sBytes = sBytes.slice(1);
-    }
-    const finalSignature = concatUint8Arrays([rBytes, sBytes]);
-    return {
-        r: toHex(finalSignature.slice(0, 32)),
-        s: toHex(finalSignature.slice(32)),
-    };
-}

package/dist/types/admin/config-admin.d.ts

@@ -8,7 +8,8 @@ import { AdminProtocolAdminSubPackage } from "./interface/protocolAdminClass.js"
 import { AdminDeviceWalletSubPackage } from "./interface/deviceWalletClass.js";
 import { AdminESIMWalletSubPackage } from "./interface/eSIMWalletClass.js";
 import { AdminPaymentAdapterSubPackage } from "./interface/paymentAdapterClass.js";
-export { KokioError, NullOrUndefinedValueError, MissingSmartWalletError, MissingEOAWalletError, InvalidClientError, UnsupportedChainError, UnconfiguredChainError, CounterfactualMismatchError, ContractRevertError, decodeContractRevert, } from "../logic/errors.js";
+import { AdminCallsSubPackage } from "./interface/callsClass.js";
+export { KokioError, NullOrUndefinedValueError, MissingSmartWalletError, MissingEOAWalletError, InvalidClientError, UnsupportedChainError, UnconfiguredChainError, CounterfactualMismatchError, BatchSizeOutOfRangeError, DepositOnResumeError, ESIMWalletNotLazyDeployedError, MissingBatchEventError, StalledBatchError, ContractRevertError, decodeContractRevert, } from "../logic/errors.js";
 export type { DecodedRevert } from "../logic/errors.js";
 export { OperationState } from "../logic/admin/reads/protocolAdmin.reads.js";
 /**
@@ -38,6 +39,8 @@ export declare class KokioAdmin {
     lazyWalletRegistry: AdminLazyWalletRegistrySubPackage;
     protocolAdmin: AdminProtocolAdminSubPackage;
     paymentAdapter: AdminPaymentAdapterSubPackage;
+    /** Calls for the app to sign as a user operation, built here so the backend holds the purchase logic. */
+    calls: AdminCallsSubPackage;
     deviceWallet?: AdminDeviceWalletSubPackage;
     eSIMWallet?: AdminESIMWalletSubPackage;
     constructor(walletClient: WalletClient, deviceWalletAddress?: Address, eSIMWalletAddress?: Address);

package/dist/types/admin/interface/callsClass.d.ts

@@ -0,0 +1,26 @@
+import { Address, Hex, WalletClient } from "viem";
+import { DataBundleDetails } from "../../types.js";
+/**
+ * Builds the calls a user's device wallet signs as one user operation. Nothing
+ * is signed or sent here: hand the result to the app, which passes it to
+ * `deviceWallet.sendUserOperation`. Addresses are passed per call, since one
+ * backend builds calls for many users.
+ */
+export declare class AdminCallsSubPackage {
+    walletClient: WalletClient;
+    constructor(walletClient: WalletClient);
+    /**
+     * The calls `kokio.eSIMWallet.buyDataBundleWithTransfer` sends: a token
+     * transfer from the device wallet for whatever the eSIM wallet is short of,
+     * then the purchase. The purchase emits `DataBundleBoughtWithToken` as usual.
+     */
+    buyDataBundleWithTransfer(eSIMWalletAddress: Address, dataBundleDetails: DataBundleDetails, asset: Hex, maxAmountIn: bigint, paymentReference: Hex): Promise<import("../../types.js").Call[]>;
+    /**
+     * The calls `kokio.eSIMWallet.acceptAndBindESIMWallet` sends, for the device
+     * wallet named in `requestTransferOwnership` to sign. Build them once the
+     * `OwnershipTransferRequested` event names that device wallet as `_newOwner`.
+     */
+    acceptAndBindESIMWallet(eSIMWalletAddress: Address, newDeviceWalletAddress: Address, options?: {
+        grantAccessToFunds?: boolean;
+    }): import("../../types.js").Call[];
+}

package/dist/types/config.d.ts

@@ -9,7 +9,7 @@ import { ESIMWalletSubPackage } from "./interface/eSIMWalletClass.js";
 import { ESIMWalletFactorySubPackage } from "./interface/eSIMWalletFactoryClass.js";
 import { PaymentAdapterSubPackage } from "./interface/paymentAdapterClass.js";
 import { KokioSmartAccountClient } from "./types.js";
-export { KokioError, NullOrUndefinedValueError, MissingSmartWalletError, MissingEOAWalletError, InvalidClientError, UnsupportedChainError, UnconfiguredChainError, CounterfactualMismatchError, ContractRevertError, decodeContractRevert, } from "./logic/errors.js";
+export { KokioError, NullOrUndefinedValueError, MissingSmartWalletError, MissingEOAWalletError, InvalidClientError, UnsupportedChainError, UnconfiguredChainError, CounterfactualMismatchError, BatchSizeOutOfRangeError, DepositOnResumeError, ESIMWalletNotLazyDeployedError, MissingBatchEventError, StalledBatchError, ContractRevertError, decodeContractRevert, } from "./logic/errors.js";
 export type { DecodedRevert } from "./logic/errors.js";
 export declare class Kokio {
     viemWalletClient: WalletClient;

package/dist/types/interface/deviceWalletClass.d.ts

@@ -8,6 +8,18 @@ export declare class DeviceWalletSubPackage {
     sendUserOperation(calls: Call[]): Promise<`0x${string}`>;
     addDeposit(amount: bigint): Promise<`0x${string}`>;
     addESIMWallet(eSIMWalletAddress: Address): Promise<`0x${string}`>;
+    /**
+     * Deploy an eSIM wallet and bind it to this device wallet in one user
+     * operation, optionally granting it access to this wallet's tokens too.
+     * Resolves once the operation is sent, with its hash and the eSIM wallet's
+     * address.
+     */
+    deployAndBindESIMWallet(salt: bigint, options?: {
+        grantAccessToFunds?: boolean;
+    }): Promise<{
+        userOpHash: Hex;
+        eSIMWalletAddress: Address;
+    }>;
     getVaultAddress(): Promise<`0x${string}`>;
     removeESIMWallet(eSIMWalletAddress: Address, callBackETH: boolean): Promise<`0x${string}`>;
     toggleAccessToFunds(eSIMWalletAddress: Address, hasAccessToFunds: boolean): Promise<`0x${string}`>;

package/dist/types/interface/eSIMWalletClass.d.ts

@@ -6,7 +6,21 @@ export declare class ESIMWalletSubPackage {
     address: `0x${string}`;
     constructor(client: KokioSmartAccountClient, address: Address);
     acceptOwnershipTransfer(): Promise<`0x${string}`>;
+    /**
+     * Accept this eSIM wallet's transfer and bind it to the signing device
+     * wallet in one user operation, optionally granting it access to that
+     * wallet's tokens too.
+     */
+    acceptAndBindESIMWallet(options?: {
+        grantAccessToFunds?: boolean;
+    }): Promise<`0x${string}`>;
     buyDataBundleWithToken(dataBundleDetails: DataBundleDetails, asset: Hex, maxAmountIn: bigint, paymentReference: Hex): Promise<`0x${string}`>;
+    /**
+     * Same purchase as `buyDataBundleWithToken`, with the device wallet sending
+     * the tokens it needs in the same user operation. Works without having granted
+     * this eSIM wallet access to the device wallet's funds.
+     */
+    buyDataBundleWithTransfer(dataBundleDetails: DataBundleDetails, asset: Hex, maxAmountIn: bigint, paymentReference: Hex): Promise<`0x${string}`>;
     priceCapUSDCents(): Promise<bigint>;
     deviceWallet(): Promise<`0x${string}`>;
     owner(): Promise<`0x${string}`>;

package/dist/types/interface/eSIMWalletFactoryClass.d.ts

@@ -4,6 +4,12 @@ export declare class ESIMWalletFactorySubPackage {
     smartAccountClient: KokioSmartAccountClient;
     walletClient: WalletClient;
     constructor(walletClient: WalletClient, smartAccountClient: KokioSmartAccountClient);
+    /**
+     * @deprecated Deploys without binding, so the device wallet does not treat the
+     * new eSIM wallet as its own. Use `deviceWallet.deployAndBindESIMWallet`.
+     */
     deployESIMWalletWithUserOp(deviceWalletAddress: Address, salt: bigint): Promise<`0x${string}`>;
+    /** Address the eSIM wallet for this device wallet and salt deploys to. */
+    getCounterFactualAddress(deviceWalletAddress: Address, salt: bigint): Promise<`0x${string}`>;
     getCurrentESIMWalletImplementation(): Promise<`0x${string}`>;
 }

package/dist/types/interface/registryClass.d.ts

@@ -3,6 +3,14 @@ import { KokioSmartAccountClient } from "../types.js";
 export declare class RegistrySubPackage {
     client: KokioSmartAccountClient;
     constructor(client: KokioSmartAccountClient);
+    /**
+     * Record in the registry that this device wallet holds the eSIM wallet.
+     *
+     * Registry side only: the device wallet itself still does not treat the eSIM
+     * wallet as its own (`isValidESIMWallet` stays false, so it cannot manage it or
+     * grant it fund access). To take on an eSIM wallet use `deviceWallet.addESIMWallet`,
+     * which writes both sides.
+     */
     bindESIMWallet(eSIMWalletAddress: Address): Promise<`0x${string}`>;
     toggleESIMWalletStandbyStatus(eSIMWalletAddress: Address, isOnStandby: boolean): Promise<`0x${string}`>;
     isDeviceIdentifierAlreadyUsed(deviceUniqueIdentifier: string): Promise<boolean>;

package/dist/types/interface/smartAccountClass.d.ts

@@ -8,5 +8,14 @@ export declare class SmartAccountSubPackage {
     gasPolicyId: string;
     constructor(client: WalletClient, credentialId: string, rpId: string, pimlicoAPIKey: string, gasPolicyId: string);
     getSmartWallet(deviceUniqueIdentifier: string, deviceWalletOwnerKey: P256Key, salt: bigint): Promise<KokioSmartAccount>;
-    getSmartWalletClient(account: KokioSmartAccount): Promise<KokioSmartAccountClient>;
+    /**
+     * Client that sends the account's user operations through a bundler, with
+     * gas sponsored by the paymaster at the same endpoint.
+     *
+     * @param options.bundlerUrl Bundler and ERC-7677 paymaster endpoint. Defaults to
+     * Pimlico for the wallet client's chain, keyed by the API key given to `Kokio`.
+     */
+    getSmartWalletClient(account: KokioSmartAccount, options?: {
+        bundlerUrl?: string;
+    }): Promise<KokioSmartAccountClient>;
 }

package/dist/types/logic/account-kit/createSmartAccount.d.ts

@@ -63,5 +63,5 @@ type RawGasEstimate = Record<string, Hex>;
  * override placed on the client is never the one it calls.
  */
 export declare const _padGasEstimate: (estimate: RawGasEstimate) => RawGasEstimate;
-export declare const _getSmartWalletClient: (client: WalletClient, pimlicoAPIKey: string, gasPolicyId: string, account: KokioSmartAccount) => Promise<KokioSmartAccountClient>;
+export declare const _getSmartWalletClient: (client: WalletClient, pimlicoAPIKey: string, gasPolicyId: string, account: KokioSmartAccount, bundlerUrl?: string) => Promise<KokioSmartAccountClient>;
 export {};

package/dist/types/logic/calls/eSIMWallet.calls.d.ts

@@ -0,0 +1,25 @@
+import { Address, Client, Hex, PublicActions } from "viem";
+import { Call, DataBundleDetails } from "../../types.js";
+/** Any client that can read contracts: the mobile smart account client, or a wallet client extended with `publicActions`. */
+export type CallBuilderClient = Pick<PublicActions, "readContract" | "getChainId"> & Pick<Client, "transport">;
+/**
+ * The calls for buying a data bundle with tokens the device wallet sends over
+ * in the same user operation, so the eSIM wallet needs no access to the device
+ * wallet's funds.
+ *
+ * Only the shortfall is sent: the quote for the bundle minus what the eSIM
+ * wallet already holds of `asset`, worked out when this runs. If that balance
+ * or the quote changes before the operation lands, it reverts, so build the
+ * calls again rather than resending old ones.
+ */
+export declare const _buyDataBundleWithTransferCalls: (client: CallBuilderClient, eSIMWalletAddress: Address, dataBundleDetails: DataBundleDetails, asset: Hex, maxAmountIn: bigint, paymentReference: Hex) => Promise<Call[]>;
+/**
+ * The calls for the new device wallet to take over an eSIM wallet another
+ * device wallet asked to hand it: accept the transfer, then bind it, which also
+ * tells the registry and clears the standby flag.
+ *
+ * Accepting first is what lets the bind through: it makes this device wallet
+ * the owner and clears the pending transfer. Fund access cannot be granted at
+ * bind time, so `grantAccessToFunds` adds a `toggleAccessToFunds` after it.
+ */
+export declare const _acceptAndBindESIMWalletCalls: (eSIMWalletAddress: Address, deviceWalletAddress: Address, grantAccessToFunds: boolean) => Call[];

package/dist/types/logic/constants.d.ts

@@ -18,5 +18,8 @@ export interface chainSpecifcConstants {
 export declare const baseMainnetFactoryAddresses: Record<string, Address>;
 export declare const baseSepoliaFactoryAddresses: Record<string, Address>;
 export declare const customErrors: Record<string, string>;
+export declare const _chainId: (client: {
+    getChainId: () => Promise<number>;
+}) => Promise<number>;
 export declare const _extractChainID: (client: WalletClient) => Promise<number>;
 export declare const _getChainSpecificConstants: (chainID: CHAIN_ID.BASE_MAINNET | CHAIN_ID.BASE_SEPOLIA, rpcURL: string, pimlicoAPIKey?: string) => chainSpecifcConstants;

package/dist/types/logic/deviceWallet.d.ts

@@ -19,6 +19,18 @@ export declare const _toggleAccessToFunds: (client: KokioSmartAccountClient, add
  * a bind from undoing the owner's revocation.
  */
 export declare const _addESIMWallet: (client: KokioSmartAccountClient, address: Address, eSIMWalletAddress: Address) => Promise<`0x${string}`>;
+/**
+ * Deploy an eSIM wallet for this device wallet and bind it, in one user operation.
+ *
+ * Fund access cannot be granted at bind time, so `grantAccessToFunds` adds a
+ * `toggleAccessToFunds` after the bind in the same operation. The device wallet
+ * must already be registered (`registry.isDeviceWalletValid`), or the factory
+ * refuses it.
+ */
+export declare const _deployAndBindESIMWallet: (client: KokioSmartAccountClient, address: Address, salt: bigint, grantAccessToFunds: boolean) => Promise<{
+    userOpHash: Hex;
+    eSIMWalletAddress: Address;
+}>;
 /**
  * Release an eSIM wallet and put it on standby for a transfer.
  *

package/dist/types/logic/eSIMWallet.d.ts

@@ -21,6 +21,15 @@ export declare const _setPriceCapUSDCents: (client: KokioSmartAccountClient, add
  * inventing one.
  */
 export declare const _buyDataBundleWithToken: (client: KokioSmartAccountClient, address: Address, dataBundleDetails: DataBundleDetails, asset: Hex, maxAmountIn: bigint, paymentReference: Hex) => Promise<`0x${string}`>;
+/**
+ * Buy a data bundle with tokens the device wallet sends over in the same user
+ * operation, so the eSIM wallet needs no access to the device wallet's funds.
+ *
+ * Only the shortfall is sent: the quote for the bundle minus what this eSIM
+ * wallet already holds of `asset`. Arguments are as for `buyDataBundleWithToken`.
+ * The backend builds the same calls with `admin.calls.buyDataBundleWithTransfer`.
+ */
+export declare const _buyDataBundleWithTransfer: (client: KokioSmartAccountClient, address: Address, dataBundleDetails: DataBundleDetails, asset: Hex, maxAmountIn: bigint, paymentReference: Hex) => Promise<`0x${string}`>;
 /**
  * Send an ERC-20 held by this eSIM wallet back to its owning device wallet.
  * `onlyDeviceWallet`.
@@ -61,4 +70,11 @@ export declare const _deviceWallet: (client: KokioSmartAccountClient, address: A
 export declare const _transactionHistory: (client: KokioSmartAccountClient, address: Address, index: bigint) => Promise<DataBundleDetails>;
 export declare const _requestTransferOwnership: (client: KokioSmartAccountClient, address: Address, newOwner: Address) => Promise<`0x${string}`>;
 export declare const _acceptOwnershipTransfer: (client: KokioSmartAccountClient, address: Address) => Promise<`0x${string}`>;
+/**
+ * Accept an eSIM wallet another device wallet asked to hand over, and bind it,
+ * in one user operation. `grantAccessToFunds` also lets it pull this device
+ * wallet's tokens. The backend builds the same calls with
+ * `admin.calls.acceptAndBindESIMWallet`.
+ */
+export declare const _acceptAndBindESIMWallet: (client: KokioSmartAccountClient, address: Address, grantAccessToFunds: boolean) => Promise<`0x${string}`>;
 export declare const _sendETHToDeviceWallet: (client: KokioSmartAccountClient, address: Address, amount: bigint) => Promise<`0x${string}`>;

package/dist/types/logic/eSIMWalletFactory.d.ts

@@ -1,4 +1,6 @@
 import { Address } from "viem";
 import { KokioSmartAccountClient } from "../types.js";
 export declare const _deployESIMWalletWithUserOp: (client: KokioSmartAccountClient, deviceWalletAddress: Address, salt: bigint) => Promise<`0x${string}`>;
+/** Address `deployESIMWallet` deploys to for this device wallet and salt. */
+export declare const _getESIMWalletCounterFactualAddress: (client: KokioSmartAccountClient, deviceWalletAddress: Address, salt: bigint) => Promise<Address>;
 export declare const _getCurrentESIMWalletImplementation: (client: KokioSmartAccountClient) => Promise<Address>;

package/dist/types/logic/errors.d.ts

@@ -107,14 +107,15 @@ export declare class ContractRevertError extends KokioError {
     constructor(data: Hex);
 }
 /**
- * Pulls a ContractRevertError out of an error thrown by viem, or `null` if it
- * isn't a revert viem could decode a selector for.
+ * Pulls a ContractRevertError out of an error thrown by viem, or `null` when
+ * the error carries no revert data (a network failure, a rejected signature).
  */
 export declare const toContractRevertError: (err: unknown) => ContractRevertError | null;
 /**
- * `client.writeContract`, but a recognised on-chain revert comes back as a
- * ContractRevertError instead of viem's raw error chain. Anything else -
- * network failures, an unrecognised revert selector - is rethrown as-is.
+ * `client.writeContract`, but a revert comes back as a ContractRevertError
+ * instead of viem's raw error chain. Its `decoded` is null when the selector
+ * belongs to none of the Kokio contracts. Anything that is not a revert, such
+ * as a network failure, is rethrown as-is.
  *
  * Mirrors `WalletClient["writeContract"]`'s own generics rather than reading
  * them off `Parameters<...>`, since that would collapse the per-call overload

package/dist/types/logic/utils.d.ts

@@ -1,25 +1,4 @@
 import { Hex } from "viem";
 export declare const _add0x: (data: Hex | string) => Hex;
-export declare const _remove0x: (data: Hex | string) => string;
 export declare function _shouldRemoveLeadingZero(bytes: Uint8Array): boolean;
 export declare function _concatUint8Arrays(arrays: Uint8Array[]): Uint8Array;
-export declare function base64UrlToBuffer(base64url: string): Buffer;
-export interface ClientDataJSON {
-    type: string;
-    challenge: string;
-    origin: string;
-    crossOrigin?: boolean;
-    [key: string]: unknown;
-}
-export declare function decodeClientDataJSON(base64url: string): ClientDataJSON;
-export declare function hexToArrayBuffer(hexString: string): ArrayBuffer;
-export declare function parseDEREncodedSignature(signature: Uint8Array): {
-    r: string;
-    s: string;
-};
-export declare function shouldRemoveLeadingZero(bytes: Uint8Array): boolean;
-export declare function concatUint8Arrays(arrays: Uint8Array[]): Uint8Array;
-export declare function parseSignature(signature: Uint8Array): {
-    r: `0x${string}`;
-    s: `0x${string}`;
-};

package/dist/types/types.d.ts

@@ -20,7 +20,7 @@ export type OwnerCall = {
     abi: Abi;
     functionName: string;
     args?: readonly unknown[];
-    /** ETH sent with the call. The timelock has to be holding it. */
+    /** ETH sent with the call. `executor.execute` attaches it from the executing account. */
     value?: bigint;
 };
 /**