kokio-sdk 3.0.2 → 3.2.0

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

@@ -1,4 +1,4 @@
-import { _getChainSpecificConstants } from "../constants.js";
+import { _chainId, _getChainSpecificConstants } from "../constants.js";
 import { MissingEOAWalletError, writeContractOrThrow } from "../errors.js";
 import { Registry } from "../../abis/index.js";
 // Admin-EOA logic for `Registry`. Most of this is `onlyOwner`, so the `client`
@@ -11,7 +11,7 @@ import { Registry } from "../../abis/index.js";
 // deployments whose owner is a plain EOA or multisig.
 /** Wire (or rewire) the LazyWalletRegistry into the Registry. `onlyOwner`. */
 export const _addOrUpdateLazyWalletRegistryAddress = async (client, lazyWalletRegistry) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -19,7 +19,7 @@ export const _addOrUpdateLazyWalletRegistryAddress = async (client, lazyWalletRe
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.REGISTRY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: Registry,
         functionName: 'addOrUpdateLazyWalletRegistryAddress',
         args: [lazyWalletRegistry]
@@ -27,7 +27,7 @@ export const _addOrUpdateLazyWalletRegistryAddress = async (client, lazyWalletRe
 };
 /** Update the vault that receives eSIM payments. `onlyOwner`. */
 export const _updateVaultAddress = async (client, newVaultAddress) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -35,7 +35,7 @@ export const _updateVaultAddress = async (client, newVaultAddress) => {
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.REGISTRY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: Registry,
         functionName: 'updateVaultAddress',
         args: [newVaultAddress]
@@ -51,7 +51,7 @@ export const _updateVaultAddress = async (client, newVaultAddress) => {
  * incumbent instead withdraws a pending nomination and hands the role back.
  */
 export const _requestAdminUpdate = async (client, newAdmin) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -59,7 +59,7 @@ export const _requestAdminUpdate = async (client, newAdmin) => {
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.REGISTRY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: Registry,
         functionName: 'requestAdminUpdate',
         args: [newAdmin]
@@ -73,7 +73,7 @@ export const _requestAdminUpdate = async (client, newAdmin) => {
  * rather than passing quietly and leaving the caller believing it acted.
  */
 export const _disableAdmin = 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)
@@ -81,7 +81,7 @@ export const _disableAdmin = async (client) => {
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.REGISTRY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: Registry,
         functionName: 'disableAdmin',
         args: []
@@ -95,7 +95,7 @@ export const _disableAdmin = async (client) => {
  * incumbent. Reverts if the admin was never suspended.
  */
 export const _enableAdmin = 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 _enableAdmin = async (client) => {
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.REGISTRY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: Registry,
         functionName: 'enableAdmin',
         args: []
@@ -119,7 +119,7 @@ export const _enableAdmin = async (client) => {
  * funds through their device wallet's `execute`, which a pause never reaches.
  */
 export const _pause = 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)
@@ -127,7 +127,7 @@ export const _pause = async (client) => {
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.REGISTRY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: Registry,
         functionName: 'pause',
         args: []
@@ -141,7 +141,7 @@ export const _pause = async (client) => {
  * `unpauseInstantly` if the wait is not acceptable.
  */
 export const _unpause = 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)
@@ -149,7 +149,7 @@ export const _unpause = async (client) => {
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.REGISTRY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: Registry,
         functionName: 'unpause',
         args: []
@@ -164,7 +164,7 @@ export const _unpause = async (client) => {
  * for every wallet without one of its own.
  */
 export const _setDefaultPriceCapUSDCents = async (client, cap) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -172,7 +172,7 @@ export const _setDefaultPriceCapUSDCents = async (client, cap) => {
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.REGISTRY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: Registry,
         functionName: 'setDefaultPriceCapUSDCents',
         args: [cap]
@@ -185,7 +185,7 @@ export const _setDefaultPriceCapUSDCents = async (client, cap) => {
  * wallet reverts rather than moving.
  */
 export const _assignESIMIdentifier = async (client, eSIMWalletAddress, eSIMUniqueIdentifier) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -193,7 +193,7 @@ export const _assignESIMIdentifier = async (client, eSIMWalletAddress, eSIMUniqu
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.REGISTRY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: Registry,
         functionName: 'assignESIMIdentifier',
         args: [eSIMWalletAddress, eSIMUniqueIdentifier]
@@ -209,7 +209,7 @@ export const _assignESIMIdentifier = async (client, eSIMWalletAddress, eSIMUniqu
  * `_paymentReference` is spendable once per eSIM wallet.
  */
 export const _recordSettledPurchase = async (client, eSIMWalletAddress, dataBundleDetail, asset, tokenAmount, paymentReference) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -217,7 +217,7 @@ export const _recordSettledPurchase = async (client, eSIMWalletAddress, dataBund
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.REGISTRY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: Registry,
         functionName: 'recordSettledPurchase',
         args: [eSIMWalletAddress, dataBundleDetail, asset, tokenAmount, paymentReference]
@@ -229,7 +229,7 @@ export const _recordSettledPurchase = async (client, eSIMWalletAddress, dataBund
  * newly nominated admin EOA.
  */
 export const _acceptAdminUpdate = 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)
@@ -237,7 +237,7 @@ export const _acceptAdminUpdate = async (client) => {
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.REGISTRY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: Registry,
         functionName: 'acceptAdminUpdate',
         args: []
@@ -253,7 +253,7 @@ export const _acceptAdminUpdate = async (client) => {
  * accepts for every contract at once and needs no delay.
  */
 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)
@@ -261,7 +261,7 @@ export const _acceptOwnership = async (client) => {
     return writeContractOrThrow(client, {
         address: values.factoryAddresses.REGISTRY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: Registry,
         functionName: 'acceptOwnership',
         args: []
@@ -282,7 +282,7 @@ export const _acceptOwnership = async (client) => {
  * ownership where it is rather than stranding it.
  */
 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 {
@@ -305,7 +305,7 @@ export const _transferOwnershipCall = async (client, newOwner) => {
  * again ends the proxy's life. Diff the storage layout before scheduling.
  */
 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 {

package/dist/esm/logic/calls/eSIMWallet.calls.js

@@ -0,0 +1,72 @@
+import { encodeFunctionData, erc20Abi } from "viem";
+import { DeviceWallet, ESIMWallet, PaymentAdapter, Registry } from "../../abis/index.js";
+import { _chainId, _getChainSpecificConstants } from "../constants.js";
+/**
+ * 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 const _buyDataBundleWithTransferCalls = async (client, eSIMWalletAddress, dataBundleDetails, asset, maxAmountIn, paymentReference) => {
+    const chainID = await _chainId(client);
+    const values = _getChainSpecificConstants(chainID, client.transport.url);
+    // The eSIM wallet pays through whichever adapter the registry names, so read it there.
+    const adapter = await client.readContract({
+        address: values.factoryAddresses.REGISTRY, abi: Registry, functionName: "paymentAdapter"
+    });
+    const [{ token }, amountIn] = await Promise.all([
+        client.readContract({
+            address: adapter, abi: PaymentAdapter, functionName: "resolveAsset", args: [asset]
+        }),
+        client.readContract({
+            address: adapter, abi: PaymentAdapter, functionName: "quote", args: [asset, dataBundleDetails.priceUSDCents]
+        }),
+    ]);
+    const held = await client.readContract({
+        address: token, abi: erc20Abi, functionName: "balanceOf", args: [eSIMWalletAddress]
+    });
+    const buy = {
+        to: eSIMWalletAddress,
+        data: encodeFunctionData({
+            abi: ESIMWallet,
+            functionName: "buyDataBundleWithToken",
+            args: [dataBundleDetails, asset, maxAmountIn, paymentReference]
+        })
+    };
+    if (held >= amountIn)
+        return [buy];
+    return [
+        {
+            to: token,
+            data: encodeFunctionData({ abi: erc20Abi, functionName: "transfer", args: [eSIMWalletAddress, amountIn - held] })
+        },
+        buy
+    ];
+};
+/**
+ * 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 const _acceptAndBindESIMWalletCalls = (eSIMWalletAddress, deviceWalletAddress, grantAccessToFunds) => {
+    const self = (functionName, hasAccessToFunds) => ({
+        to: deviceWalletAddress,
+        data: encodeFunctionData({ abi: DeviceWallet, functionName, args: [eSIMWalletAddress, hasAccessToFunds] })
+    });
+    return [
+        {
+            to: eSIMWalletAddress,
+            data: encodeFunctionData({ abi: ESIMWallet, functionName: "acceptOwnershipTransfer", args: [] })
+        },
+        self("addESIMWallet", false),
+        ...(grantAccessToFunds ? [self("toggleAccessToFunds", true)] : [])
+    ];
+};

package/dist/esm/logic/constants.js

@@ -54,11 +54,24 @@ export const customErrors = {
     MISSING_SMART_WALLET: "Error: Client does not have smart wallet account associated",
     MISSING_EOA_WALLET: "Error: Client does not have EOA wallet associated"
 };
+// A client's RPC URL is fixed, so its chain id is too. Asking once per client
+// saves every later SDK call a round trip to the node.
+const chainIds = new WeakMap();
+export const _chainId = (client) => {
+    let chainId = chainIds.get(client);
+    if (!chainId) {
+        chainId = client.getChainId();
+        chainIds.set(client, chainId);
+        // A failed lookup is not remembered, so the next call asks again.
+        chainId.catch(() => chainIds.delete(client));
+    }
+    return chainId;
+};
 export const _extractChainID = async (client) => {
     if (!client) {
         throw new InvalidClientError();
     }
-    return client.getChainId();
+    return _chainId(client);
 };
 // Maps each supported chain id to its factory-address book + viem chain. Base
 // Mainnet is listed with '0x' placeholders so the guard below rejects it with a

package/dist/esm/logic/deviceWallet.js

@@ -1,6 +1,8 @@
 import { encodeFunctionData, getContract } from "viem";
-import { DeviceWallet } from "../abis/index.js";
+import { DeviceWallet, ESIMWalletFactory } from "../abis/index.js";
 import { MissingSmartWalletError } from "./errors.js";
+import { _chainId, _getChainSpecificConstants } from "./constants.js";
+import { _getESIMWalletCounterFactualAddress } from "./eSIMWalletFactory.js";
 // A userOp from a device wallet runs through `execute`, so at the target contract
 // msg.sender is the device-wallet account itself. That constrains which DeviceWallet
 // functions this surface can expose:
@@ -72,6 +74,38 @@ export const _addESIMWallet = async (client, address, eSIMWalletAddress) => {
             }]
     });
 };
+/**
+ * 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 const _deployAndBindESIMWallet = async (client, address, salt, grantAccessToFunds) => {
+    const chainID = await _chainId(client);
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    if (!client.account)
+        throw new MissingSmartWalletError();
+    const eSIMWalletAddress = await _getESIMWalletCounterFactualAddress(client, address, salt);
+    const self = (functionName, hasAccessToFunds) => ({
+        to: address,
+        data: encodeFunctionData({ abi: DeviceWallet, functionName, args: [eSIMWalletAddress, hasAccessToFunds] })
+    });
+    const userOpHash = await client.sendUserOperation({
+        account: client.account,
+        calls: [
+            {
+                to: values.factoryAddresses.ESIM_WALLET_FACTORY,
+                data: encodeFunctionData({ abi: ESIMWalletFactory, functionName: "deployESIMWallet", args: [address, salt] })
+            },
+            self("addESIMWallet", false),
+            ...(grantAccessToFunds ? [self("toggleAccessToFunds", true)] : [])
+        ]
+    });
+    return { userOpHash, eSIMWalletAddress };
+};
 /**
  * Release an eSIM wallet and put it on standby for a transfer.
  *

package/dist/esm/logic/deviceWalletFactory.js

@@ -1,8 +1,8 @@
-import { _getChainSpecificConstants } from "./constants.js";
+import { _chainId, _getChainSpecificConstants } from "./constants.js";
 import { MissingEOAWalletError } from "./errors.js";
 import { DeviceWalletFactory } from "../abis/index.js";
 export const _createAccountWithEOA = async (client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt, depositAmount) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
@@ -12,7 +12,7 @@ export const _createAccountWithEOA = async (client, deviceUniqueIdentifier, devi
     return client.writeContract({
         address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
         chain: values.chain,
-        account: client.account.address,
+        account: client.account,
         abi: DeviceWalletFactory,
         functionName: 'createAccount',
         args: [deviceUniqueIdentifier, deviceWalletOwnerKey, salt],
@@ -23,7 +23,7 @@ export const _createAccountWithEOA = async (client, deviceUniqueIdentifier, devi
 // On-chain arg order is (bytes32[2] ownerKey, string uid, uint256 salt); note this
 // differs from `createAccount`.
 export const _getAddress = 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);
     return client.readContract({
@@ -35,7 +35,7 @@ export const _getAddress = async (client, deviceUniqueIdentifier, deviceWalletOw
 };
 // `getCurrentDeviceWalletImplementation` is a `view` - read it directly instead of a userOp.
 export const _getCurrentDeviceWalletImplementation = 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({
@@ -57,7 +57,7 @@ export const _getCurrentDeviceWalletImplementation = async (client) => {
  * Reverts on an empty identifier or a key that is not a point on the P256 curve.
  */
 export const _preCreateAccountValidation = async (client, deviceUniqueIdentifier, deviceWalletOwnerKey) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -73,7 +73,7 @@ export const _preCreateAccountValidation = async (client, deviceUniqueIdentifier
  * registers it.
  */
 export const _deviceWalletInfoAdded = async (client, deviceWallet) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     return client.readContract({
@@ -88,7 +88,7 @@ export const _deviceWalletInfoAdded = async (client, deviceWallet) => {
  * all of them and no wallet can decline it.
  */
 export const _beacon = 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({
@@ -100,7 +100,7 @@ export const _beacon = async (client) => {
 };
 /** The registry the factory writes new wallets into. */
 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({
@@ -112,7 +112,7 @@ export const _registry = async (client) => {
 };
 /** The EntryPoint baked into every device wallet this factory deploys. */
 export const _entryPoint = 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({
@@ -124,7 +124,7 @@ export const _entryPoint = async (client) => {
 };
 /** The contract new device wallets verify WebAuthn assertions through. */
 export const _verifier = 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/eSIMWallet.js

@@ -2,6 +2,7 @@ import { encodeFunctionData, maxUint256 } from "viem";
 import { MissingSmartWalletError } from "./errors.js";
 import { ESIMWallet } from "../abis/index.js";
 import { _defaultPriceCapUSDCents } from "./registry.js";
+import { _acceptAndBindESIMWalletCalls, _buyDataBundleWithTransferCalls } from "./calls/eSIMWallet.calls.js";
 // Not exposed on this surface:
 //   - populateHistory and setESIMUniqueIdentifier are `onlyRegistry` - callable
 //     only by the registry contract. Naming an eSIM goes through
@@ -61,6 +62,22 @@ export const _buyDataBundleWithToken = async (client, address, dataBundleDetails
             }]
     });
 };
+/**
+ * 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 const _buyDataBundleWithTransfer = async (client, address, dataBundleDetails, asset, maxAmountIn, paymentReference) => {
+    if (!client.account)
+        throw new MissingSmartWalletError();
+    return client.sendUserOperation({
+        account: client.account,
+        calls: await _buyDataBundleWithTransferCalls(client, address, dataBundleDetails, asset, maxAmountIn, paymentReference)
+    });
+};
 /**
  * Send an ERC-20 held by this eSIM wallet back to its owning device wallet.
  * `onlyDeviceWallet`.
@@ -180,6 +197,21 @@ export const _acceptOwnershipTransfer = async (client, address) => {
             }]
     });
 };
+/**
+ * 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 const _acceptAndBindESIMWallet = async (client, address, grantAccessToFunds) => {
+    if (!client.account)
+        throw new MissingSmartWalletError();
+    // UserOp - the sender is the pending `newRequestedOwner`, and then the owner the bind needs.
+    return client.sendUserOperation({
+        account: client.account,
+        calls: _acceptAndBindESIMWalletCalls(address, client.account.address, grantAccessToFunds)
+    });
+};
 export const _sendETHToDeviceWallet = async (client, address, amount) => {
     if (!client.account)
         throw new MissingSmartWalletError();

package/dist/esm/logic/eSIMWalletFactory.js

@@ -1,5 +1,5 @@
 import { encodeFunctionData } from "viem";
-import { _getChainSpecificConstants } from "./constants.js";
+import { _chainId, _getChainSpecificConstants } from "./constants.js";
 import { MissingSmartWalletError } from "./errors.js";
 import { ESIMWalletFactory } from "../abis/index.js";
 // Not exposed on this surface:
@@ -10,7 +10,7 @@ import { ESIMWalletFactory } from "../abis/index.js";
 // `deployESIMWalletWithUserOp` works because a registered device wallet passes
 // `registry.isDeviceWalletValid(msg.sender)`, so the userOp sender satisfies the modifier.
 export const _deployESIMWalletWithUserOp = 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)
@@ -28,8 +28,20 @@ export const _deployESIMWalletWithUserOp = async (client, deviceWalletAddress, s
             }]
     });
 };
+/** Address `deployESIMWallet` deploys to for this device wallet and salt. */
+export const _getESIMWalletCounterFactualAddress = async (client, deviceWalletAddress, salt) => {
+    const chainID = await _chainId(client);
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    return client.readContract({
+        address: values.factoryAddresses.ESIM_WALLET_FACTORY,
+        abi: ESIMWalletFactory,
+        functionName: "getCounterFactualAddress",
+        args: [deviceWalletAddress, salt]
+    });
+};
 export const _getCurrentESIMWalletImplementation = async (client) => {
-    const chainID = await client.getChainId();
+    const chainID = await _chainId(client);
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     // `getCurrentESIMWalletImplementation` is a `view` - read it directly instead of a userOp.

package/dist/esm/logic/errors.js

@@ -1,5 +1,5 @@
 import { BaseError, ContractFunctionRevertedError, decodeErrorResult, isHex, } from "viem";
-import { DeviceWallet, DeviceWalletFactory, ESIMWallet, ESIMWalletFactory, LazyWalletRegistry, P256Verifier, Registry, RegistryHelper, } from "../abis/index.js";
+import { DeviceWallet, DeviceWalletFactory, ESIMWallet, ESIMWalletFactory, LazyWalletRegistry, P256Verifier, Registry, RegistryHelper, ProtocolAdmin, PaymentAdapter, } from "../abis/index.js";
 /**
  * Base class for every error the Kokio SDK throws deliberately. Consumers can
  * `instanceof KokioError` to distinguish SDK-originated failures from viem /
@@ -144,6 +144,8 @@ const REVERTABLE_ABIS = [
     P256Verifier,
     Registry,
     RegistryHelper,
+    ProtocolAdmin,
+    PaymentAdapter,
 ];
 /**
  * Best-effort decode of raw revert data (the ABI-encoded `Error(string)`,
@@ -181,21 +183,25 @@ export class ContractRevertError extends KokioError {
     }
 }
 /**
- * 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 const toContractRevertError = (err) => {
     if (!(err instanceof BaseError))
         return null;
     const revert = err.walk((e) => e instanceof ContractFunctionRevertedError);
-    if (!(revert instanceof ContractFunctionRevertedError) || !revert.raw)
-        return null;
-    return new ContractRevertError(revert.raw);
+    if (revert instanceof ContractFunctionRevertedError && revert.raw)
+        return new ContractRevertError(revert.raw);
+    // A bundler rejects a reverting user operation while estimating its gas, and
+    // puts the revert data only in the error message.
+    const data = err.details?.match(/reverted during simulation with reason: (0x[0-9a-fA-F]+)/)?.[1];
+    return data ? new ContractRevertError(data) : 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