kokio-sdk 3.0.1 → 3.1.0

package/README.md

@@ -22,13 +22,19 @@ surface, with a code example and return type, see the
 
 ## Installation
 
+In the mobile app:
+
+```sh
+npm install kokio-sdk react-native-passkey
+```
+
+On a backend that only uses `kokio-sdk/admin`:
+
 ```sh
 npm install kokio-sdk
 ```
 
-The package ships as ES modules and requires Node 18 or newer (or a React Native
-runtime). `viem` is bundled as a dependency, so you do not need to install it
-separately.
+The package ships as ES modules and requires Node 18 or newer (or a React Native runtime). `viem` is bundled as a dependency, so you do not need to install it separately. `react-native-passkey` is a native module, so the app installs it itself: Expo only links native modules the app lists directly, and one copy avoids version clashes.
 
 ## Mobile client (Expo / React Native)
 
@@ -39,10 +45,9 @@ is ever held in the app.
 
 You will need:
 
-- a viem `WalletClient` connected to the target chain, carrying an `account`
-  and an explicit RPC URL (see the note under the example),
+- a viem `WalletClient` connected to the target chain with an explicit RPC URL (see the note under the example). It needs no `account`: the passkey signs every user operation.
 - the passkey `credentialId` and `rpId` registered for the device,
-- a Pimlico API key and a gas policy id (used by the bundler and paymaster).
+- a Pimlico API key, and optionally a Pimlico sponsorship policy id (`sp_...`). Pass `""` to be sponsored without a policy.
 
 ```ts
 import { Kokio } from "kokio-sdk";
@@ -50,7 +55,6 @@ import { createWalletClient, http } from "viem";
 import { baseSepolia } from "viem/chains";
 
 const walletClient = createWalletClient({
-  account: knownAddress,
   chain: baseSepolia,
   transport: http(rpcUrl),
 });
@@ -90,15 +94,11 @@ const receipt = await smartAccountClient.waitForUserOperationReceipt({ hash });
 if (!receipt.success) throw new Error("operation reverted");
 ```
 
-Two things about the wallet client. It has to carry an `account`:
-`getSmartWallet` refuses a client without one, though it never asks it for a
-signature, since the passkey signs everything. And give `http()` a real RPC
-URL, because the SDK reads `client.transport.url` to build the public client
-it uses for contract reads.
+The wallet client needs no `account`, since the passkey signs everything. Give `http()` a real RPC URL, because the SDK reads `client.transport.url` to build the public client it uses for contract reads.
+
+Every write resolves with the user operation hash once the bundler accepts it, not once it is mined, so wait for the receipt as above. An operation the bundler can see will revert is refused before it is sent, and the write rejects with a `ContractRevertError` whose `decoded.errorName` names the contract error (for example `PaymentReferenceAlreadyUsed`). One that only reverts once mined still returns a receipt, so check `receipt.success` too. `receipt.receipt.transactionHash` is the onchain transaction.
 
-Check `receipt.success`. An operation whose calls revert is still mined and
-still returns a receipt, so the await resolving is not on its own proof the
-write landed. `receipt.receipt.transactionHash` is the onchain transaction.
+Calls that belong together have helpers that send them as one user operation, so the user sees one passkey prompt: `deviceWallet.deployAndBindESIMWallet(salt, { grantAccessToFunds: true })` deploys an eSIM wallet, binds it and grants it access to the device wallet's tokens, and `eSIMWallet.buyDataBundleWithTransfer(...)` sends the tokens and buys in one go, without pull access.
 
 The contract surfaces (`deviceWallet`, `eSIMWallet`, `deviceWalletFactory`,
 `eSIMWalletFactory`, `registry`, `paymentAdapter`, `P256Verifier`) are only

package/dist/esm/admin/config-admin.js

@@ -10,7 +10,7 @@ import { AdminPaymentAdapterSubPackage } from "./interface/paymentAdapterClass.j
 // Re-export the typed error surface so backend consumers can `instanceof
 // KokioError` (or a subclass) and decode reverts without reaching into internal
 // module paths - mirroring `config.ts`.
-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";
 // `getOperationState` answers with this, and comparing against it needs the enum
 // at runtime rather than only in the types.
 export { OperationState } from "../logic/admin/reads/protocolAdmin.reads.js";

package/dist/esm/config.js

@@ -10,7 +10,7 @@ import { PaymentAdapterSubPackage } from "./interface/paymentAdapterClass.js";
 // Re-export the typed error surface so consumers can `instanceof KokioError`
 // (or a specific subclass) and decode on-chain reverts without reaching into
 // internal module paths.
-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 class Kokio {
     viemWalletClient;
     credentialId;

package/dist/esm/interface/deviceWalletClass.js

@@ -1,4 +1,4 @@
-import { _addDeposit, _addESIMWallet, _canPullFunds, _deviceUniqueIdentifier, _entryPoint, _eSIMWalletFactory, _getDeposit, _getOwner, _getVaultAddress, _isValidESIMWallet, _isValidSignature, _registry, _removeESIMWallet, _sendUserOperation, _toggleAccessToFunds, _transferOwnership, _verifier, _withdrawDepositTo } from "../logic/deviceWallet.js";
+import { _addDeposit, _addESIMWallet, _canPullFunds, _deployAndBindESIMWallet, _deviceUniqueIdentifier, _entryPoint, _eSIMWalletFactory, _getDeposit, _getOwner, _getVaultAddress, _isValidESIMWallet, _isValidSignature, _registry, _removeESIMWallet, _sendUserOperation, _toggleAccessToFunds, _transferOwnership, _verifier, _withdrawDepositTo } from "../logic/deviceWallet.js";
 export class DeviceWalletSubPackage {
     smartAccountClient;
     walletClient;
@@ -17,6 +17,15 @@ export class DeviceWalletSubPackage {
     addESIMWallet(eSIMWalletAddress) {
         return _addESIMWallet(this.smartAccountClient, this.address, eSIMWalletAddress);
     }
+    /**
+     * 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, options = {}) {
+        return _deployAndBindESIMWallet(this.smartAccountClient, this.address, salt, options.grantAccessToFunds ?? false);
+    }
     getVaultAddress() {
         return _getVaultAddress(this.smartAccountClient, this.address);
     }

package/dist/esm/interface/eSIMWalletClass.js

@@ -1,4 +1,4 @@
-import { _acceptOwnershipTransfer, _buyDataBundleWithToken, _priceCapUSDCents, _deviceWallet, _owner, _requestTransferOwnership, _sendETHToDeviceWallet, _sendTokenToDeviceWallet, _setPriceCapUSDCents, _transactionHistory } from "../logic/eSIMWallet.js";
+import { _acceptOwnershipTransfer, _buyDataBundleWithToken, _buyDataBundleWithTransfer, _priceCapUSDCents, _deviceWallet, _owner, _requestTransferOwnership, _sendETHToDeviceWallet, _sendTokenToDeviceWallet, _setPriceCapUSDCents, _transactionHistory } from "../logic/eSIMWallet.js";
 export class ESIMWalletSubPackage {
     client;
     address;
@@ -12,6 +12,14 @@ export class ESIMWalletSubPackage {
     buyDataBundleWithToken(dataBundleDetails, asset, maxAmountIn, paymentReference) {
         return _buyDataBundleWithToken(this.client, this.address, dataBundleDetails, asset, maxAmountIn, paymentReference);
     }
+    /**
+     * 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, asset, maxAmountIn, paymentReference) {
+        return _buyDataBundleWithTransfer(this.client, this.address, dataBundleDetails, asset, maxAmountIn, paymentReference);
+    }
     priceCapUSDCents() {
         return _priceCapUSDCents(this.client, this.address);
     }

package/dist/esm/interface/eSIMWalletFactoryClass.js

@@ -1,4 +1,4 @@
-import { _deployESIMWalletWithUserOp, _getCurrentESIMWalletImplementation } from "../logic/eSIMWalletFactory.js";
+import { _deployESIMWalletWithUserOp, _getCurrentESIMWalletImplementation, _getESIMWalletCounterFactualAddress } from "../logic/eSIMWalletFactory.js";
 export class ESIMWalletFactorySubPackage {
     smartAccountClient;
     walletClient;
@@ -6,9 +6,17 @@ export class ESIMWalletFactorySubPackage {
         this.smartAccountClient = smartAccountClient;
         this.walletClient = walletClient;
     }
+    /**
+     * @deprecated Deploys without binding, so the device wallet does not treat the
+     * new eSIM wallet as its own. Use `deviceWallet.deployAndBindESIMWallet`.
+     */
     deployESIMWalletWithUserOp(deviceWalletAddress, salt) {
         return _deployESIMWalletWithUserOp(this.smartAccountClient, deviceWalletAddress, salt);
     }
+    /** Address the eSIM wallet for this device wallet and salt deploys to. */
+    getCounterFactualAddress(deviceWalletAddress, salt) {
+        return _getESIMWalletCounterFactualAddress(this.smartAccountClient, deviceWalletAddress, salt);
+    }
     getCurrentESIMWalletImplementation() {
         return _getCurrentESIMWalletImplementation(this.smartAccountClient);
     }

package/dist/esm/interface/registryClass.js

@@ -4,6 +4,14 @@ export class RegistrySubPackage {
     constructor(client) {
         this.client = client;
     }
+    /**
+     * 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) {
         return _bindESIMWallet(this.client, eSIMWalletAddress);
     }

package/dist/esm/interface/smartAccountClass.js

@@ -15,7 +15,14 @@ export class SmartAccountSubPackage {
     getSmartWallet(deviceUniqueIdentifier, deviceWalletOwnerKey, salt) {
         return _getSmartWallet(this.client, this.credentialId, this.rpId, deviceUniqueIdentifier, deviceWalletOwnerKey, salt);
     }
-    getSmartWalletClient(account) {
-        return _getSmartWalletClient(this.client, this.pimlicoAPIKey, this.gasPolicyId, account);
+    /**
+     * 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, options = {}) {
+        return _getSmartWalletClient(this.client, this.pimlicoAPIKey, this.gasPolicyId, account, options.bundlerUrl);
     }
 }

package/dist/esm/logic/P256Verifier.js

@@ -1,9 +1,9 @@
-import { _getChainSpecificConstants } from "./constants.js";
+import { _chainId, _getChainSpecificConstants } from "./constants.js";
 import { P256Verifier } from "../abis/index.js";
 // `verifySignature` is a `view` - read it directly instead of spending a userOp
 // (the previous userOp form returned a userOp hash, never the boolean result).
 export const _verifySignature = async (client, message, requireMessageVerification, webAuthnSignature, x, y) => {
-    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/account-kit/createSmartAccount.js

@@ -1,11 +1,13 @@
 import { http, createPublicClient, createTransport, publicActions, encodeFunctionData, encodePacked, encodeAbiParameters, parseAbiParameters, getContract, concat, keccak256, getContractAddress, getAddress, hashMessage, toHex, hashTypedData, hexToBytes, bytesToHex } from "viem";
 import { createBundlerClient, createPaymasterClient, entryPoint08Abi, getUserOperationHash, toSmartAccount } from "viem/account-abstraction";
-import { _getChainSpecificConstants, ZERO, SIGNATURE_VALIDITY_SECONDS, STUB_VERIFICATION_GAS_PAD, STUB_PRE_VERIFICATION_GAS_PAD } from "../constants.js";
-import { CounterfactualMismatchError } from "../errors.js";
+import { _chainId, _getChainSpecificConstants, ZERO, SIGNATURE_VALIDITY_SECONDS, STUB_VERIFICATION_GAS_PAD, STUB_PRE_VERIFICATION_GAS_PAD } from "../constants.js";
+import { CounterfactualMismatchError, toContractRevertError } from "../errors.js";
 import { DeviceWallet, DeviceWalletFactory } from "../../abis/index.js";
-import { isoBase64URL } from "@simplewebauthn/server/helpers";
+import { base64urlnopad } from "@scure/base";
 import { Passkey } from "react-native-passkey";
 import { p256 } from "@noble/curves/nist.js";
+// Authenticators differ on padding and alphabet, so accept either form.
+const fromBase64URL = (value) => base64urlnopad.decode(value.replace(/=+$/, "").replace(/\+/g, "-").replace(/\//g, "_"));
 var AuthenticatorTransport;
 (function (AuthenticatorTransport) {
     AuthenticatorTransport["usb"] = "usb";
@@ -39,10 +41,7 @@ export const BEACON_PROXY_CREATION_CODE = "0x60a0806040526104e480380380916100178
  */
 export const _stamp = async (credentialId, rpId, payload) => {
     const signingOptions = {
-        // `Uint8Array.from` gives a fresh ArrayBuffer-backed view, matching the
-        // `Uint8Array<ArrayBuffer>` that `fromBuffer` expects (viem's `hexToBytes`
-        // is typed over the wider `ArrayBufferLike`).
-        challenge: isoBase64URL.fromBuffer(Uint8Array.from(hexToBytes(payload))),
+        challenge: base64urlnopad.encode(hexToBytes(payload)),
         allowCredentials: [{
                 id: credentialId,
                 type: "public-key",
@@ -69,7 +68,7 @@ export const _stamp = async (credentialId, rpId, payload) => {
     }
     const { clientDataJSON, authenticatorData, signature } = authenticationResult.response;
     // 1. Decode clientDataJSON
-    const clientDataJSONBuffer = isoBase64URL.toBuffer(clientDataJSON);
+    const clientDataJSONBuffer = fromBase64URL(clientDataJSON);
     const clientDataJSONString = new TextDecoder().decode(clientDataJSONBuffer);
     // 2. Calculate indices for the contract (byte offsets)
     const typeSearchString = '"type":"webauthn.get"';
@@ -88,14 +87,10 @@ export const _stamp = async (credentialId, rpId, payload) => {
         throw new Error(`Could not find challenge substring '${challengeSearchString}' in clientDataJSON for index calculation.`);
     }
     // 3. Decode authenticatorData
-    const authenticatorDataBytes = isoBase64URL.toBuffer(authenticatorData);
+    const authenticatorDataBytes = fromBase64URL(authenticatorData);
     const authenticatorDataHex = bytesToHex(authenticatorDataBytes);
     // 4. Decode signature (ASN.1 DER encoded)
-    const signatureBytes = isoBase64URL.toBuffer(signature);
-    // let parsedSignature = p256.Signature.fromDER(signatureBytes);
-    let parsedSignature = p256.Signature.fromBytes(signatureBytes instanceof Uint8Array
-        ? signatureBytes
-        : new Uint8Array(signatureBytes), "der");
+    let parsedSignature = p256.Signature.fromBytes(fromBase64URL(signature), "der");
     // Normalize s
     const n = p256.Point.CURVE().n;
     const halfN = n >> 1n;
@@ -134,7 +129,7 @@ export const _encodeCalls = async (calls) => {
     });
 };
 export const _getFactoryArgs = async (client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     const factoryData = encodeFunctionData({
@@ -145,7 +140,7 @@ export const _getFactoryArgs = async (client, deviceUniqueIdentifier, deviceWall
     return { factory: values.factoryAddresses.DEVICE_WALLET_FACTORY, factoryData };
 };
 export const getInitCodeHash = async (client, deviceUniqueIdentifier, deviceWalletOwnerKey) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     // off-chain computation of the DeviceWallet address
@@ -176,7 +171,7 @@ export const getInitCodeHash = async (client, deviceUniqueIdentifier, deviceWall
     return keccak256(initCode);
 };
 export const getCounterFactualAddress = async (client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     const deviceWalletFactoryAddress = values.factoryAddresses.DEVICE_WALLET_FACTORY;
@@ -204,20 +199,23 @@ export const getCounterFactualAddress = async (client, deviceUniqueIdentifier, d
  * an unconditional check, e.g. right after a contract redeploy.
  */
 export const _assertCounterfactualMatchesOnChain = async (client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
-    const offChain = await getCounterFactualAddress(client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt);
     const deviceWalletFactory = getContract({
         abi: DeviceWalletFactory,
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         client,
     });
-    // on-chain view arg order is (ownerKey, uid, salt) - differs from createAccount
-    const onChain = await deviceWalletFactory.read.getCounterFactualAddress([
-        deviceWalletOwnerKey,
-        deviceUniqueIdentifier,
-        salt,
+    // Neither side needs the other, so both are asked for at once.
+    const [offChain, onChain] = await Promise.all([
+        getCounterFactualAddress(client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt),
+        // on-chain view arg order is (ownerKey, uid, salt) - differs from createAccount
+        deviceWalletFactory.read.getCounterFactualAddress([
+            deviceWalletOwnerKey,
+            deviceUniqueIdentifier,
+            salt,
+        ]),
     ]);
     if (getAddress(offChain) !== getAddress(onChain)) {
         throw new CounterfactualMismatchError(getAddress(offChain), getAddress(onChain));
@@ -293,11 +291,9 @@ export const _signUserOperationHash = async (credentialId, rpId, userOpHash) =>
 // same chain skip the extra RPC the drift guard costs.
 const _counterfactualVerifiedChains = new Set();
 export const _getSmartWallet = async (client, credentialId, rpId, deviceUniqueIdentifier, deviceWalletOwnerKey, salt) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
-    if (!client.account)
-        throw new Error('Error: No signer account found with WalletClient');
     const accountAddress = _counterfactualVerifiedChains.has(chainID)
         ? await getCounterFactualAddress(client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt)
         : await _assertCounterfactualMatchesOnChain(client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt);
@@ -385,20 +381,35 @@ const _splitTransport = (pimlicoRpcURL, rpcURL) => {
     // RPC has to stay readable here.
     { url: rpcURL });
 };
-export const _getSmartWalletClient = async (client, pimlicoAPIKey, gasPolicyId, account) => {
-    const chainID = await client.getChainId();
+export const _getSmartWalletClient = async (client, pimlicoAPIKey, gasPolicyId, account, bundlerUrl) => {
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL, pimlicoAPIKey);
-    // Pimlico sponsors via ERC-7677, keyed by the gas policy.
-    const paymaster = createPaymasterClient({ transport: http(values.pimlicoRpcURL) });
-    return createBundlerClient({
+    const bundlerURL = bundlerUrl ?? values.pimlicoRpcURL;
+    // Pimlico sponsors via ERC-7677 and reads the policy from `sponsorshipPolicyId`.
+    // A policy is optional there, so an empty id sends no context at all.
+    const paymaster = createPaymasterClient({ transport: http(bundlerURL) });
+    const bundlerClient = createBundlerClient({
         account,
         chain: values.chain,
         client: createPublicClient({ chain: values.chain, transport: http(values.rpcURL) }),
-        transport: _splitTransport(values.pimlicoRpcURL, values.rpcURL),
+        transport: _splitTransport(bundlerURL, values.rpcURL),
         paymaster,
-        paymasterContext: { policyId: gasPolicyId },
-        // extend() keeps the bundler fields at runtime but drops them from the
-        // inferred type, so the result is re-asserted rather than narrowed.
+        paymasterContext: gasPolicyId ? { sponsorshipPolicyId: gasPolicyId } : undefined,
     }).extend(publicActions);
+    // Every user operation the SDK sends goes through here, so a revert is
+    // decoded once for all of them, the same way admin writes are.
+    const sendUserOperation = bundlerClient.sendUserOperation;
+    // extend() keeps the bundler fields at runtime but drops them from the
+    // inferred type, so the result is re-asserted rather than narrowed.
+    return bundlerClient.extend(() => ({
+        sendUserOperation: (async (args) => {
+            try {
+                return await sendUserOperation(args);
+            }
+            catch (err) {
+                throw toContractRevertError(err) ?? err;
+            }
+        }),
+    }));
 };

package/dist/esm/logic/admin/deviceWallet.eoa.js

@@ -1,4 +1,4 @@
-import { _getChainSpecificConstants } from "../constants.js";
+import { _chainId, _getChainSpecificConstants } from "../constants.js";
 import { MissingEOAWalletError, writeContractOrThrow } from "../errors.js";
 import { DeviceWallet } from "../../abis/index.js";
 // Admin-EOA logic targeting a specific `DeviceWallet` instance (its address is
@@ -14,7 +14,7 @@ import { DeviceWallet } from "../../abis/index.js";
  * `toggleAccessToETH`, which the admin EOA cannot reach.
  */
 export const _deployESIMWallet = async (client, deviceWalletAddress, salt) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -22,7 +22,7 @@ export const _deployESIMWallet = async (client, deviceWalletAddress, salt) => {
     return writeContractOrThrow(client, {
         address: deviceWalletAddress,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: DeviceWallet,
         functionName: 'deployESIMWallet',
         args: [false, salt]
@@ -36,7 +36,7 @@ export const _deployESIMWallet = async (client, deviceWalletAddress, salt) => {
  * out, and topping one up is not a way to reach its funds.
  */
 export const _addDeposit = async (client, deviceWalletAddress, amount) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -44,7 +44,7 @@ export const _addDeposit = async (client, deviceWalletAddress, amount) => {
     return writeContractOrThrow(client, {
         address: deviceWalletAddress,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: DeviceWallet,
         functionName: 'addDeposit',
         args: [],

package/dist/esm/logic/admin/deviceWalletFactory.eoa.js

@@ -1,4 +1,4 @@
-import { _getChainSpecificConstants } from "../constants.js";
+import { _chainId, _getChainSpecificConstants } from "../constants.js";
 import { MissingEOAWalletError, writeContractOrThrow } from "../errors.js";
 import { DeviceWalletFactory } from "../../abis/index.js";
 // Admin-EOA logic for `DeviceWalletFactory`.
@@ -19,7 +19,7 @@ import { DeviceWalletFactory } from "../../abis/index.js";
  * is drawn; any surplus is refunded to the caller on chain.
  */
 export const _deployDeviceWalletForUsers = async (client, deviceUniqueIdentifiers, deviceWalletOwnersKey, salts, depositAmounts, value) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -27,7 +27,7 @@ export const _deployDeviceWalletForUsers = async (client, deviceUniqueIdentifier
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: DeviceWalletFactory,
         functionName: 'deployDeviceWalletForUsers',
         args: [deviceUniqueIdentifiers, deviceWalletOwnersKey, salts, depositAmounts],
@@ -40,7 +40,7 @@ export const _deployDeviceWalletForUsers = async (client, deviceUniqueIdentifier
  * factory rederives the counterfactual address from it to check the wallet.
  */
 export const _postCreateAccount = async (client, deviceWallet, deviceUniqueIdentifier, deviceWalletOwnerKey, salt) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -48,7 +48,7 @@ export const _postCreateAccount = async (client, deviceWallet, deviceUniqueIdent
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: DeviceWalletFactory,
         functionName: 'postCreateAccount',
         args: [deviceWallet, deviceUniqueIdentifier, deviceWalletOwnerKey, salt]
@@ -56,7 +56,7 @@ export const _postCreateAccount = async (client, deviceWallet, deviceUniqueIdent
 };
 /** One-time wiring of the registry into the factory. `onlyAdmin`. */
 export const _addRegistryAddress = async (client, registryContractAddress) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -64,7 +64,7 @@ export const _addRegistryAddress = async (client, registryContractAddress) => {
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: DeviceWalletFactory,
         functionName: 'addRegistryAddress',
         args: [registryContractAddress]
@@ -72,7 +72,7 @@ export const _addRegistryAddress = async (client, registryContractAddress) => {
 };
 /** Point the device-wallet beacon at a new implementation. `onlyOwner` (upgradeManager). */
 export const _updateDeviceWalletImplementation = async (client, newDeviceImpl) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -80,7 +80,7 @@ export const _updateDeviceWalletImplementation = async (client, newDeviceImpl) =
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: DeviceWalletFactory,
         functionName: 'updateDeviceWalletImplementation',
         args: [newDeviceImpl]
@@ -100,7 +100,7 @@ export const _updateDeviceWalletImplementation = async (client, newDeviceImpl) =
  * it, so the new owner can move every deployed device wallet at once.
  */
 export const _transferOwnershipCall = async (client, newOwner) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return {
@@ -119,7 +119,7 @@ export const _transferOwnershipCall = async (client, newOwner) => {
  * instead. Changing what the factory deploys next is a beacon update, not this.
  */
 export const _upgradeCall = async (client, newImplementation, data = '0x') => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return {
@@ -138,7 +138,7 @@ export const _upgradeCall = async (client, newImplementation, data = '0x') => {
  * at once.
  */
 export const _acceptOwnership = async (client) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -146,7 +146,7 @@ export const _acceptOwnership = async (client) => {
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: DeviceWalletFactory,
         functionName: 'acceptOwnership',
         args: []

package/dist/esm/logic/admin/eSIMWallet.eoa.js

@@ -1,4 +1,4 @@
-import { _getChainSpecificConstants } from "../constants.js";
+import { _chainId, _getChainSpecificConstants } from "../constants.js";
 import { MissingEOAWalletError, writeContractOrThrow } from "../errors.js";
 import { ESIMWallet } from "../../abis/index.js";
 // Admin-EOA logic targeting a specific `ESIMWallet` instance (address passed in).
@@ -14,7 +14,7 @@ import { ESIMWallet } from "../../abis/index.js";
  * spendable once per eSIM wallet.
  */
 export const _buyDataBundleWithToken = async (client, eSIMWalletAddress, dataBundleDetails, asset, maxAmountIn, paymentReference) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -22,7 +22,7 @@ export const _buyDataBundleWithToken = async (client, eSIMWalletAddress, dataBun
     return writeContractOrThrow(client, {
         address: eSIMWalletAddress,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: ESIMWallet,
         functionName: 'buyDataBundleWithToken',
         args: [dataBundleDetails, asset, maxAmountIn, paymentReference]

package/dist/esm/logic/admin/eSIMWalletFactory.eoa.js

@@ -1,4 +1,4 @@
-import { _getChainSpecificConstants } from "../constants.js";
+import { _chainId, _getChainSpecificConstants } from "../constants.js";
 import { MissingEOAWalletError, writeContractOrThrow } from "../errors.js";
 import { ESIMWalletFactory } from "../../abis/index.js";
 // Admin-EOA logic for `ESIMWalletFactory`. Both functions are owner-gated
@@ -14,7 +14,7 @@ import { ESIMWalletFactory } from "../../abis/index.js";
 // `onlyRegistryOrDeviceWalletFactoryOrDeviceWallet`, so a bare EOA always reverts.
 /** One-time wiring of the registry into the eSIM factory. Owner only. */
 export const _addRegistryAddress = async (client, registryContractAddress) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -22,7 +22,7 @@ export const _addRegistryAddress = async (client, registryContractAddress) => {
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.ESIM_WALLET_FACTORY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: ESIMWalletFactory,
         functionName: 'addRegistryAddress',
         args: [registryContractAddress]
@@ -30,7 +30,7 @@ export const _addRegistryAddress = async (client, registryContractAddress) => {
 };
 /** Point the eSIM-wallet beacon at a new implementation. `onlyOwner`. */
 export const _updateESIMWalletImplementation = async (client, eSIMWalletImpl) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -38,7 +38,7 @@ export const _updateESIMWalletImplementation = async (client, eSIMWalletImpl) =>
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.ESIM_WALLET_FACTORY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: ESIMWalletFactory,
         functionName: 'updateESIMWalletImplementation',
         args: [eSIMWalletImpl]
@@ -58,7 +58,7 @@ export const _updateESIMWalletImplementation = async (client, eSIMWalletImpl) =>
  * it, so the new owner can move every deployed eSIM wallet at once.
  */
 export const _transferOwnershipCall = async (client, newOwner) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return {
@@ -76,7 +76,7 @@ export const _transferOwnershipCall = async (client, newOwner) => {
  * the beacon, which moves through `updateESIMWalletImplementation` instead.
  */
 export const _upgradeCall = async (client, newImplementation, data = '0x') => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return {
@@ -95,7 +95,7 @@ export const _upgradeCall = async (client, newImplementation, data = '0x') => {
  * at once.
  */
 export const _acceptOwnership = async (client) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -103,7 +103,7 @@ export const _acceptOwnership = async (client) => {
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.ESIM_WALLET_FACTORY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: ESIMWalletFactory,
         functionName: 'acceptOwnership',
         args: []