kokio-sdk 0.0.1

package/src/logic/deviceWallet.ts

@@ -0,0 +1,175 @@
+import { Address, createPublicClient, encodeFunctionData, getContract, PublicClient, WalletClient } from "viem";
+import { SmartAccountClient } from "@aa-sdk/core";
+import { DeviceWallet } from "../abis/index.js";
+import { _getChainSpecificConstants, customErrors } from "./constants.js";
+import { P256Key } from "../types.js";
+
+export const _deployESIMWallet = async (client: SmartAccountClient, address: Address, hasAccessToETH: boolean, salt: bigint) => {
+
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET);
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: DeviceWallet,
+                functionName: "deployESIMWallet",
+                args: [hasAccessToETH, salt]
+            })
+        }
+    });
+}
+
+export const _setESIMUniqueIdentifierForAnESIMWallet = async (
+    client: SmartAccountClient,
+    address: Address,
+    eSIMWalletAddress: Address,
+    eSIMUniqueIdentifier: string
+) => {
+
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET);
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: DeviceWallet,
+                functionName: "setESIMUniqueIdentifierForAnESIMWallet",
+                args: [eSIMWalletAddress, eSIMUniqueIdentifier]
+            })
+        }
+    });
+    // const contract = (await getContractInstance(client)).deviceWallet(address);
+
+    // return contract.write.setESIMUniqueIdentifierForAnESIMWallet([eSIMWalletAddress, eSIMUniqueIdentifier]);
+}
+
+export const _payETHForDataBundles = async (client: SmartAccountClient, address: Address, amount: bigint) => {
+
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: DeviceWallet,
+                functionName: "payETHForDataBundles",
+                args: [amount]
+            })
+        }
+    });
+}
+
+export const _pullETH = async (client: SmartAccountClient, address: Address, amount: bigint) => {
+    
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET);
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: DeviceWallet,
+                functionName: "pullETH",
+                args: [address, amount]
+            })
+        }
+    });
+}
+
+export const _getVaultAddress = async (client: SmartAccountClient, address: Address) => {
+
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET);
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: DeviceWallet,
+                functionName: "getVaultAddress",
+                args: [address]
+            })
+        }
+    });
+}
+
+export const _toggleAccessToETH = async (client: SmartAccountClient, address: Address, eSIMWalletAddress: Address, hasAccessToETH: boolean) => {
+
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET);
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: DeviceWallet,
+                functionName: "toggleAccessToETH",
+                args: [address, eSIMWalletAddress, hasAccessToETH]
+            })
+        }
+    });
+}
+
+export const _addESIMWallet = async (client: SmartAccountClient, address: Address, eSIMWalletAddress: Address, hasAccessToETH: boolean) => {
+
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET);
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: DeviceWallet,
+                functionName: "addESIMWallet",
+                args: [address, eSIMWalletAddress, hasAccessToETH]
+            })
+        }
+    });
+}
+
+export const _removeESIMWallet = async (client: SmartAccountClient, address: Address, eSIMWalletAddress: Address, hasAccessToETH: boolean) => {
+
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET);
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: DeviceWallet,
+                functionName: "removeESIMWallet",
+                args: [address, eSIMWalletAddress, hasAccessToETH]
+            })
+        }
+    });
+}
+
+export const _getOwner = async (client: WalletClient, address: Address) => {
+
+    const chainID = await client.getChainId();
+    const values = _getChainSpecificConstants(chainID);
+
+    const contract = getContract({
+        abi: DeviceWallet,
+        address: address,
+        client
+    })
+
+    const x = await contract.read.owner([0]);
+    const y = await contract.read.owner([1]);
+
+    const owner = [x,y]; 
+    return owner as P256Key;
+}

package/src/logic/deviceWalletFactory.ts

@@ -0,0 +1,70 @@
+import { encodeFunctionData, WalletClient } from "viem";
+import { SmartAccountClient } from "@aa-sdk/core";
+import { _extractChainID, _getChainSpecificConstants, customErrors } from "./constants.js";
+import { DeviceWalletFactory } from "../abis/index.js";
+
+export const _createAccountWithEOA = async (
+    client: WalletClient,
+    deviceUniqueIdentifier: string,
+    deviceWalletOwnerKey: string,
+    salt: bigint,
+    depositAmount: bigint
+) => {
+
+    const chainID = await client.getChainId();
+    const values = _getChainSpecificConstants(chainID);
+
+    if (!client.account) throw new Error(customErrors.MISSING_EOA_WALLET);
+
+    return client.writeContract({
+        address: values.factoryAddresses.DEVICE_WALLET_FACTORY,
+        chain: values.chain,
+        account: client.account.address,
+        abi: DeviceWalletFactory,
+        functionName: 'createAccount',
+        args: [deviceUniqueIdentifier, deviceWalletOwnerKey, salt, depositAmount]
+    });
+}
+
+export const _getAddress = async (
+    client: SmartAccountClient,
+    deviceUniqueIdentifier: string,
+    deviceWalletOwnerKey: string,
+    salt: bigint,
+) => {
+
+    const values = _getChainSpecificConstants(await client.getChainId());
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: values.factoryAddresses.DEVICE_WALLET_FACTORY,
+            data: encodeFunctionData({
+                abi: DeviceWalletFactory,
+                functionName: "getAddress",
+                args: [deviceUniqueIdentifier, deviceWalletOwnerKey, salt]
+            })
+        }
+    });
+}
+
+export const _getCurrentDeviceWalletImplementation = async (client: SmartAccountClient) => {
+
+    const values = _getChainSpecificConstants(await client.getChainId());
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: values.factoryAddresses.DEVICE_WALLET_FACTORY,
+            data: encodeFunctionData({
+                abi: DeviceWalletFactory,
+                functionName: "getCurrentDeviceWalletImplementation",
+                args: []
+            })
+        }
+    });
+}

package/src/logic/eSIMWallet.ts

@@ -0,0 +1,149 @@
+import { Address, encodeFunctionData, WalletClient } from "viem"
+import { DataBundleDetails } from "../types.js";
+import { SmartAccountClient } from "@aa-sdk/core";
+import { customErrors } from "./constants.js";
+import { ESIMWallet } from "../abis/index.js";
+
+
+export const _setESIMUniqueIdentifier = async (client: SmartAccountClient, address: Address, eSIMUniqueIdentifier: string) => {
+
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: ESIMWallet,
+                functionName: "setESIMUniqueIdentifier",
+                args: [eSIMUniqueIdentifier]
+            })
+        }
+    });
+}
+
+export const _buyDataBundle = async (client: SmartAccountClient, address: Address, dataBundleDetails: DataBundleDetails) => {
+    
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: ESIMWallet,
+                functionName: "payETHForDataBundles",
+                args: [dataBundleDetails]
+            })
+        }
+    });
+}
+
+export const _populateHistory = async (client: SmartAccountClient, address: Address, dataBundleDetails: Array<DataBundleDetails>) => {
+
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: ESIMWallet,
+                functionName: "populateHistory",
+                args: [dataBundleDetails]
+            })
+        }
+    });
+}
+
+export const _owner = async (client: SmartAccountClient, address: Address) => {
+
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: ESIMWallet,
+                functionName: "ow",
+                args: []
+            })
+        }
+    });
+}
+
+export const _requestTransferOwnership = async (client: SmartAccountClient, address: Address, newOwner: Address) => {
+
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: ESIMWallet,
+                functionName: "requestTransferOwnership",
+                args: [newOwner]
+            })
+        }
+    });
+}
+
+export const _acceptOwnershipTransfer = async (client: SmartAccountClient, address: Address) => {
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: ESIMWallet,
+                functionName: "acceptOwnershipTransfer",
+                args: []
+            })
+        }
+    });
+}
+
+export const _sendETHToDeviceWallet = async (client: SmartAccountClient, address: Address, amount: bigint) => {
+
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: ESIMWallet,
+                functionName: "sendETHToDeviceWallet",
+                args: [amount]
+            })
+        }
+    });
+}
+
+export const _transferOwnership = async (client: SmartAccountClient, address: Address, amount: bigint) => {
+
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: address,
+            data: encodeFunctionData({
+                abi: ESIMWallet,
+                functionName: "transferOwnership",
+                args: [amount]
+            })
+        }
+    });
+}

package/src/logic/eSIMWalletFactory.ts

@@ -0,0 +1,78 @@
+import { Address, encodeFunctionData, WalletClient } from "viem"
+import { _getChainSpecificConstants, customErrors } from "./constants.js";
+import { SmartAccountClient } from "@aa-sdk/core";
+import { ESIMWalletFactory } from "../abis/index.js";
+
+export const _addRegistryAddress = async (client: SmartAccountClient, registryContractAddress: Address) => {
+
+    const values = _getChainSpecificConstants(await client.getChainId());
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: values.factoryAddresses.ESIM_WALLET_FACTORY,
+            data: encodeFunctionData({
+                abi: ESIMWalletFactory,
+                functionName: "addRegistryAddress",
+                args: [registryContractAddress]
+            })
+        }
+    });
+}
+
+export const _deployESIMWalletWithEOA = async (client: WalletClient, deviceWalletAddress: Address, salt: bigint) => {
+
+    const chainID = await client.getChainId();
+    const values = _getChainSpecificConstants(chainID);
+
+    if (!client.account) throw new Error(customErrors.MISSING_EOA_WALLET);
+
+    return client.writeContract({
+        address: values.factoryAddresses.ESIM_WALLET_FACTORY,
+        chain: values.chain,
+        account: client.account.address,
+        abi: ESIMWalletFactory,
+        functionName: 'deployESIMWallet',
+        args: [deviceWalletAddress, salt]
+    });
+}
+
+export const _deployESIMWalletWithUserOp = async (client: SmartAccountClient, deviceWalletAddress: Address, salt: bigint) => {
+
+    const values = _getChainSpecificConstants(await client.getChainId());
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: values.factoryAddresses.ESIM_WALLET_FACTORY,
+            data: encodeFunctionData({
+                abi: ESIMWalletFactory,
+                functionName: "deployESIMWallet",
+                args: [deviceWalletAddress, salt]
+            })
+        }
+    });
+}
+
+export const _getCurrentESIMWalletImplementation = async (client: SmartAccountClient) => {
+
+    const values = _getChainSpecificConstants(await client.getChainId());
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: values.factoryAddresses.ESIM_WALLET_FACTORY,
+            data: encodeFunctionData({
+                abi: ESIMWalletFactory,
+                functionName: "getCurrentESIMWalletImplementation",
+                args: []
+            })
+        }
+    });
+}

package/src/logic/lazyWalletRegistry.ts

@@ -0,0 +1,98 @@
+import { encodeFunctionData, Hex, WalletClient } from "viem";
+import { DataBundleDetails } from "../types.js";
+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) => {
+
+    const values = _getChainSpecificConstants(await client.getChainId());
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+            data: encodeFunctionData({
+                abi: LazyWalletRegistry,
+                functionName: "isLazyWalletDeployed",
+                args: [deviceUniqueIdentifier]
+            })
+        }
+    });
+}
+
+export const _batchPopulateHistory = async (
+    client: SmartAccountClient,
+    deviceUniqueIdentifiers: Array<string>,
+    eSIMUniqueIdentifiers: Array<Array<string>>,
+    dataBundleDetails: Array<Array<DataBundleDetails>>
+) => {
+
+    const values = _getChainSpecificConstants(await client.getChainId());
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+            data: encodeFunctionData({
+                abi: LazyWalletRegistry,
+                functionName: "batchPopulateHistory",
+                args: [deviceUniqueIdentifiers, eSIMUniqueIdentifiers, dataBundleDetails]
+            })
+        }
+    });
+}
+
+export const _deployLazyWalletAndSetESIMIdentifier = async (
+    client: SmartAccountClient,
+    deviceOwnerPublicKey: Hex[2],
+    deviceUniqueIdentifier: string,
+    salt: bigint,
+    depositAmount: bigint
+) => {
+
+    const values = _getChainSpecificConstants(await client.getChainId());
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+            data: encodeFunctionData({
+                abi: LazyWalletRegistry,
+                functionName: "deployLazyWalletAndSetESIMIdentifier",
+                args: [deviceOwnerPublicKey, deviceUniqueIdentifier, salt, depositAmount]
+            })
+        }
+    });
+}
+
+export const _switchESIMIdentifierToNewDeviceIdentifier = async (
+    client: SmartAccountClient,
+    eSIMIdentifier: string,
+    oldDeviceIdentifier: string,
+    newDeviceIdentifier: string
+) => {
+
+    const values = _getChainSpecificConstants(await client.getChainId());
+    if(!client.account) throw new Error(customErrors.MISSING_SMART_WALLET)
+    
+    // UserOp
+    return client.sendUserOperation({
+        account: client.account,
+        uo:{
+            target: values.factoryAddresses.LAZY_WALLET_REGISTRY,
+            data: encodeFunctionData({
+                abi: LazyWalletRegistry,
+                functionName: "switchESIMIdentifierToNewDeviceIdentifier",
+                args: [eSIMIdentifier, oldDeviceIdentifier, newDeviceIdentifier]
+            })
+        }
+    });
+}

package/src/logic/services/turnkeyClient.ts

@@ -0,0 +1,80 @@
+import { assertActivityCompleted, assertNonNull, TurnkeyClient } from "@turnkey/http"
+import { Address, hashMessage, hashTypedData, SignableMessage, toHex, TypedData, TypedDataDefinition } from "viem";
+import { decodeAttestationObject, decodeClientDataJSON } from "@simplewebauthn/server/helpers";
+import { base64UrlToBuffer } from "../utils.js";
+import { WebAuthnSignature } from "../../types.js";
+
+export const _signMessageWithTurnkey = async (client: TurnkeyClient, organizationId: string, signWith: Address, message: SignableMessage): Promise<WebAuthnSignature> => {
+    
+    const payload = hashMessage(message);
+    
+    const { activity } = await client.signRawPayload({
+        type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2",
+        organizationId: organizationId,
+        parameters: {
+            signWith: signWith,
+            payload: payload,
+            encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
+            hashFunction: "HASH_FUNCTION_NO_OP",
+        },
+        timestampMs: String(Date.now()), // millisecond timestamp
+    });
+
+    assertActivityCompleted(activity);
+
+    const attestationObject = assertNonNull(activity.intent.createOrganizationIntent?.rootAuthenticator.attestation.response.attestationObject);
+    const decodedAttestationObj = decodeAttestationObject(base64UrlToBuffer(attestationObject))
+
+    const clientDataJson = assertNonNull(activity.intent.createOrganizationIntent?.rootAuthenticator.attestation.response.clientDataJson);
+    const decodedClientDataJson = decodeClientDataJSON(clientDataJson);
+
+    const signature = assertNonNull(activity.result.signRawPayloadResult);
+
+    return {
+        authenticatorData: toHex(decodedAttestationObj.get("authData")),
+        clientDataJSON: JSON.stringify(decodedClientDataJson),
+        challengeIndex: BigInt(23),
+        typeIndex: BigInt(1),
+        r: BigInt(signature.r),
+        s: BigInt(signature.s) 
+    }
+} 
+
+export const _signTypedDataWithTurnkey = async <
+    const typedData extends TypedData | Record<string, unknown>,
+    primaryType extends keyof typedData | "EIP712Domain" = keyof typedData
+> (client: TurnkeyClient, organizationId: string, signWith: Address, typedData: TypedDataDefinition<typedData, primaryType>): Promise<WebAuthnSignature> => {
+    
+    const payload = hashTypedData(typedData);
+    
+    const { activity } = await client.signRawPayload({
+        type: "ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2",
+        organizationId: organizationId,
+        parameters: {
+            signWith: signWith,
+            payload: payload,
+            encoding: "PAYLOAD_ENCODING_HEXADECIMAL",
+            hashFunction: "HASH_FUNCTION_NO_OP",
+        },
+        timestampMs: String(Date.now()), // millisecond timestamp
+    });
+
+    assertActivityCompleted(activity);
+
+    const attestationObject = assertNonNull(activity.intent.createOrganizationIntent?.rootAuthenticator.attestation.response.attestationObject);
+    const decodedAttestationObj = decodeAttestationObject(base64UrlToBuffer(attestationObject))
+
+    const clientDataJson = assertNonNull(activity.intent.createOrganizationIntent?.rootAuthenticator.attestation.response.clientDataJson);
+    const decodedClientDataJson = decodeClientDataJSON(clientDataJson);
+
+    const signature = assertNonNull(activity.result.signRawPayloadResult);
+
+    return {
+        authenticatorData: toHex(decodedAttestationObj.get("authData")),
+        clientDataJSON: JSON.stringify(decodedClientDataJson),
+        challengeIndex: BigInt(23),
+        typeIndex: BigInt(1),
+        r: BigInt(signature.r),
+        s: BigInt(signature.s) 
+    }
+}