kokio-sdk 1.1.0 → 2.1.0

package/dist/types/abis/RegistryHelper.d.ts

@@ -1,4 +1,18 @@
 declare const RegistryHelper: readonly [{
+    readonly type: "function";
+    readonly name: "claimedESIMIdentifiers";
+    readonly inputs: readonly [{
+        readonly name: "hashOfESIMIdentifier";
+        readonly type: "bytes32";
+        readonly internalType: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "eSIMWallet";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
     readonly type: "function";
     readonly name: "deployLazyWallet";
     readonly inputs: readonly [{
@@ -17,19 +31,6 @@ declare const RegistryHelper: readonly [{
         readonly name: "_eSIMUniqueIdentifiers";
         readonly type: "string[]";
         readonly internalType: "string[]";
-    }, {
-        readonly name: "_dataBundleDetails";
-        readonly type: "tuple[][]";
-        readonly internalType: "struct DataBundleDetails[][]";
-        readonly components: readonly [{
-            readonly name: "dataBundleID";
-            readonly type: "string";
-            readonly internalType: "string";
-        }, {
-            readonly name: "dataBundlePrice";
-            readonly type: "uint256";
-            readonly internalType: "uint256";
-        }];
     }, {
         readonly name: "_depositAmount";
         readonly type: "uint256";
@@ -45,6 +46,36 @@ declare const RegistryHelper: readonly [{
         readonly internalType: "address[]";
     }];
     readonly stateMutability: "payable";
+}, {
+    readonly type: "function";
+    readonly name: "deployMoreLazyESIMWallets";
+    readonly inputs: readonly [{
+        readonly name: "_deviceWallet";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "_deviceUniqueIdentifier";
+        readonly type: "string";
+        readonly internalType: "string";
+    }, {
+        readonly name: "_baseSalt";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "_startIndex";
+        readonly type: "uint256";
+        readonly internalType: "uint256";
+    }, {
+        readonly name: "_eSIMUniqueIdentifiers";
+        readonly type: "string[]";
+        readonly internalType: "string[]";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address[]";
+        readonly internalType: "address[]";
+    }];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly name: "deviceWalletFactory";
@@ -83,6 +114,34 @@ declare const RegistryHelper: readonly [{
         readonly internalType: "contract ESIMWalletFactory";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "eSIMWalletForIdentifier";
+    readonly inputs: readonly [{
+        readonly name: "_eSIMUniqueIdentifier";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "isDeviceIdentifierAlreadyUsed";
+    readonly inputs: readonly [{
+        readonly name: "_deviceUniqueIdentifier";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "isDeviceWalletValid";
@@ -97,6 +156,20 @@ declare const RegistryHelper: readonly [{
         readonly internalType: "bool";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "isESIMIdentifierClaimed";
+    readonly inputs: readonly [{
+        readonly name: "_eSIMUniqueIdentifier";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+        readonly internalType: "bool";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "isESIMWalletOnStandby";
@@ -135,6 +208,29 @@ declare const RegistryHelper: readonly [{
         readonly internalType: "address";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "populateLazyHistory";
+    readonly inputs: readonly [{
+        readonly name: "_eSIMWallet";
+        readonly type: "address";
+        readonly internalType: "address";
+    }, {
+        readonly name: "_dataBundleDetails";
+        readonly type: "tuple[]";
+        readonly internalType: "struct DataBundleDetails[]";
+        readonly components: readonly [{
+            readonly name: "dataBundleID";
+            readonly type: "string";
+            readonly internalType: "string";
+        }, {
+            readonly name: "dataBundlePrice";
+            readonly type: "uint256";
+            readonly internalType: "uint256";
+        }];
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
     readonly name: "registeredP256Keys";
@@ -163,6 +259,86 @@ declare const RegistryHelper: readonly [{
         readonly internalType: "address";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "event";
+    readonly name: "AdminDisabled";
+    readonly inputs: readonly [{
+        readonly name: "_adminOfRecord";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "_caller";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "AdminEnabled";
+    readonly inputs: readonly [{
+        readonly name: "_adminOfRecord";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "_caller";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "AdminUpdateRequested";
+    readonly inputs: readonly [{
+        readonly name: "eSIMWalletAdmin";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "_newAdmin";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "AdminUpdateRevoked";
+    readonly inputs: readonly [{
+        readonly name: "_caller";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "_revokedAddress";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "AdminUpdated";
+    readonly inputs: readonly [{
+        readonly name: "_newAdmin";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "DefaultDataBundlePriceCapUpdated";
+    readonly inputs: readonly [{
+        readonly name: "_cap";
+        readonly type: "uint256";
+        readonly indexed: false;
+        readonly internalType: "uint256";
+    }];
+    readonly anonymous: false;
 }, {
     readonly type: "event";
     readonly name: "DeviceWalletInfoUpdated";
@@ -183,6 +359,46 @@ declare const RegistryHelper: readonly [{
         readonly internalType: "bytes32[2]";
     }];
     readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "DeviceWalletOwnerKeyUpdated";
+    readonly inputs: readonly [{
+        readonly name: "_deviceWallet";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }, {
+        readonly name: "_oldOwnerKey";
+        readonly type: "bytes32[2]";
+        readonly indexed: false;
+        readonly internalType: "bytes32[2]";
+    }, {
+        readonly name: "_newOwnerKey";
+        readonly type: "bytes32[2]";
+        readonly indexed: false;
+        readonly internalType: "bytes32[2]";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "ESIMIdentifierClaimed";
+    readonly inputs: readonly [{
+        readonly name: "_hashOfESIMIdentifier";
+        readonly type: "bytes32";
+        readonly indexed: true;
+        readonly internalType: "bytes32";
+    }, {
+        readonly name: "_eSIMUniqueIdentifier";
+        readonly type: "string";
+        readonly indexed: false;
+        readonly internalType: "string";
+    }, {
+        readonly name: "_eSIMWallet";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
 }, {
     readonly type: "event";
     readonly name: "ESIMWalletSetOnStandby";
@@ -228,6 +444,16 @@ declare const RegistryHelper: readonly [{
         readonly internalType: "string";
     }];
     readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "Paused";
+    readonly inputs: readonly [{
+        readonly name: "_admin";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
 }, {
     readonly type: "event";
     readonly name: "RegistryInitialized";
@@ -256,10 +482,15 @@ declare const RegistryHelper: readonly [{
         readonly type: "address";
         readonly indexed: true;
         readonly internalType: "address";
-    }, {
-        readonly name: "_verifier";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "Unpaused";
+    readonly inputs: readonly [{
+        readonly name: "_owner";
         readonly type: "address";
-        readonly indexed: false;
+        readonly indexed: true;
         readonly internalType: "address";
     }];
     readonly anonymous: false;
@@ -288,9 +519,79 @@ declare const RegistryHelper: readonly [{
         readonly internalType: "address";
     }];
     readonly anonymous: false;
+}, {
+    readonly type: "event";
+    readonly name: "VaultAddressUpdated";
+    readonly inputs: readonly [{
+        readonly name: "_updatedVaultAddress";
+        readonly type: "address";
+        readonly indexed: true;
+        readonly internalType: "address";
+    }];
+    readonly anonymous: false;
+}, {
+    readonly type: "error";
+    readonly name: "DeviceWalletAlreadyExists";
+    readonly inputs: readonly [{
+        readonly name: "deviceIdentifier";
+        readonly type: "string";
+        readonly internalType: "string";
+    }, {
+        readonly name: "deviceWallet";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "ESIMIdentifierAlreadyClaimed";
+    readonly inputs: readonly [{
+        readonly name: "eSIMIdentifier";
+        readonly type: "string";
+        readonly internalType: "string";
+    }, {
+        readonly name: "eSIMWallet";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "ESIMIdentifierReservedForLazyWallet";
+    readonly inputs: readonly [{
+        readonly name: "eSIMIdentifier";
+        readonly type: "string";
+        readonly internalType: "string";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "EmptyESIMIdentifier";
+    readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "NotADeviceWallet";
+    readonly inputs: readonly [{
+        readonly name: "account";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
+}, {
+    readonly type: "error";
+    readonly name: "NotAProtocolESIMWallet";
+    readonly inputs: readonly [{
+        readonly name: "eSIMWallet";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
 }, {
     readonly type: "error";
     readonly name: "OnlyLazyWalletRegistry";
     readonly inputs: readonly [];
+}, {
+    readonly type: "error";
+    readonly name: "UnknownESIMWallet";
+    readonly inputs: readonly [{
+        readonly name: "eSIMWallet";
+        readonly type: "address";
+        readonly internalType: "address";
+    }];
 }];
 export default RegistryHelper;

package/dist/types/abis/index.d.ts

@@ -7,4 +7,5 @@ import P256Verifier from './P256Verifier.js';
 import Registry from './Registry.js';
 import RegistryHelper from './RegistryHelper.js';
 import BeaconProxy from './BeaconProxy.js';
-export { DeviceWallet, DeviceWalletFactory, ESIMWallet, ESIMWalletFactory, LazyWalletRegistry, P256Verifier, Registry, RegistryHelper, BeaconProxy };
+import ProtocolAdmin from './ProtocolAdmin.js';
+export { DeviceWallet, DeviceWalletFactory, ESIMWallet, ESIMWalletFactory, LazyWalletRegistry, P256Verifier, Registry, RegistryHelper, BeaconProxy, ProtocolAdmin };

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

@@ -4,10 +4,12 @@ import { AdminDeviceWalletFactorySubPackage } from "./interface/deviceWalletFact
 import { AdminESIMWalletFactorySubPackage } from "./interface/eSIMWalletFactoryClass.js";
 import { AdminRegistrySubPackage } from "./interface/registryClass.js";
 import { AdminLazyWalletRegistrySubPackage } from "./interface/lazyWalletRegistryClass.js";
+import { AdminProtocolAdminSubPackage } from "./interface/protocolAdminClass.js";
 import { AdminDeviceWalletSubPackage } from "./interface/deviceWalletClass.js";
 import { AdminESIMWalletSubPackage } from "./interface/eSIMWalletClass.js";
 export { KokioError, NullOrUndefinedValueError, MissingSmartWalletError, MissingEOAWalletError, InvalidClientError, UnsupportedChainError, UnconfiguredChainError, CounterfactualMismatchError, ContractRevertError, decodeContractRevert, } from "../logic/errors.js";
 export type { DecodedRevert } from "../logic/errors.js";
+export { OperationState } from "../logic/admin/reads/protocolAdmin.reads.js";
 /**
  * EOA-only entry point for the NodeJS backend.
  *
@@ -33,6 +35,7 @@ export declare class KokioAdmin {
     eSIMWalletFactory: AdminESIMWalletFactorySubPackage;
     registry: AdminRegistrySubPackage;
     lazyWalletRegistry: AdminLazyWalletRegistrySubPackage;
+    protocolAdmin: AdminProtocolAdminSubPackage;
     deviceWallet?: AdminDeviceWalletSubPackage;
     eSIMWallet?: AdminESIMWalletSubPackage;
     constructor(walletClient: WalletClient, deviceWalletAddress?: Address, eSIMWalletAddress?: Address);

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

@@ -1,4 +1,4 @@
-import { Address, WalletClient } from "viem";
+import { Address, Hex, WalletClient } from "viem";
 /**
  * Thin EOA wrapper around a specific `DeviceWallet` instance. The instance
  * address is bound at construction; `KokioAdmin.setDeviceWalletAddress` swaps it
@@ -8,10 +8,17 @@ export declare class AdminDeviceWalletSubPackage {
     walletClient: WalletClient;
     deviceWalletAddress: Address;
     constructor(walletClient: WalletClient, deviceWalletAddress: Address);
-    deployESIMWallet(hasAccessToETH: boolean, salt: bigint): Promise<`0x${string}`>;
-    setESIMUniqueIdentifierForAnESIMWallet(eSIMWalletAddress: Address, eSIMUniqueIdentifier: string): Promise<`0x${string}`>;
+    deployESIMWallet(salt: bigint): Promise<`0x${string}`>;
+    addDeposit(amount: bigint): Promise<`0x${string}`>;
     deviceUniqueIdentifier(): Promise<string>;
     isValidESIMWallet(eSIMWallet: Address): Promise<boolean>;
     canPullETH(eSIMWallet: Address): Promise<boolean>;
     getVaultAddress(): Promise<`0x${string}`>;
+    getOwner(): Promise<import("../../types.js").P256Key>;
+    getDeposit(): Promise<bigint>;
+    isValidSignature(messageHash: Hex, signature: Hex): Promise<`0x${string}`>;
+    registry(): Promise<`0x${string}`>;
+    eSIMWalletFactory(): Promise<`0x${string}`>;
+    entryPoint(): Promise<`0x${string}`>;
+    verifier(): Promise<`0x${string}`>;
 }

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

@@ -1,4 +1,4 @@
-import { Address, WalletClient } from "viem";
+import { Address, Hex, WalletClient } from "viem";
 import { P256Key } from "../../types.js";
 /**
  * Thin EOA wrapper around `DeviceWalletFactory`. Holds only the wallet client;
@@ -10,16 +10,23 @@ export declare class AdminDeviceWalletFactorySubPackage {
     constructor(walletClient: WalletClient);
     createAccount(deviceUniqueIdentifier: string, deviceWalletOwnerKey: P256Key, salt: bigint, depositAmount: bigint): Promise<`0x${string}`>;
     deployDeviceWalletForUsers(deviceUniqueIdentifiers: Array<string>, deviceWalletOwnersKey: Array<P256Key>, salts: Array<bigint>, depositAmounts: Array<bigint>, value: bigint): Promise<`0x${string}`>;
-    postCreateAccount(deviceWallet: Address, deviceUniqueIdentifier: string, deviceWalletOwnerKey: P256Key): Promise<`0x${string}`>;
+    postCreateAccount(deviceWallet: Address, deviceUniqueIdentifier: string, deviceWalletOwnerKey: P256Key, salt: bigint): Promise<`0x${string}`>;
     addRegistryAddress(registryContractAddress: Address): Promise<`0x${string}`>;
-    updateVaultAddress(newVaultAddress: Address): Promise<`0x${string}`>;
-    requestAdminUpdate(newAdmin: Address): Promise<`0x${string}`>;
-    acceptAdminUpdate(): Promise<`0x${string}`>;
     updateDeviceWalletImplementation(newDeviceImpl: Address): Promise<`0x${string}`>;
     eSIMWalletAdmin(): Promise<`0x${string}`>;
-    vault(): Promise<`0x${string}`>;
-    newRequestedAdmin(): Promise<`0x${string}`>;
     deviceWalletInfoAdded(deviceWallet: Address): Promise<boolean>;
     getCurrentDeviceWalletImplementation(): Promise<`0x${string}`>;
     getCounterFactualAddress(deviceWalletOwnerKey: P256Key, deviceUniqueIdentifier: string, salt: bigint): Promise<`0x${string}`>;
+    preCreateAccountValidation(deviceUniqueIdentifier: string, deviceWalletOwnerKey: P256Key): Promise<`0x${string}`>;
+    beacon(): Promise<`0x${string}`>;
+    registry(): Promise<`0x${string}`>;
+    entryPoint(): Promise<`0x${string}`>;
+    verifier(): Promise<`0x${string}`>;
+    owner(): Promise<`0x${string}`>;
+    pendingOwner(): Promise<`0x${string}`>;
+    proxiableUUID(): Promise<`0x${string}`>;
+    upgradeInterfaceVersion(): Promise<string>;
+    acceptOwnership(): Promise<`0x${string}`>;
+    transferOwnershipCall(newOwner: Address): Promise<import("../../types.js").OwnerCall>;
+    upgradeCall(newImplementation: Address, data?: Hex): Promise<import("../../types.js").OwnerCall>;
 }

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

@@ -14,4 +14,7 @@ export declare class AdminESIMWalletSubPackage {
     eSIMUniqueIdentifier(): Promise<string>;
     newRequestedOwner(): Promise<`0x${string}`>;
     owner(): Promise<`0x${string}`>;
+    dataBundlePriceCap(): Promise<bigint>;
+    deviceWallet(): Promise<`0x${string}`>;
+    transactionHistory(index: bigint): Promise<DataBundleDetails>;
 }

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

@@ -1,10 +1,17 @@
-import { Address, WalletClient } from "viem";
+import { Address, Hex, WalletClient } from "viem";
 /** Thin EOA (owner) wrapper around `ESIMWalletFactory`. */
 export declare class AdminESIMWalletFactorySubPackage {
     walletClient: WalletClient;
     constructor(walletClient: WalletClient);
     addRegistryAddress(registryContractAddress: Address): Promise<`0x${string}`>;
     updateESIMWalletImplementation(eSIMWalletImpl: Address): Promise<`0x${string}`>;
+    acceptOwnership(): Promise<`0x${string}`>;
+    transferOwnershipCall(newOwner: Address): Promise<import("../../types.js").OwnerCall>;
+    upgradeCall(newImplementation: Address, data?: Hex): Promise<import("../../types.js").OwnerCall>;
     isESIMWalletDeployed(eSIMWallet: Address): Promise<boolean>;
     getCurrentESIMWalletImplementation(): Promise<`0x${string}`>;
+    owner(): Promise<`0x${string}`>;
+    pendingOwner(): Promise<`0x${string}`>;
+    proxiableUUID(): Promise<`0x${string}`>;
+    upgradeInterfaceVersion(): Promise<string>;
 }

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

@@ -1,14 +1,50 @@
-import { WalletClient } from "viem";
+import { Address, Hex, WalletClient } from "viem";
 import { DataBundleDetails, P256Key } from "../../types.js";
 /** Thin EOA (eSIMWalletAdmin) wrapper around `LazyWalletRegistry`. */
 export declare class AdminLazyWalletRegistrySubPackage {
     walletClient: WalletClient;
     constructor(walletClient: WalletClient);
     batchPopulateHistory(deviceUniqueIdentifiers: Array<string>, eSIMUniqueIdentifiers: Array<Array<string>>, dataBundleDetails: Array<Array<DataBundleDetails>>): Promise<`0x${string}`>;
-    deployLazyWalletAndSetESIMIdentifier(deviceOwnerPublicKey: P256Key, deviceUniqueIdentifier: string, salt: bigint, depositAmount: bigint): Promise<`0x${string}`>;
+    /**
+     * Deploy a lazy device and all of its eSIM wallets. Sends as many transactions
+     * as the device needs and resolves once every wallet exists, so the caller
+     * does not deal with the on-chain batching at all.
+     *
+     * Resumable: call it again with the same arguments (and a deposit of 0) to
+     * pick a part-deployed device up from where it stopped.
+     *
+     * Record all of the device's purchase history before this runs.
+     */
+    deployLazyWalletAndSetESIMIdentifier(deviceOwnerPublicKey: P256Key, deviceUniqueIdentifier: string, salt: bigint, depositAmount: bigint, maxWallets?: bigint): Promise<import("../../types.js").LazyDeployment>;
+    /**
+     * Copy an eSIM's whole purchase history onto its wallet, over as many
+     * transactions as it takes. Resumable, and safe to run while the device's
+     * other eSIM wallets are still being deployed.
+     */
+    setHistoryForLazyWallet(eSIMIdentifier: string, maxEntries?: bigint): Promise<import("../../types.js").LazyHistoryCopy>;
     switchESIMIdentifierToNewDeviceIdentifier(eSIMIdentifier: string, oldDeviceIdentifier: string, newDeviceIdentifier: string): Promise<`0x${string}`>;
+    deployLazyWalletFirstBatch(deviceOwnerPublicKey: P256Key, deviceUniqueIdentifier: string, salt: bigint, depositAmount: bigint, maxWallets: bigint): Promise<`0x${string}`>;
+    deployMoreESIMWalletsForLazyDevice(deviceUniqueIdentifier: string, maxWallets: bigint): Promise<`0x${string}`>;
+    setHistoryForLazyWalletBatch(eSIMIdentifier: string, maxEntries: bigint): Promise<`0x${string}`>;
     upgradeManager(): Promise<`0x${string}`>;
     eSIMIdentifierToDeviceIdentifier(eSIMIdentifier: string): Promise<string>;
+    MAX_ESIM_WALLETS_PER_CALL(): Promise<bigint>;
+    MAX_HISTORY_ENTRIES_PER_CALL(): Promise<bigint>;
+    /** Deploy cursor. Non-zero exactly when the lazy route ran this device's first batch. */
+    eSIMWalletsDeployed(deviceIdentifier: string): Promise<bigint>;
+    lazyDeploymentSalt(deviceIdentifier: string): Promise<bigint>;
+    lazyDeployedESIMWallet(eSIMIdentifier: string): Promise<`0x${string}`>;
+    /** History cursor, per eSIM. */
+    historyEntriesCopied(eSIMIdentifier: string): Promise<bigint>;
+    isDeviceIdentifierReserved(deviceIdentifier: string): Promise<boolean>;
+    isESIMIdentifierReserved(eSIMIdentifier: string): Promise<boolean>;
     deviceIdentifierToESIMDetails(deviceIdentifier: string, eSIMIdentifier: string, index: bigint): Promise<DataBundleDetails>;
     eSIMIdentifiersAssociatedWithDeviceIdentifier(deviceIdentifier: string, index: bigint): Promise<string>;
+    owner(): Promise<`0x${string}`>;
+    pendingOwner(): Promise<`0x${string}`>;
+    proxiableUUID(): Promise<`0x${string}`>;
+    upgradeInterfaceVersion(): Promise<string>;
+    acceptOwnership(): Promise<`0x${string}`>;
+    transferOwnershipCall(newOwner: Address): Promise<import("../../types.js").OwnerCall>;
+    upgradeCall(newImplementation: Address, data?: Hex): Promise<import("../../types.js").OwnerCall>;
 }

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

@@ -0,0 +1,95 @@
+import { Address, Hex, WalletClient } from "viem";
+import type { OperationOptions, OwnerCall, ScheduledBatchOperation, ScheduledOperation } from "../../types.js";
+/** Schedules operations. Needs an EOA holding `PROPOSER_ROLE`. */
+export declare class ProtocolAdminProposerSubPackage {
+    walletClient: WalletClient;
+    constructor(walletClient: WalletClient);
+    schedule(call: OwnerCall, opts?: OperationOptions, delay?: bigint): Promise<ScheduledOperation>;
+    scheduleBatch(calls: readonly OwnerCall[], opts?: OperationOptions, delay?: bigint): Promise<ScheduledBatchOperation>;
+    scheduleRaw(target: Address, value: bigint, payload: Hex, predecessor: Hex, salt: Hex, delay: bigint): Promise<ScheduledOperation>;
+}
+/** Runs operations whose delay has elapsed. Open to any funded EOA. */
+export declare class ProtocolAdminExecutorSubPackage {
+    walletClient: WalletClient;
+    constructor(walletClient: WalletClient);
+    execute(operation: ScheduledOperation): Promise<`0x${string}`>;
+    executeBatch(operation: ScheduledBatchOperation): Promise<`0x${string}`>;
+    executeRaw(target: Address, value: bigint, payload: Hex, predecessor: Hex, salt: Hex): Promise<`0x${string}`>;
+}
+/** Drops a scheduled operation. Needs `CANCELLER_ROLE`, which proposers also hold. */
+export declare class ProtocolAdminCancellerSubPackage {
+    walletClient: WalletClient;
+    constructor(walletClient: WalletClient);
+    cancel(id: Hex): Promise<`0x${string}`>;
+}
+/**
+ * The three instant powers. Needs `GUARDIAN_ROLE`.
+ *
+ * Each one takes something away and none grants anything, which is what keeps
+ * the role away from user funds. Undoing any of them is an owner action and
+ * waits, so the side taking power away wins the race against the side handing it
+ * back.
+ */
+export declare class ProtocolAdminGuardianSubPackage {
+    walletClient: WalletClient;
+    constructor(walletClient: WalletClient);
+    unpauseInstantly(target: Address): Promise<`0x${string}`>;
+    revokeCancellersInstantly(accounts: readonly Address[]): Promise<`0x${string}`>;
+    disableAdminInstantly(target?: Address): Promise<`0x${string}`>;
+}
+/**
+ * The timelock that owns `Registry`, `LazyWalletRegistry`, `DeviceWalletFactory`
+ * and `ESIMWalletFactory`.
+ *
+ * Owner calls go one way: `proposer.schedule` announces one, the delay elapses,
+ * and `executor.execute` runs it. The role surfaces are separate because they
+ * need different keys, and `executor` needs no role at all.
+ *
+ * ```ts
+ * const op = await admin.protocolAdmin.proposer.schedule({
+ *     address: registryAddress,
+ *     abi: Registry,
+ *     functionName: "updateVaultAddress",
+ *     args: [newVault],
+ * });
+ * // ... wait out admin.protocolAdmin.getMinDelay() ...
+ * await admin.protocolAdmin.executor.execute(op);
+ * ```
+ */
+export declare class AdminProtocolAdminSubPackage {
+    walletClient: WalletClient;
+    proposer: ProtocolAdminProposerSubPackage;
+    executor: ProtocolAdminExecutorSubPackage;
+    canceller: ProtocolAdminCancellerSubPackage;
+    guardian: ProtocolAdminGuardianSubPackage;
+    constructor(walletClient: WalletClient);
+    acceptOwnershipBatch(targets: readonly Address[]): Promise<`0x${string}`>;
+    renounceRole(role: Hex, account: Address): Promise<`0x${string}`>;
+    grantRoleCall(role: Hex, account: Address): Promise<OwnerCall>;
+    revokeRoleCall(role: Hex, account: Address): Promise<OwnerCall>;
+    updateDelayCall(newDelay: bigint): Promise<OwnerCall>;
+    disableAndNominateCall(target: Address, newAdmin: Address): Promise<OwnerCall>;
+    disableAdminCall(target?: Address): Promise<OwnerCall>;
+    enableAdminCall(target?: Address): Promise<OwnerCall>;
+    unpauseCall(target?: Address): Promise<OwnerCall>;
+    setDefaultDataBundlePriceCapCall(cap: bigint, target?: Address): Promise<OwnerCall>;
+    operationId(call: OwnerCall, opts?: OperationOptions): Promise<`0x${string}`>;
+    operationIdBatch(calls: readonly OwnerCall[], opts?: OperationOptions): Promise<`0x${string}`>;
+    operationIdRaw(target: Address, value: bigint, payload: Hex, predecessor: Hex, salt: Hex): Promise<`0x${string}`>;
+    operationIdBatchRaw(targets: readonly Address[], values: readonly bigint[], payloads: readonly Hex[], predecessor: Hex, salt: Hex): Promise<`0x${string}`>;
+    getMinDelay(): Promise<bigint>;
+    minDelayFloor(): Promise<bigint>;
+    getOperationState(id: Hex): Promise<import("../config-admin.js").OperationState>;
+    getTimestamp(id: Hex): Promise<bigint>;
+    isOperation(id: Hex): Promise<boolean>;
+    isOperationPending(id: Hex): Promise<boolean>;
+    isOperationReady(id: Hex): Promise<boolean>;
+    isOperationDone(id: Hex): Promise<boolean>;
+    hasRole(role: Hex, account: Address): Promise<boolean>;
+    getRoleAdmin(role: Hex): Promise<`0x${string}`>;
+    DEFAULT_ADMIN_ROLE(): Promise<`0x${string}`>;
+    PROPOSER_ROLE(): Promise<`0x${string}`>;
+    CANCELLER_ROLE(): Promise<`0x${string}`>;
+    EXECUTOR_ROLE(): Promise<`0x${string}`>;
+    GUARDIAN_ROLE(): Promise<`0x${string}`>;
+}