kokio-sdk 1.0.0 → 2.0.0

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}`>;
+}

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

@@ -4,7 +4,23 @@ export declare class AdminRegistrySubPackage {
     walletClient: WalletClient;
     constructor(walletClient: WalletClient);
     addOrUpdateLazyWalletRegistryAddress(lazyWalletRegistry: Address): Promise<`0x${string}`>;
+    updateVaultAddress(newVaultAddress: Address): Promise<`0x${string}`>;
+    requestAdminUpdate(newAdmin: Address): Promise<`0x${string}`>;
+    disableAdmin(): Promise<`0x${string}`>;
+    enableAdmin(): Promise<`0x${string}`>;
+    acceptAdminUpdate(): Promise<`0x${string}`>;
+    assignESIMIdentifier(eSIMWalletAddress: Address, eSIMUniqueIdentifier: string): Promise<`0x${string}`>;
+    pause(): Promise<`0x${string}`>;
+    unpause(): Promise<`0x${string}`>;
+    setDefaultDataBundlePriceCap(cap: bigint): 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>;
+    owner(): Promise<`0x${string}`>;
     eSIMWalletAdmin(): Promise<`0x${string}`>;
+    adminOfRecord(): Promise<`0x${string}`>;
+    adminDisabled(): Promise<boolean>;
+    newRequestedAdmin(): Promise<`0x${string}`>;
     vault(): Promise<`0x${string}`>;
     upgradeManager(): Promise<`0x${string}`>;
     lazyWalletRegistry(): Promise<`0x${string}`>;
@@ -14,4 +30,18 @@ export declare class AdminRegistrySubPackage {
     isDeviceWalletValid(deviceWallet: Address): Promise<boolean>;
     isESIMWalletValid(eSIMWallet: Address): Promise<`0x${string}`>;
     isESIMWalletOnStandby(eSIMWallet: Address): Promise<boolean>;
+    paused(): Promise<boolean>;
+    defaultDataBundlePriceCap(): Promise<bigint>;
+    isDeviceIdentifierAlreadyUsed(deviceUniqueIdentifier: string): Promise<boolean>;
+    isESIMIdentifierClaimed(eSIMUniqueIdentifier: string): Promise<boolean>;
+    eSIMWalletForIdentifier(eSIMUniqueIdentifier: string): Promise<`0x${string}`>;
+    claimedESIMIdentifiers(hashOfESIMIdentifier: Hex): Promise<`0x${string}`>;
+    requireDeviceIdentifierNotReserved(deviceUniqueIdentifier: string): Promise<void>;
+    requireNotPaused(): Promise<void>;
+    pendingOwner(): Promise<`0x${string}`>;
+    deviceWalletFactory(): Promise<`0x${string}`>;
+    eSIMWalletFactory(): Promise<`0x${string}`>;
+    entryPoint(): Promise<`0x${string}`>;
+    proxiableUUID(): Promise<`0x${string}`>;
+    upgradeInterfaceVersion(): Promise<string>;
 }

package/dist/types/config.d.ts

@@ -3,29 +3,31 @@ import { KokioConstants } from "./interface/constantsClass.js";
 import { SmartAccountSubPackage } from "./interface/smartAccountClass.js";
 import { DeviceWalletFactorySubPackage } from "./interface/deviceWalletFactoryClass.js";
 import { P256VerifierSubPackage } from "./interface/P256VerifierClass.js";
-import { LazyWalletRegistrySubPackage } from "./interface/lazyWalletRegistryClass.js";
+import { RegistrySubPackage } from "./interface/registryClass.js";
 import { DeviceWalletSubPackage } from "./interface/deviceWalletClass.js";
 import { ESIMWalletSubPackage } from "./interface/eSIMWalletClass.js";
 import { ESIMWalletFactorySubPackage } from "./interface/eSIMWalletFactoryClass.js";
-import { SmartAccountClient } from "@aa-sdk/core";
+import { KokioSmartAccountClient } from "./types.js";
 export { KokioError, NullOrUndefinedValueError, MissingSmartWalletError, MissingEOAWalletError, InvalidClientError, UnsupportedChainError, UnconfiguredChainError, CounterfactualMismatchError, ContractRevertError, decodeContractRevert, } from "./logic/errors.js";
 export type { DecodedRevert } from "./logic/errors.js";
 export declare class Kokio {
     viemWalletClient: WalletClient;
     credentialId: string;
     rpId: string;
-    organizationId: string;
     pimlicoAPIKey: string;
     gasPolicyId: string;
+    smartAccountClient?: KokioSmartAccountClient;
+    deviceWalletAddress?: Address;
+    eSIMWalletAddress?: Address;
     private _constants;
     smartAccount: SmartAccountSubPackage;
     deviceWalletFactory?: DeviceWalletFactorySubPackage;
     eSIMWalletFactory?: ESIMWalletFactorySubPackage;
-    lazyWalletRegistry?: LazyWalletRegistrySubPackage;
+    registry?: RegistrySubPackage;
     deviceWallet?: DeviceWalletSubPackage;
     eSIMWallet?: ESIMWalletSubPackage;
     P256Verifier?: P256VerifierSubPackage;
-    constructor(viemWalletClient: WalletClient, credentialId: string, rpId: string, organizationId: string, pimlicoAPIKey: string, gasPolicyId: string, smartAccountClient?: SmartAccountClient, deviceWalletAddress?: Address, eSIMWalletAddress?: Address);
+    constructor(viemWalletClient: WalletClient, credentialId: string, rpId: string, pimlicoAPIKey: string, gasPolicyId: string, smartAccountClient?: KokioSmartAccountClient, deviceWalletAddress?: Address, eSIMWalletAddress?: Address);
     /**
      * Chain-specific constants (factory addresses, chain, RPC URLs, custom errors)
      * for the wallet client's connected chain. Resolution is asynchronous because
@@ -36,4 +38,23 @@ export declare class Kokio {
      * The underlying value is memoized, so repeated awaits do not re-fetch.
      */
     get constants(): Promise<KokioConstants>;
+    /**
+     * Bind a `DeviceWallet` instance address after construction and (re)wire
+     * the `deviceWallet` surface to it. Returns `this` for chaining.
+     *
+     * Needs a `smartAccountClient` already on this instance - every write on
+     * `deviceWallet` sends a user operation through it. Without one,
+     * `deviceWallet` stays `undefined`, same as when no address is passed to
+     * the constructor.
+     */
+    setDeviceWalletAddress(deviceWalletAddress: Address): this;
+    /**
+     * Bind an `ESIMWallet` instance address after construction and (re)wire
+     * the `eSIMWallet` surface to it. Returns `this` for chaining.
+     *
+     * A user holding several eSIM wallets can call this to switch which one
+     * `kokio.eSIMWallet` acts on, without re-creating `Kokio`. Same
+     * `smartAccountClient` requirement as {@link setDeviceWalletAddress}.
+     */
+    setESIMWalletAddress(eSIMWalletAddress: Address): this;
 }

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

@@ -1,8 +1,7 @@
 import { Hex } from "viem";
-import { WebAuthnSignature } from "../types";
-import { SmartAccountClient } from "@aa-sdk/core";
+import { WebAuthnSignature, KokioSmartAccountClient } from "../types.js";
 export declare class P256VerifierSubPackage {
-    client: SmartAccountClient;
-    constructor(client: SmartAccountClient);
+    client: KokioSmartAccountClient;
+    constructor(client: KokioSmartAccountClient);
     verifySignature(message: Hex, requireMessageVerification: boolean, webAuthnSignature: WebAuthnSignature, x: bigint, y: bigint): Promise<boolean>;
 }

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

@@ -16,9 +16,9 @@ export interface KokioConstants {
  */
 export declare class ConstantsSubPackage {
     private client;
-    private pimlicoAPIKey;
+    private pimlicoAPIKey?;
     private cache?;
-    constructor(client: WalletClient, pimlicoAPIKey: string);
+    constructor(client: WalletClient, pimlicoAPIKey?: string);
     /**
      * Resolves and caches the chain-specific constants. Subsequent calls
      * return the same promise, so the chain id is only fetched once.