kokio-sdk 1.0.0 → 2.0.0

package/dist/esm/interface/deviceWalletClass.js

@@ -1,4 +1,4 @@
-import { _addESIMWallet, _getOwner, _getVaultAddress, _removeESIMWallet, _toggleAccessToETH } from "../logic/deviceWallet.js";
+import { _addDeposit, _addESIMWallet, _canPullETH, _deviceUniqueIdentifier, _entryPoint, _eSIMWalletFactory, _getDeposit, _getOwner, _getVaultAddress, _isValidESIMWallet, _isValidSignature, _registry, _removeESIMWallet, _sendUserOperation, _toggleAccessToETH, _transferOwnership, _verifier, _withdrawDepositTo } from "../logic/deviceWallet.js";
 export class DeviceWalletSubPackage {
     smartAccountClient;
     walletClient;
@@ -8,19 +8,59 @@ export class DeviceWalletSubPackage {
         this.walletClient = walletClient;
         this.address = address;
     }
-    addESIMWallet(eSIMWalletAddress, hasAccessToETH) {
-        return _addESIMWallet(this.smartAccountClient, this.address, eSIMWalletAddress, hasAccessToETH);
+    sendUserOperation(calls) {
+        return _sendUserOperation(this.smartAccountClient, calls);
+    }
+    addDeposit(amount) {
+        return _addDeposit(this.smartAccountClient, this.address, amount);
+    }
+    addESIMWallet(eSIMWalletAddress) {
+        return _addESIMWallet(this.smartAccountClient, this.address, eSIMWalletAddress);
     }
     getVaultAddress() {
         return _getVaultAddress(this.smartAccountClient, this.address);
     }
-    removeESIMWallet(eSIMWalletAddress, hasAccessToETH) {
-        return _removeESIMWallet(this.smartAccountClient, this.address, eSIMWalletAddress, hasAccessToETH);
+    removeESIMWallet(eSIMWalletAddress, callBackETH) {
+        return _removeESIMWallet(this.smartAccountClient, this.address, eSIMWalletAddress, callBackETH);
     }
     toggleAccessToETH(eSIMWalletAddress, hasAccessToETH) {
         return _toggleAccessToETH(this.smartAccountClient, this.address, eSIMWalletAddress, hasAccessToETH);
     }
+    transferOwnership(newOwner) {
+        return _transferOwnership(this.smartAccountClient, this.address, newOwner);
+    }
+    withdrawDepositTo(withdrawAddress, amount) {
+        return _withdrawDepositTo(this.smartAccountClient, this.address, withdrawAddress, amount);
+    }
+    // Reads
+    canPullETH(eSIMWalletAddress) {
+        return _canPullETH(this.smartAccountClient, this.address, eSIMWalletAddress);
+    }
+    deviceUniqueIdentifier() {
+        return _deviceUniqueIdentifier(this.smartAccountClient, this.address);
+    }
+    entryPoint() {
+        return _entryPoint(this.smartAccountClient, this.address);
+    }
+    eSIMWalletFactory() {
+        return _eSIMWalletFactory(this.smartAccountClient, this.address);
+    }
+    getDeposit() {
+        return _getDeposit(this.smartAccountClient, this.address);
+    }
     getOwner() {
         return _getOwner(this.walletClient, this.address);
     }
+    isValidESIMWallet(eSIMWalletAddress) {
+        return _isValidESIMWallet(this.smartAccountClient, this.address, eSIMWalletAddress);
+    }
+    isValidSignature(messageHash, signature) {
+        return _isValidSignature(this.smartAccountClient, this.address, messageHash, signature);
+    }
+    registry() {
+        return _registry(this.smartAccountClient, this.address);
+    }
+    verifier() {
+        return _verifier(this.smartAccountClient, this.address);
+    }
 }

package/dist/esm/interface/deviceWalletFactoryClass.js

@@ -1,4 +1,4 @@
-import { _createAccountWithEOA, _getAddress, _getCurrentDeviceWalletImplementation } from "../logic/deviceWalletFactory.js";
+import { _createAccountWithEOA, _getAddress, _getCurrentDeviceWalletImplementation, _preCreateAccountValidation, _deviceWalletInfoAdded, _beacon, _registry, _entryPoint, _verifier } from "../logic/deviceWalletFactory.js";
 export class DeviceWalletFactorySubPackage {
     smartAccountClient;
     walletClient;
@@ -15,4 +15,23 @@ export class DeviceWalletFactorySubPackage {
     getCurrentDeviceWalletImplementation() {
         return _getCurrentDeviceWalletImplementation(this.smartAccountClient);
     }
+    // Reads
+    preCreateAccountValidation(deviceUniqueIdentifier, deviceWalletOwnerKey) {
+        return _preCreateAccountValidation(this.smartAccountClient, deviceUniqueIdentifier, deviceWalletOwnerKey);
+    }
+    deviceWalletInfoAdded(deviceWallet) {
+        return _deviceWalletInfoAdded(this.smartAccountClient, deviceWallet);
+    }
+    beacon() {
+        return _beacon(this.smartAccountClient);
+    }
+    registry() {
+        return _registry(this.smartAccountClient);
+    }
+    entryPoint() {
+        return _entryPoint(this.smartAccountClient);
+    }
+    verifier() {
+        return _verifier(this.smartAccountClient);
+    }
 }

package/dist/esm/interface/eSIMWalletClass.js

@@ -1,4 +1,4 @@
-import { _acceptOwnershipTransfer, _buyDataBundle, _owner, _requestTransferOwnership, _sendETHToDeviceWallet, _setESIMUniqueIdentifier } from "../logic/eSIMWallet.js";
+import { _acceptOwnershipTransfer, _buyDataBundle, _dataBundlePriceCap, _deviceWallet, _owner, _requestTransferOwnership, _sendETHToDeviceWallet, _setDataBundlePriceCap, _transactionHistory } from "../logic/eSIMWallet.js";
 export class ESIMWalletSubPackage {
     client;
     address;
@@ -12,6 +12,12 @@ export class ESIMWalletSubPackage {
     buyDataBundle(dataBundleDetails) {
         return _buyDataBundle(this.client, this.address, dataBundleDetails);
     }
+    dataBundlePriceCap() {
+        return _dataBundlePriceCap(this.client, this.address);
+    }
+    deviceWallet() {
+        return _deviceWallet(this.client, this.address);
+    }
     owner() {
         return _owner(this.client, this.address);
     }
@@ -21,7 +27,10 @@ export class ESIMWalletSubPackage {
     sendETHToDeviceWallet(amount) {
         return _sendETHToDeviceWallet(this.client, this.address, amount);
     }
-    setESIMUniqueIdentifier(eSIMUniqueIdentifier) {
-        return _setESIMUniqueIdentifier(this.client, this.address, eSIMUniqueIdentifier);
+    setDataBundlePriceCap(cap) {
+        return _setDataBundlePriceCap(this.client, this.address, cap);
+    }
+    transactionHistory(index) {
+        return _transactionHistory(this.client, this.address, index);
     }
 }

package/dist/esm/interface/registryClass.js

@@ -0,0 +1,47 @@
+import { _bindESIMWallet, _toggleESIMWalletStandbyStatus, _isDeviceIdentifierAlreadyUsed, _paused, _requireNotPaused, _isESIMWalletValid, _isESIMWalletOnStandby, _isDeviceWalletValid, _uniqueIdentifierToDeviceWallet, _isESIMIdentifierClaimed, _eSIMWalletForIdentifier, _defaultDataBundlePriceCap, _requireDeviceIdentifierNotReserved } from "../logic/registry.js";
+export class RegistrySubPackage {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    bindESIMWallet(eSIMWalletAddress) {
+        return _bindESIMWallet(this.client, eSIMWalletAddress);
+    }
+    toggleESIMWalletStandbyStatus(eSIMWalletAddress, isOnStandby) {
+        return _toggleESIMWalletStandbyStatus(this.client, eSIMWalletAddress, isOnStandby);
+    }
+    // Reads
+    isDeviceIdentifierAlreadyUsed(deviceUniqueIdentifier) {
+        return _isDeviceIdentifierAlreadyUsed(this.client, deviceUniqueIdentifier);
+    }
+    paused() {
+        return _paused(this.client);
+    }
+    requireNotPaused() {
+        return _requireNotPaused(this.client);
+    }
+    isESIMWalletValid(eSIMWalletAddress) {
+        return _isESIMWalletValid(this.client, eSIMWalletAddress);
+    }
+    isESIMWalletOnStandby(eSIMWalletAddress) {
+        return _isESIMWalletOnStandby(this.client, eSIMWalletAddress);
+    }
+    isDeviceWalletValid(deviceWalletAddress) {
+        return _isDeviceWalletValid(this.client, deviceWalletAddress);
+    }
+    uniqueIdentifierToDeviceWallet(deviceUniqueIdentifier) {
+        return _uniqueIdentifierToDeviceWallet(this.client, deviceUniqueIdentifier);
+    }
+    isESIMIdentifierClaimed(eSIMUniqueIdentifier) {
+        return _isESIMIdentifierClaimed(this.client, eSIMUniqueIdentifier);
+    }
+    eSIMWalletForIdentifier(eSIMUniqueIdentifier) {
+        return _eSIMWalletForIdentifier(this.client, eSIMUniqueIdentifier);
+    }
+    defaultDataBundlePriceCap() {
+        return _defaultDataBundlePriceCap(this.client);
+    }
+    requireDeviceIdentifierNotReserved(deviceUniqueIdentifier) {
+        return _requireDeviceIdentifierNotReserved(this.client, deviceUniqueIdentifier);
+    }
+}

package/dist/esm/interface/smartAccountClass.js

@@ -3,19 +3,17 @@ export class SmartAccountSubPackage {
     client;
     credentialId;
     rpId;
-    organizationId;
     pimlicoAPIKey;
     gasPolicyId;
-    constructor(client, credentialId, rpId, organiationId, pimlicoAPIKey, gasPolicyId) {
+    constructor(client, credentialId, rpId, pimlicoAPIKey, gasPolicyId) {
         this.client = client;
         this.credentialId = credentialId;
         this.rpId = rpId;
-        this.organizationId = organiationId;
         this.pimlicoAPIKey = pimlicoAPIKey;
         this.gasPolicyId = gasPolicyId;
     }
     getSmartWallet(deviceUniqueIdentifier, deviceWalletOwnerKey, salt) {
-        return _getSmartWallet(this.client, this.credentialId, this.rpId, this.organizationId, 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);

package/dist/esm/logic/account-kit/createSmartAccount.js

@@ -1,8 +1,7 @@
-import { createSmartAccountClient, getEntryPoint, toSmartContractAccount, split, erc7677Middleware } from "@aa-sdk/core";
-import { http, encodeFunctionData, encodePacked, encodeAbiParameters, parseAbiParameters, getContract, concat, keccak256, getContractAddress, getAddress, hashMessage, toHex, hashTypedData, hexToBytes, bytesToHex } from "viem";
-import { _getChainSpecificConstants, ZERO, SIGNATURE_VALIDITY_SECONDS } from "../constants.js";
+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 { _remove0x } from "../utils.js";
 import { DeviceWallet, DeviceWalletFactory } from "../../abis/index.js";
 import { isoBase64URL } from "@simplewebauthn/server/helpers";
 import { Passkey } from "react-native-passkey";
@@ -24,19 +23,20 @@ var AuthenticatorTransport;
  * DeviceWalletFactory deploys, or the computed address will diverge from the
  * deployed one. Source of truth:
  *   OpenZeppelin Contracts v5.0.0 - proxy/beacon/BeaconProxy.sol
- *   compiled by Hardhat (smart-contract-suite `artifacts/@openzeppelin/contracts/
- *   proxy/beacon/BeaconProxy.sol/BeaconProxy.json`), solc 0.8.25+commit.b61c2a91,
- *   optimizer { enabled: true, runs: 200 }, viaIR: true.
- * NOTE: the Foundry `out/` artifact (different optimizer settings) produces a
- * DIFFERENT bytecode - do not swap it in without re-verifying the counterfactual.
- * `_assertCounterfactualMatchesOnChain` guards against drift at runtime.
+ *   smart-contract-suite `deployments/base-sepolia-84532-entrypoint-v8.json`,
+ *   section `create2`, solc 0.8.36, optimizer runs 10000000, viaIR: true,
+ *   evm target osaka. Hash: 0xc571dd76379a732e12f1973fa9f4cbbaeb1702bb0ace06e5beb7e2b56cd03c6b.
+ * NOTE: a different optimizer/compiler setting produces a DIFFERENT bytecode -
+ * do not swap it in without re-verifying the counterfactual.
+ * `_assertCounterfactualMatchesOnChain` guards against drift; `_getSmartWallet`
+ * runs it once per chain per process.
+ */
+export const BEACON_PROXY_CREATION_CODE = "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";
+/**
+ * Stamp is client-side authentication. Since the passkeys are on the user's mobile device
+ * react-native-passkey helps fetch passkey for the user (provided credentialId, rpId).
+ * This is exactly how the WebAuthn.sol contract needs it to be.
  */
-export const BEACON_PROXY_CREATION_CODE = "0x60a06040908082526104a8803803809161001982856102ae565b8339810182828203126101e95761002f826102e7565b60208084015191939091906001600160401b0382116101e9570182601f820112156101e957805190610060826102fb565b9361006d875195866102ae565b8285528383830101116101e957829060005b83811061029a57505060009184010152823b1561027a577fa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d5080546001600160a01b0319166001600160a01b038581169182179092558551635c60da1b60e01b8082529194928482600481895afa91821561026f57600092610238575b50813b1561021f5750508551847f1cf3b03a6cf19fa2baba4df148e9dcabedea7f8a5c07840e207e5c089be95d3e600080a282511561020057508290600487518096819382525afa9283156101f5576000936101b3575b5091600080848461019096519101845af4903d156101aa573d610174816102fb565b90610181885192836102ae565b8152600081943d92013e610316565b505b6080525161012e908161037a82396080518160180152f35b60609250610316565b92508183813d83116101ee575b6101ca81836102ae565b810103126101e9576000806101e1610190956102e7565b945050610152565b600080fd5b503d6101c0565b85513d6000823e3d90fd5b9350505050346102105750610192565b63b398979f60e01b8152600490fd5b8751634c9c8ce360e01b81529116600482015260249150fd5b9091508481813d8311610268575b61025081836102ae565b810103126101e957610261906102e7565b90386100fb565b503d610246565b88513d6000823e3d90fd5b8351631933b43b60e21b81526001600160a01b0384166004820152602490fd5b81810183015186820184015284920161007f565b601f909101601f19168101906001600160401b038211908210176102d157604052565b634e487b7160e01b600052604160045260246000fd5b51906001600160a01b03821682036101e957565b6001600160401b0381116102d157601f01601f191660200190565b9061033d575080511561032b57805190602001fd5b604051630a12f52160e11b8152600490fd5b81511580610370575b61034e575090565b604051639996b31560e01b81526001600160a01b039091166004820152602490fd5b50803b1561034656fe60806040819052635c60da1b60e01b81526020816004817f00000000000000000000000000000000000000000000000000000000000000006001600160a01b03165afa90811560a9576000916054575b5060da565b905060203d60201160a3575b601f8101601f191682019167ffffffffffffffff831181841017608d576088926040520160b5565b38604f565b634e487b7160e01b600052604160045260246000fd5b503d6060565b6040513d6000823e3d90fd5b602090607f19011260d5576080516001600160a01b038116810360d55790565b600080fd5b6000808092368280378136915af43d82803e1560f4573d90f35b3d90fdfea264697066735822122099ba460fd62b3e22c737d15959887e6cae3498f3495d31e43e2bcf1283aec7d264736f6c63430008190033";
-/*
-** Stamp is client-side authentication. Since the passkeys are one the user's mobile device
-** react-native-passkey helps fetch passkey for the user (provided credentialId, rpId).
-** This is exactly how the WebAuthn.sol contract needs it to be.
-*/
 export const _stamp = async (credentialId, rpId, payload) => {
     const signingOptions = {
         // `Uint8Array.from` gives a fresh ArrayBuffer-backed view, matching the
@@ -113,43 +113,36 @@ export const _stamp = async (credentialId, rpId, payload) => {
     };
     return webAuthnSig;
 };
-const _encodeExecute = async (tx) => {
-    return encodeFunctionData({
-        abi: DeviceWallet,
-        functionName: "execute",
-        args: [{
-                dest: tx.target,
-                value: tx.value ?? ZERO,
-                data: tx.data
-            }]
-    });
-};
-const _encodeBatchExecute = async (txs) => {
-    const new_txs = [];
-    for (let i = 0; i < txs.length; ++i) {
-        new_txs.push({
-            dest: txs[i].target,
-            value: txs[i].value ?? ZERO,
-            data: txs[i].data
+export const _encodeCalls = async (calls) => {
+    const txs = calls.map((call) => ({
+        dest: call.to,
+        value: call.value ?? ZERO,
+        data: call.data ?? "0x"
+    }));
+    // executeBatch costs more calldata, so a lone call goes through execute.
+    if (txs.length === 1) {
+        return encodeFunctionData({
+            abi: DeviceWallet,
+            functionName: "execute",
+            args: [txs[0]]
         });
     }
     return encodeFunctionData({
         abi: DeviceWallet,
         functionName: "executeBatch",
-        args: [new_txs]
+        args: [txs]
     });
 };
-export const _getAccountInitCode = async (client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt) => {
-    // To send with user operations
+export const _getFactoryArgs = async (client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt) => {
     const chainID = await client.getChainId();
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
-    const callData = encodeFunctionData({
+    const factoryData = encodeFunctionData({
         abi: DeviceWalletFactory,
         functionName: "createAccount",
         args: [deviceUniqueIdentifier, deviceWalletOwnerKey, salt],
     });
-    return values.factoryAddresses.DEVICE_WALLET_FACTORY.concat(_remove0x(callData));
+    return { factory: values.factoryAddresses.DEVICE_WALLET_FACTORY, factoryData };
 };
 export const getInitCodeHash = async (client, deviceUniqueIdentifier, deviceWalletOwnerKey) => {
     const chainID = await client.getChainId();
@@ -199,17 +192,16 @@ export const getCounterFactualAddress = async (client, deviceUniqueIdentifier, d
     return getAddress(create2Address);
 };
 /**
- * Optional drift guard. Recomputes the counterfactual address off-chain (using
- * the pinned {@link BEACON_PROXY_CREATION_CODE}) and compares it against the
+ * Drift guard. Recomputes the counterfactual address off-chain (using the
+ * pinned {@link BEACON_PROXY_CREATION_CODE}) and compares it against the
  * on-chain `DeviceWalletFactory.getCounterFactualAddress` view - which derives
  * the address from the BeaconProxy the factory ACTUALLY deploys. A mismatch
  * means the pinned proxy bytecode (or init encoding) has drifted from the
  * deployed contract, so this throws early instead of letting a UserOp deploy to,
  * or fund, the wrong address.
  *
- * Not wired into the default account-creation path (it costs one extra RPC);
- * call it explicitly in environments where you want the extra safety, e.g.
- * after a contract redeploy or on first use against a new chain.
+ * `_getSmartWallet` runs this once per chain per process; call it directly for
+ * an unconditional check, e.g. right after a contract redeploy.
  */
 export const _assertCounterfactualMatchesOnChain = async (client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt) => {
     const chainID = await client.getChainId();
@@ -252,27 +244,36 @@ export const _encodeSignature = async (webAuthnSignature, validUntil) => {
     const signature = encodePacked(["uint8", "uint48", "bytes"], [1, validUntil, encodedWebAuthnSignatureBytes]);
     return signature;
 };
+// The challenge the wallet's isValidSignature rebuilds before checking a passkey
+// assertion. Everything the caller controls has to be inside what was signed:
+// validUntil so an expired signature cannot be revived by rewriting the header,
+// and the chain id and wallet address because neither is implied by the message.
+// Wallets sit at the same address on every chain, and one owner key can back a
+// second wallet at another salt.
+const _erc1271Challenge = (validUntil, chainId, accountAddress, messageHash) => hashMessage({
+    raw: encodePacked(["uint8", "uint48", "uint256", "address", "bytes32"], [1, validUntil, BigInt(chainId), accountAddress, messageHash])
+});
 // message here is the original message data (string or Uint8Array) directly from the app
-export const _signMessage = async (message, credentialId, rpId) => {
+export const _signMessage = async (message, credentialId, rpId, chainId, accountAddress) => {
     const validUntil = Math.floor(Date.now() / 1000) + SIGNATURE_VALIDITY_SECONDS;
     // viem's SignableMessage is `string | { raw: Hex | ByteArray }`. A plain
     // string is a UTF-8 message; the `{ raw }` form is already-serialized bytes
     // (possibly a pre-computed digest). hashMessage handles both natively, so
     // forward the message as-is rather than force-casting it to a string.
-    const payload = hashMessage(message);
-    // The original message is passed to the stamp and sign function.
-    // The stamp and sign function creates the EIP-191 digest hash using its hashMessage function
-    // The result of the hashMessage(message) will be the `payload` used as a challenge
+    const messageHash = hashMessage(message);
+    // The verifier is handed this digest and derives the challenge from it, so
+    // the digest is what gets bound rather than what gets stamped.
+    const payload = _erc1271Challenge(validUntil, chainId, accountAddress, messageHash);
     const webAuthnSignature = await _stamp(credentialId, rpId, payload);
     return _encodeSignature(webAuthnSignature, validUntil);
 };
-export const _signTypedData = async (typedData, credentialId, rpId) => {
+export const _signTypedData = async (typedData, credentialId, rpId, chainId, accountAddress) => {
     // signature valid until, UNIX timestamp in seconds
     const validUntil = Math.floor(Date.now() / 1000) + SIGNATURE_VALIDITY_SECONDS;
-    // EIP-712 digest is the WebAuthn challenge, mirroring _signMessage's use of
-    // the EIP-191 digest. The contract's isValidSignature receives this same
-    // hashTypedData result and verifies the passkey signature against it.
-    const payload = hashTypedData(typedData);
+    // The EIP-712 digest takes the place of the EIP-191 one, and the challenge
+    // is built over it the same way. The verifier cannot tell the two apart.
+    const messageHash = hashTypedData(typedData);
+    const payload = _erc1271Challenge(validUntil, chainId, accountAddress, messageHash);
     const webAuthnSignature = await _stamp(credentialId, rpId, payload);
     return _encodeSignature(webAuthnSignature, validUntil);
 };
@@ -287,64 +288,117 @@ export const _signUserOperationHash = async (credentialId, rpId, userOpHash) =>
     const webAuthnSignature = await _stamp(credentialId, rpId, payload);
     return _encodeSignature(webAuthnSignature, validUntil);
 };
-export const _getSmartWallet = async (client, credentialId, rpId, organiationId, deviceUniqueIdentifier, deviceWalletOwnerKey, salt) => {
+// Chains whose pinned BeaconProxy bytecode has already been checked against
+// the deployed factory in this process, so repeat wallet creations on the
+// 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 rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
     if (!client.account)
         throw new Error('Error: No signer account found with WalletClient');
-    return toSmartContractAccount({
-        /// REQUIRED PARAMS ///
-        source: "MyAccount",
-        transport: http(values.rpcURL),
-        chain: values.chain,
-        // The EntryPointDef that your account is compatible with
-        entryPoint: getEntryPoint(values.chain, { version: "0.7.0" }),
-        getAccountInitCode: async () => await _getAccountInitCode(client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt),
-        // getAccountInitCodeHash: async (): Promise<BytesLike> => await getInitCodeHash(client, deviceUniqueIdentifier, deviceWalletOwnerKey),
-        // an invalid signature that doesn't cause your account to revert during validation
-        getDummySignature: async () => "0x",
-        // given a UO in the form of {target, data, value} should output the calldata for calling your contract's execution method
-        encodeExecute: async (uo) => _encodeExecute(uo),
-        signMessage: async ({ message }) => _signMessage(message, credentialId, rpId),
-        signTypedData: async (typedData) => _signTypedData(typedData, credentialId, rpId),
-        /// OPTIONAL PARAMS ///
-        // if you already know your account's address, pass that in here to avoid generating a new counterfactual
-        accountAddress: await getCounterFactualAddress(client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt),
-        // if your account supports batching, this should take an array of UOs and return the calldata for calling your contract's batchExecute method
-        encodeBatchExecute: async (uos) => _encodeBatchExecute(uos),
-        // if your contract expects a different signing scheme than the default signMessage scheme, you can override that here
-        signUserOperationHash: async (hash) => _signUserOperationHash(credentialId, rpId, hash),
-        // allows you to define the calldata for upgrading your account
-        // encodeUpgradeToAndCall: async (params): Promise<Hash> => "0x...",
+    const accountAddress = _counterfactualVerifiedChains.has(chainID)
+        ? await getCounterFactualAddress(client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt)
+        : await _assertCounterfactualMatchesOnChain(client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt);
+    _counterfactualVerifiedChains.add(chainID);
+    const entryPointAddress = values.factoryAddresses.ENTRY_POINT;
+    return toSmartAccount({
+        // Reads (nonce, deployment check) go to the chain RPC, not the bundler.
+        client: createPublicClient({ chain: values.chain, transport: http(values.rpcURL) }),
+        entryPoint: {
+            abi: entryPoint08Abi,
+            address: entryPointAddress,
+            version: "0.8",
+        },
+        getAddress: async () => accountAddress,
+        getFactoryArgs: async () => _getFactoryArgs(client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt),
+        encodeCalls: async (calls) => _encodeCalls(calls),
+        // Placeholder signature for gas estimation. Must not revert validation.
+        getStubSignature: async () => "0x",
+        signMessage: async ({ message }) => _signMessage(message, credentialId, rpId, chainID, accountAddress),
+        signTypedData: async (typedData) => _signTypedData(typedData, credentialId, rpId, chainID, accountAddress),
+        signUserOperation: async ({ chainId = chainID, ...userOperation }) => {
+            const userOpHash = getUserOperationHash({
+                chainId,
+                entryPointAddress,
+                entryPointVersion: "0.8",
+                userOperation: {
+                    ...userOperation,
+                    sender: userOperation.sender ?? accountAddress,
+                },
+            });
+            return _signUserOperationHash(credentialId, rpId, userOpHash);
+        },
     });
 };
+const BUNDLER_METHODS = new Set([
+    "eth_sendUserOperation",
+    "eth_estimateUserOperationGas",
+    "eth_getUserOperationReceipt",
+    "eth_getUserOperationByHash",
+    "eth_supportedEntryPoints",
+]);
+/**
+ * Raise the bundler's verification estimates to what a real signature costs.
+ * See `STUB_VERIFICATION_GAS_PAD` for the measurements behind the numbers.
+ *
+ * This sits in the transport because viem binds `prepareUserOperation` to the
+ * client as it was before `.extend` ran, so an `estimateUserOperationGas`
+ * override placed on the client is never the one it calls.
+ */
+export const _padGasEstimate = (estimate) => {
+    const pad = (value, by) => value === undefined ? undefined : toHex(BigInt(value) + by);
+    return {
+        ...estimate,
+        // Left out rather than set to zero when the bundler omits one, so a missing
+        // field still reads as "not estimated" downstream.
+        ...(estimate.verificationGasLimit === undefined ? {} : {
+            verificationGasLimit: pad(estimate.verificationGasLimit, STUB_VERIFICATION_GAS_PAD),
+        }),
+        ...(estimate.preVerificationGas === undefined ? {} : {
+            preVerificationGas: pad(estimate.preVerificationGas, STUB_PRE_VERIFICATION_GAS_PAD),
+        }),
+    };
+};
+// Routes bundler calls to Pimlico and everything else to the chain RPC. viem
+// ships no split transport, and the returned client needs both: the SDK reads
+// contracts through the same client it sends user operations with.
+const _splitTransport = (pimlicoRpcURL, rpcURL) => {
+    const bundler = http(pimlicoRpcURL)({});
+    const rpc = http(rpcURL)({});
+    return ({ retryCount }) => createTransport({
+        key: "split",
+        name: "Split",
+        type: "split",
+        retryCount,
+        request: (async ({ method, params }) => {
+            if (!BUNDLER_METHODS.has(method))
+                return rpc.request({ method, params });
+            const result = await bundler.request({ method, params });
+            return method === "eth_estimateUserOperationGas"
+                ? _padGasEstimate(result)
+                : result;
+        }),
+    }, 
+    // Chain constants are resolved from client.transport.url, so the chain
+    // RPC has to stay readable here.
+    { url: rpcURL });
+};
 export const _getSmartWalletClient = async (client, pimlicoAPIKey, gasPolicyId, account) => {
     const chainID = await client.getChainId();
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL, pimlicoAPIKey);
-    const bundlerMethods = [
-        "eth_sendUserOperation",
-        "eth_estimateUserOperationGas",
-        "eth_getUserOperationReceipt",
-        "eth_getUserOperationByHash",
-        "eth_supportedEntryPoints",
-    ];
-    // Uses Pimlico paymaster by default for above defined bundler methods and Alchemy as fallback
-    return createSmartAccountClient({
-        // created above
-        account: account,
+    // Pimlico sponsors via ERC-7677, keyed by the gas policy.
+    const paymaster = createPaymasterClient({ transport: http(values.pimlicoRpcURL) });
+    return createBundlerClient({
+        account,
         chain: values.chain,
-        transport: split({
-            overrides: [
-                {
-                    methods: bundlerMethods,
-                    transport: http(`${values.pimlicoRpcURL}`),
-                },
-            ],
-            fallback: http(values.rpcURL),
-        }),
-        // transport: http(values.rpcURL),
-        ...erc7677Middleware({ context: { policyId: gasPolicyId } })
-    });
+        client: createPublicClient({ chain: values.chain, transport: http(values.rpcURL) }),
+        transport: _splitTransport(values.pimlicoRpcURL, 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.
+    }).extend(publicActions);
 };

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

@@ -1,15 +1,19 @@
 import { _getChainSpecificConstants } from "../constants.js";
 import { MissingEOAWalletError } from "../errors.js";
 import { DeviceWallet } from "../../abis/index.js";
+// Admin-EOA logic targeting a specific `DeviceWallet` instance (its address is
+// passed in - there is no single factory address). `deployESIMWallet` is
+// `onlyESIMWalletAdmin` on chain, so it cannot be driven from a device-wallet
+// userOp and lives on the EOA surface.
 /**
- * Admin-EOA logic targeting a specific `DeviceWallet` instance (its address is
- * passed in - there is no single factory address). Both functions are admin
- * gated on chain (`deployESIMWallet` is `onlyESIMWalletAdmin`,
- * `setESIMUniqueIdentifierForAnESIMWallet` is `onlyESIMWalletAdminOrRegistry`),
- * so they cannot be driven from a device-wallet userOp and live on the EOA surface.
+ * Deploy a new eSIM wallet under a device wallet. `onlyESIMWalletAdmin`.
+ *
+ * The bind that follows never carries ETH access: the contract reverts on a
+ * `true` rather than downgrading it quietly, so the SDK passes `false` and there
+ * is nothing to choose. The owner grants access afterwards with
+ * `toggleAccessToETH`, which the admin EOA cannot reach.
  */
-/** Deploy a new eSIM wallet under a device wallet. `onlyESIMWalletAdmin`. */
-export const _deployESIMWallet = async (client, deviceWalletAddress, hasAccessToETH, salt) => {
+export const _deployESIMWallet = async (client, deviceWalletAddress, salt) => {
     const chainID = await client.getChainId();
     const rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
@@ -21,11 +25,17 @@ export const _deployESIMWallet = async (client, deviceWalletAddress, hasAccessTo
         account: client.account.address,
         abi: DeviceWallet,
         functionName: 'deployESIMWallet',
-        args: [hasAccessToETH, salt]
+        args: [false, salt]
     });
 };
-/** Bind an eSIM's unique identifier to its wallet. `onlyESIMWalletAdminOrRegistry`. */
-export const _setESIMUniqueIdentifierForAnESIMWallet = async (client, deviceWalletAddress, eSIMWalletAddress, eSIMUniqueIdentifier) => {
+/**
+ * Top up a device wallet's gas deposit at the EntryPoint, paid by the admin EOA.
+ *
+ * Open to anyone: paying another account's gas costs the payer and nobody else.
+ * `withdrawDepositTo` is `onlySelf`, so only the wallet's owner can take it back
+ * 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 rpcURL = client.transport.url;
     const values = _getChainSpecificConstants(chainID, rpcURL);
@@ -36,7 +46,8 @@ export const _setESIMUniqueIdentifierForAnESIMWallet = async (client, deviceWall
         chain: values.chain,
         account: client.account.address,
         abi: DeviceWallet,
-        functionName: 'setESIMUniqueIdentifierForAnESIMWallet',
-        args: [eSIMWalletAddress, eSIMUniqueIdentifier]
+        functionName: 'addDeposit',
+        args: [],
+        value: amount
     });
 };