kokio-sdk 0.1.2 → 0.1.4

package/{src/logic/lazyWalletRegistry.ts → dist/esm/logic/lazyWalletRegistry.js}

@@ -1,22 +1,16 @@
-import { encodeFunctionData, Hex, WalletClient } from "viem";
-import { DataBundleDetails } from "../types.js";
+import { encodeFunctionData } from "viem";
 import { _getChainSpecificConstants, customErrors } from "./constants.js";
-import { SmartAccountClient } from "@aa-sdk/core";
 import { LazyWalletRegistry } from "../abis/index.js";
-
-
-export const _isLazyWalletDeployed = async (client: SmartAccountClient, deviceUniqueIdentifier: string) => {
-
+export const _isLazyWalletDeployed = async (client, deviceUniqueIdentifier) => {
     const chainID = await client.getChainId();
-	const rpcURL = client.transport.url;
-	const values = _getChainSpecificConstants(chainID, rpcURL);
-
-    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
-    
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    if (!client.account)
+        throw new Error(customErrors.MISSING_SMART_WALLET);
     // UserOp
     return client.sendUserOperation({
         account: client.account,
-        uo:{
+        uo: {
             target: values.factoryAddresses.LAZY_WALLET_REGISTRY,
             data: encodeFunctionData({
                 abi: LazyWalletRegistry,
@@ -25,25 +19,17 @@ export const _isLazyWalletDeployed = async (client: SmartAccountClient, deviceUn
             })
         }
     });
-}
-
-export const _batchPopulateHistory = async (
-    client: SmartAccountClient,
-    deviceUniqueIdentifiers: Array<string>,
-    eSIMUniqueIdentifiers: Array<Array<string>>,
-    dataBundleDetails: Array<Array<DataBundleDetails>>
-) => {
-
+};
+export const _batchPopulateHistory = async (client, deviceUniqueIdentifiers, eSIMUniqueIdentifiers, dataBundleDetails) => {
     const chainID = await client.getChainId();
-	const rpcURL = client.transport.url;
-	const values = _getChainSpecificConstants(chainID, rpcURL);
-
-    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
-    
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    if (!client.account)
+        throw new Error(customErrors.MISSING_SMART_WALLET);
     // UserOp
     return client.sendUserOperation({
         account: client.account,
-        uo:{
+        uo: {
             target: values.factoryAddresses.LAZY_WALLET_REGISTRY,
             data: encodeFunctionData({
                 abi: LazyWalletRegistry,
@@ -52,26 +38,17 @@ export const _batchPopulateHistory = async (
             })
         }
     });
-}
-
-export const _deployLazyWalletAndSetESIMIdentifier = async (
-    client: SmartAccountClient,
-    deviceOwnerPublicKey: Hex[2],
-    deviceUniqueIdentifier: string,
-    salt: bigint,
-    depositAmount: bigint
-) => {
-
+};
+export const _deployLazyWalletAndSetESIMIdentifier = async (client, deviceOwnerPublicKey, deviceUniqueIdentifier, salt, depositAmount) => {
     const chainID = await client.getChainId();
-	const rpcURL = client.transport.url;
-	const values = _getChainSpecificConstants(chainID, rpcURL);
-
-    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
-    
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    if (!client.account)
+        throw new Error(customErrors.MISSING_SMART_WALLET);
     // UserOp
     return client.sendUserOperation({
         account: client.account,
-        uo:{
+        uo: {
             target: values.factoryAddresses.LAZY_WALLET_REGISTRY,
             data: encodeFunctionData({
                 abi: LazyWalletRegistry,
@@ -80,25 +57,17 @@ export const _deployLazyWalletAndSetESIMIdentifier = async (
             })
         }
     });
-}
-
-export const _switchESIMIdentifierToNewDeviceIdentifier = async (
-    client: SmartAccountClient,
-    eSIMIdentifier: string,
-    oldDeviceIdentifier: string,
-    newDeviceIdentifier: string
-) => {
-
+};
+export const _switchESIMIdentifierToNewDeviceIdentifier = async (client, eSIMIdentifier, oldDeviceIdentifier, newDeviceIdentifier) => {
     const chainID = await client.getChainId();
-	const rpcURL = client.transport.url;
-	const values = _getChainSpecificConstants(chainID, rpcURL);
-
-    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
-    
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    if (!client.account)
+        throw new Error(customErrors.MISSING_SMART_WALLET);
     // UserOp
     return client.sendUserOperation({
         account: client.account,
-        uo:{
+        uo: {
             target: values.factoryAddresses.LAZY_WALLET_REGISTRY,
             data: encodeFunctionData({
                 abi: LazyWalletRegistry,
@@ -107,4 +76,4 @@ export const _switchESIMIdentifierToNewDeviceIdentifier = async (
             })
         }
     });
-}
+};

package/dist/esm/logic/utils.js

@@ -0,0 +1,100 @@
+import { isHex, toHex } from "viem";
+import { AsnParser } from "@peculiar/asn1-schema";
+import { ECDSASigValue } from "@peculiar/asn1-ecc";
+import { customErrors } from "./constants.js";
+export const _add0x = (data) => {
+    if (!data) {
+        throw customErrors.NULL_OR_UNDEFINED_VALUE;
+    }
+    return (data.indexOf('0x') !== -1) ? isHex(data) ? data : `0x${data}` : `0x${data}`;
+};
+export const _remove0x = (data) => {
+    if (!data) {
+        throw customErrors.NULL_OR_UNDEFINED_VALUE;
+    }
+    return (data.indexOf('0x') !== -1) ? data.slice(2) : data;
+};
+export function _shouldRemoveLeadingZero(bytes) {
+    return bytes[0] === 0x0 && (bytes[1] & (1 << 7)) !== 0;
+}
+export function _concatUint8Arrays(arrays) {
+    let pointer = 0;
+    const totalLength = arrays.reduce((prev, curr) => prev + curr.length, 0);
+    const toReturn = new Uint8Array(totalLength);
+    arrays.forEach((arr) => {
+        toReturn.set(arr, pointer);
+        pointer += arr.length;
+    });
+    return toReturn;
+}
+export function base64UrlToBuffer(base64url) {
+    const base64 = base64url
+        .replace(/-/g, "+")
+        .replace(/_/g, "/")
+        .padEnd((base64url.length + 3) & ~3, "=");
+    return Buffer.from(base64, "base64");
+}
+export function decodeClientDataJSON(base64url) {
+    const base64 = base64url
+        .replace(/-/g, "+")
+        .replace(/_/g, "/")
+        .padEnd((base64url.length + 3) & ~3, "=");
+    const jsonString = Buffer.from(base64, "base64").toString("utf-8");
+    return JSON.parse(jsonString);
+}
+export function hexToArrayBuffer(hexString) {
+    const cleanHex = hexString.startsWith("0x") ? hexString.slice(2) : hexString;
+    const bytes = new Uint8Array(cleanHex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        bytes[i] = parseInt(cleanHex.substr(i * 2, 2), 16);
+    }
+    return bytes.buffer;
+}
+export function parseDEREncodedSignature(signature) {
+    let offset = 0;
+    if (signature[offset++] !== 0x30)
+        throw new Error("Invalid DER sequence");
+    const length = signature[offset++];
+    if (signature[offset++] !== 0x02)
+        throw new Error("Expected integer for r");
+    const rLen = signature[offset++];
+    const r = signature.slice(offset, offset + rLen);
+    offset += rLen;
+    if (signature[offset++] !== 0x02)
+        throw new Error("Expected integer for s");
+    const sLen = signature[offset++];
+    const s = signature.slice(offset, offset + sLen);
+    return {
+        r: Buffer.from(r).toString("hex"),
+        s: Buffer.from(s).toString("hex"),
+    };
+}
+export function shouldRemoveLeadingZero(bytes) {
+    return bytes[0] === 0x0 && (bytes[1] & (1 << 7)) !== 0;
+}
+export function concatUint8Arrays(arrays) {
+    let pointer = 0;
+    const totalLength = arrays.reduce((prev, curr) => prev + curr.length, 0);
+    const toReturn = new Uint8Array(totalLength);
+    arrays.forEach((arr) => {
+        toReturn.set(arr, pointer);
+        pointer += arr.length;
+    });
+    return toReturn;
+}
+export function parseSignature(signature) {
+    const parsedSignature = AsnParser.parse(signature, ECDSASigValue);
+    let rBytes = new Uint8Array(parsedSignature.r);
+    let sBytes = new Uint8Array(parsedSignature.s);
+    if (shouldRemoveLeadingZero(rBytes)) {
+        rBytes = rBytes.slice(1);
+    }
+    if (shouldRemoveLeadingZero(sBytes)) {
+        sBytes = sBytes.slice(1);
+    }
+    const finalSignature = concatUint8Arrays([rBytes, sBytes]);
+    return {
+        r: toHex(finalSignature.slice(0, 32)),
+        s: toHex(finalSignature.slice(32)),
+    };
+}

package/dist/esm/types-export.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,3 @@
+import type { Abi } from "viem";
+declare const BeaconProxy: Abi;
+export default BeaconProxy;

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

@@ -0,0 +1,3 @@
+import type { Abi } from "viem";
+declare const DeviceWallet: Abi;
+export default DeviceWallet;

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

@@ -0,0 +1,3 @@
+import type { Abi } from "viem";
+declare const DeviceWalletFactory: Abi;
+export default DeviceWalletFactory;

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

@@ -0,0 +1,3 @@
+import type { Abi } from "viem";
+declare const ESIMWallet: Abi;
+export default ESIMWallet;

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

@@ -0,0 +1,3 @@
+import type { Abi } from "viem";
+declare const ESIMWalletFactory: Abi;
+export default ESIMWalletFactory;

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

@@ -0,0 +1,3 @@
+import type { Abi } from "viem";
+declare const LazyWalletRegistry: Abi;
+export default LazyWalletRegistry;

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

@@ -0,0 +1,3 @@
+import type { Abi } from "viem";
+declare const P256Verifier: Abi;
+export default P256Verifier;

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

@@ -0,0 +1,3 @@
+import type { Abi } from "viem";
+declare const Registry: Abi;
+export default Registry;

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

@@ -0,0 +1,3 @@
+import type { Abi } from "viem";
+declare const RegistryHelper: Abi;
+export default RegistryHelper;

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

@@ -0,0 +1,10 @@
+import DeviceWallet from './DeviceWallet.js';
+import DeviceWalletFactory from './DeviceWalletFactory.js';
+import ESIMWallet from './ESIMWallet.js';
+import ESIMWalletFactory from './ESIMWalletFactory.js';
+import LazyWalletRegistry from './LazyWalletRegistry.js';
+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 };

package/dist/types/config.d.ts

@@ -0,0 +1,37 @@
+import { Address, WalletClient } from "viem";
+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 { DeviceWalletSubPackage } from "./interface/deviceWalletClass.js";
+import { ESIMWalletSubPackage } from "./interface/eSIMWalletClass.js";
+import { ESIMWalletFactorySubPackage } from "./interface/eSIMWalletFactoryClass.js";
+import { SmartAccountClient } from "@aa-sdk/core";
+export declare class Kokio {
+    viemWalletClient: WalletClient;
+    credentialId: string;
+    rpId: string;
+    organizationId: string;
+    pimlicoAPIKey: string;
+    gasPolicyId: string;
+    private _constants;
+    smartAccount: SmartAccountSubPackage;
+    deviceWalletFactory?: DeviceWalletFactorySubPackage;
+    eSIMWalletFactory?: ESIMWalletFactorySubPackage;
+    lazyWalletRegistry?: LazyWalletRegistrySubPackage;
+    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);
+    /**
+     * Chain-specific constants (factory addresses, chain, RPC URLs, custom errors)
+     * for the wallet client's connected chain. Resolution is asynchronous because
+     * the chain id is read from the client, so this getter returns a promise:
+     *
+     *   const { factoryAddresses } = await kokio.constants;
+     *
+     * The underlying value is memoized, so repeated awaits do not re-fetch.
+     */
+    get constants(): Promise<KokioConstants>;
+}

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

@@ -0,0 +1,7 @@
+import { WebAuthnSignature } from "../types";
+import { SmartAccountClient } from "@aa-sdk/core";
+export declare class P256VerifierSubPackage {
+    client: SmartAccountClient;
+    constructor(client: SmartAccountClient);
+    verifySignature(message: string, requireMessageVerification: boolean, webAuthnSignature: WebAuthnSignature, x: bigint, y: bigint): Promise<import("@aa-sdk/core").SendUserOperationResult<keyof import("@aa-sdk/core").EntryPointRegistryBase<unknown>>>;
+}

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

@@ -0,0 +1,27 @@
+import { WalletClient } from "viem";
+import { mainnetFactoryAddresses, sepoliaFactoryAddresses, optimismMainnetFactoryAddresses, optimismSepoliaFactoryAddresses, baseMainnetFactoryAddresses, baseSepoliaFactoryAddresses, arbitrumOneFactoryAddresses, arbitrumSepoliaFactoryAddresses, customErrors, chainSpecifcConstants } from "../logic/constants.js";
+export interface KokioConstants {
+    factoryAddresses: typeof sepoliaFactoryAddresses | typeof mainnetFactoryAddresses | typeof optimismMainnetFactoryAddresses | typeof optimismSepoliaFactoryAddresses | typeof baseMainnetFactoryAddresses | typeof baseSepoliaFactoryAddresses | typeof arbitrumOneFactoryAddresses | typeof arbitrumSepoliaFactoryAddresses;
+    chain: chainSpecifcConstants["chain"];
+    rpcURL: string;
+    pimlicoRpcURL: string;
+    customErrors: typeof customErrors;
+}
+/**
+ * Resolves chain-specific constants for the wallet client's connected chain.
+ *
+ * The chain id can only be read asynchronously from the client, so resolution
+ * is deferred to `load()` (memoized after the first call). Access the resolved
+ * values via `await kokio.constants` on the top-level SDK instance.
+ */
+export declare class ConstantsSubPackage {
+    private client;
+    private pimlicoAPIKey;
+    private cache?;
+    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.
+     */
+    load(): Promise<KokioConstants>;
+}