kokio-sdk 0.0.1

package/src/interface/eSIMWalletFactoryClass.ts

@@ -0,0 +1,36 @@
+import { Address, WalletClient } from "viem";
+import {
+    _addRegistryAddress,
+    _deployESIMWalletWithEOA,
+    _deployESIMWalletWithUserOp,
+    _getCurrentESIMWalletImplementation
+} from "../logic/eSIMWalletFactory.js"
+import { SmartAccountClient } from "@aa-sdk/core";
+
+export class eSIMWalletFactorySubPackage {
+
+    smartAccountClient;
+    walletClient;
+
+    constructor(walletClient: WalletClient, smartAccountClient: SmartAccountClient) {
+        this.smartAccountClient = smartAccountClient;
+        this.walletClient = walletClient
+    }
+
+    deployESIMWalletWithEOA (deviceWalletAddress: Address, salt: bigint) {
+        return _deployESIMWalletWithEOA (this.walletClient, deviceWalletAddress, salt);
+    }
+
+
+    deployESIMWalletWithUserOp (deviceWalletAddress: Address, salt: bigint) {
+        return _deployESIMWalletWithUserOp (this.smartAccountClient, deviceWalletAddress, salt);
+    }
+
+    addRegistryAddress (registryContractAddress: Address) {
+        return _addRegistryAddress(this.smartAccountClient, registryContractAddress);
+    }
+
+    _getCurrentESIMWalletImplementation () {
+        return _getCurrentESIMWalletImplementation(this.smartAccountClient);
+    }
+}

package/src/interface/lazyWalletRegistryClass.ts

@@ -0,0 +1,34 @@
+import { Address, Hex, WalletClient } from "viem";
+import {
+    _batchPopulateHistory,
+    _deployLazyWalletAndSetESIMIdentifier,
+    _isLazyWalletDeployed,
+    _switchESIMIdentifierToNewDeviceIdentifier
+} from "../logic/lazyWalletRegistry.js"
+import { DataBundleDetails } from "../types";
+import { SmartAccountClient } from "@aa-sdk/core";
+
+export class lazyWalletRegistrySubPackage {
+
+    client;
+
+    constructor(client: SmartAccountClient) {
+        this.client = client;
+    }
+
+    _batchPopulateHistory (deviceUniqueIdentifiers: Array<string>, eSIMUniqueIdentifiers: Array<Array<string>>, dataBundleDetails: Array<Array<DataBundleDetails>>) {
+        return _batchPopulateHistory(this.client, deviceUniqueIdentifiers, eSIMUniqueIdentifiers, dataBundleDetails);
+    }
+
+    _deployLazyWalletAndSetESIMIdentifier (deviceOwnerPublicKey: Hex[2], deviceUniqueIdentifier: string, salt: bigint, depositAmount: bigint) {
+        return _deployLazyWalletAndSetESIMIdentifier(this.client, deviceOwnerPublicKey, deviceUniqueIdentifier, salt, depositAmount);
+    }
+
+    _isLazyWalletDeployed (deviceUniqueIdentifier: string) {
+        return _isLazyWalletDeployed(this.client, deviceUniqueIdentifier);
+    }
+
+    _switchESIMIdentifierToNewDeviceIdentifier (eSIMIdentifier: string, oldDeviceIdentifier: string, newDeviceIdentifier: string) {
+        return _switchESIMIdentifierToNewDeviceIdentifier(this.client, eSIMIdentifier, oldDeviceIdentifier, newDeviceIdentifier);
+    }
+}

package/src/interface/smartAccountClass.ts

@@ -0,0 +1,26 @@
+import { Address, WalletClient } from "viem";
+import { _getSmartWallet, _getSmartWalletClient } from "../logic/account-kit/createSmartAccount.js";
+import { P256Key, SignedRequest } from "../types";
+import { SmartAccountClient, SmartContractAccount } from "@aa-sdk/core";
+import { TurnkeyClient } from "@turnkey/http";
+
+export class smartAccountSubPackage {
+
+    client;
+    turnkeyClient;
+    organizationId; 
+    
+    constructor(client: WalletClient, turnkeyClient: TurnkeyClient, organiationId: string) {
+        this.client = client;
+        this.turnkeyClient = turnkeyClient;
+        this.organizationId = organiationId;
+    }
+
+    getSmartWallet (deviceUniqueIdentifier: string, deviceWalletOwnerKey: P256Key, salt: bigint, sender?: Address) {
+        return _getSmartWallet(this.client, this.turnkeyClient, this.organizationId, deviceUniqueIdentifier, deviceWalletOwnerKey, salt, sender)
+    }
+
+    getSmartWalletClient (account: SmartContractAccount) {
+        return _getSmartWalletClient(this.client, account)
+    }
+}

package/src/interface/utilsClass.ts

@@ -0,0 +1,21 @@
+import { WalletClient } from "viem";
+import { _add0x, _remove0x } from "../logic/utils.js";
+import { AccountOp, SmartAccountClient } from "@aa-sdk/core";
+
+export class UtilsSubPackage {
+
+    client; 
+    
+    constructor(client: WalletClient) {
+        this.client = client;
+    }
+
+    add0x(data: string) {
+        _add0x(data);
+    }
+
+    remove0x(data: string) {
+        _remove0x(data);
+    }
+    
+}

package/src/logic/P256Verifier.ts

@@ -0,0 +1,31 @@
+import { encodeFunctionData, WalletClient } from "viem";
+import { WebAuthnSignature } from "../types.js";
+import { SmartAccountClient } from "@aa-sdk/core";
+import { _getChainSpecificConstants, customErrors } from "./constants.js";
+import { P256Verifier } from "../abis/index.js";
+
+export const _verifySignature = async (
+    client: SmartAccountClient,
+    message: string,
+    requireMessageVerification: boolean,
+    webAuthnSignature: WebAuthnSignature,
+    x: bigint,
+    y: 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.P256VERIFIER,
+            data: encodeFunctionData({
+                abi: P256Verifier,
+                functionName: "deployLazyWalletAndSetESIMIdentifier",
+                args: [message, requireMessageVerification, webAuthnSignature, x, y]
+            })
+        }
+    });
+}

package/src/logic/account-kit/createSmartAccount.ts

@@ -0,0 +1,282 @@
+import { 
+	AccountOp,
+	createSmartAccountClient,
+	getEntryPoint,
+	SmartContractAccount,
+	toSmartContractAccount,
+} from "@aa-sdk/core";
+import { 
+	http,
+	type SignableMessage,
+	type Hash,
+	WalletClient,
+	Hex,
+	encodeFunctionData,
+	Address,
+	encodePacked,
+	encodeAbiParameters,
+	getContract,
+	TypedDataDefinition,
+	TypedData
+} from "viem";
+import { TurnkeyClient } from "@turnkey/http";
+import { BytesLike, ethers, hexlify } from "ethers";
+import { _getChainSpecificConstants, ZERO } from "../constants.js";
+import { _add0x, _concatUint8Arrays, _remove0x, _shouldRemoveLeadingZero } from "../utils.js";
+import { P256Key, WebAuthnSignature } from "../../types.js";
+import { DeviceWallet, DeviceWalletFactory } from "../../abis/index.js";
+import { _signMessageWithTurnkey, _signTypedDataWithTurnkey } from "../services/turnkeyClient.js";
+
+const _encodeExecute = async (tx: AccountOp) => {
+
+	return encodeFunctionData({
+		abi: DeviceWallet,
+		functionName: "execute",
+		args: [{
+			dest: tx.target,
+			value: tx.value ?? ZERO,
+			data: tx.data
+		}]
+	});
+}
+
+const _encodeBatchExecute = async (txs: AccountOp[]) => {
+  
+	const new_txs:{dest:Address, value:bigint, data: Hex | '0x'}[] = [];
+	
+	for (let i=0; i<txs.length; ++i) {
+		new_txs.push({
+		dest: txs[i].target,
+		value: txs[i].value ?? ZERO,
+		data: txs[i].data
+		})
+	}
+	
+	return encodeFunctionData({
+		abi: DeviceWallet,
+		functionName: "executeBatch",
+		args: [new_txs]
+	});
+}
+
+const _getAccountInitCode = async (client: WalletClient, deviceUniqueIdentifier: string, deviceWalletOwnerKey: P256Key, salt: bigint): Promise<Hex> => {
+
+  // To send with user operations
+  const chainID = await client.getChainId();
+  const values = _getChainSpecificConstants(chainID);
+
+  const callData =  encodeFunctionData({
+    abi: DeviceWalletFactory, 
+    functionName: "createAccount",
+    args: [deviceUniqueIdentifier, deviceWalletOwnerKey, salt, ZERO],
+  })
+
+  return values.factoryAddresses.DEVICE_WALLET_FACTORY.concat(_remove0x(callData)) as Hex;
+}
+
+const getInitCodeHash = async (client: WalletClient, deviceUniqueIdentifier: string, deviceWalletOwnerKey: P256Key): Promise<BytesLike> => {
+  
+	const chainID = await client.getChainId();
+	const values = _getChainSpecificConstants(chainID);
+  
+  // off-chain computation of the DeviceWallet address
+	const registry = values.factoryAddresses.REGISTRY;
+	const deviceWalletFactoryAddress = values.factoryAddresses.DEVICE_WALLET_FACTORY;
+
+	const deviceWalletFactory = getContract({
+		abi: DeviceWalletFactory,
+		address: deviceWalletFactoryAddress,
+		client
+	});
+
+	const beacon = await deviceWalletFactory.read.beacon([]);
+
+	const abiCoder = ethers.AbiCoder.defaultAbiCoder();
+
+	// Encode the DeviceWallet.init with the init params
+	const deviceWallet = new ethers.Interface(DeviceWallet);
+	const deviceWalletInitData = deviceWallet.encodeFunctionData("init", [
+		registry,
+		deviceWalletOwnerKey,
+		deviceUniqueIdentifier,
+	]);
+
+	const beaconProxyBytecode = "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";
+
+	// Encode BeaconProxy constructor args
+	const beaconProxyConstructorArgs = abiCoder.encode(
+		["address", "bytes"],
+		[beacon, deviceWalletInitData]
+	);
+	
+	// Compute initCode
+	const initCode:BytesLike = ethers.concat([beaconProxyBytecode, beaconProxyConstructorArgs]);
+
+	return ethers.keccak256(initCode);
+}
+
+const prepareSaltForCreate2 = (sender: Address, salt: BigInt): BytesLike => {
+
+	// Calculating unique salt based on createAccount function's implementation
+	const abiCoder = ethers.AbiCoder.defaultAbiCoder();
+	const encoded = abiCoder.encode(
+		["address", "uint256"],
+		[sender, salt]
+	);
+	const uniqueSaltBytes32 = ethers.keccak256(encoded);
+
+	return uniqueSaltBytes32;
+}
+
+// NOTE: Sender is the address that deploys the contract.
+// In case of ERC-4337, it is the Entry Point contract address
+const getCounterFactualAddress = async (client: WalletClient, deviceUniqueIdentifier: string, deviceWalletOwnerKey: P256Key, salt: BigInt, sender?: Address):Promise<Hex> => {
+
+	const chainID = await client.getChainId();
+	const values = _getChainSpecificConstants(chainID);
+	const deviceWalletFactoryAddress = values.factoryAddresses.DEVICE_WALLET_FACTORY;
+
+	sender = sender? sender : values.factoryAddresses.SENDER_CREATOR;
+	const uniqueSaltBytes32 = prepareSaltForCreate2(sender, salt);
+	const initCodeHash = await getInitCodeHash(client, deviceUniqueIdentifier, deviceWalletOwnerKey);
+
+	// Calculate deterministic address from init code hash
+	const create2Address = ethers.getCreate2Address(deviceWalletFactoryAddress, uniqueSaltBytes32, initCodeHash);
+
+	return ethers.getAddress(create2Address) as Address;
+}
+
+const _encodeSignature = async (webAuthnSignature: WebAuthnSignature): Promise<Hex> => {
+
+	const signature = encodePacked(
+		["uint8", "uint48", "bytes"],
+		[
+		1,
+		0,
+		encodeAbiParameters([
+			{
+				type: "tuple",
+				name: "credentials",
+				components: [
+					{
+						name: "authenticatorData",
+						type: "bytes",
+					},
+					{
+						name: "clientDataJSON",
+						type: "string",
+					},
+					{
+						name: "challengeIndex",
+						type: "uint256",
+					},
+					{
+						name: "typeIndex",
+						type: "uint256",
+					},
+					{
+						name: "r",
+						type: "uint256",
+					},
+					{
+						name: "s",
+						type: "uint256",
+					},
+				],
+			},
+		],
+		[
+			{
+				authenticatorData: _add0x(webAuthnSignature.authenticatorData),
+				clientDataJSON: JSON.stringify(webAuthnSignature.clientDataJSON),
+				challengeIndex: BigInt(23),
+				typeIndex: BigInt(1),
+				r: webAuthnSignature.r,
+				s: webAuthnSignature.s,
+			},
+		]),
+		],
+	);
+
+	return signature;
+}
+
+const _signMessage = async (message: SignableMessage, turnkeyClient: TurnkeyClient, organiationId: string, signWith: Address): Promise<Hex> => {
+
+	const webAuthnSignature = await _signMessageWithTurnkey(turnkeyClient, organiationId, signWith, message);
+
+	return _encodeSignature(webAuthnSignature);
+}
+
+const _signTypedData = async <
+    const typedData extends TypedData | Record<string, unknown>,
+    primaryType extends keyof typedData | "EIP712Domain" = keyof typedData
+> (typedData: TypedDataDefinition<typedData, primaryType>, turnkeyClient: TurnkeyClient, organiationId: string, signWith: Address): Promise<Hex> => {
+
+	const webAuthnSignature = await _signTypedDataWithTurnkey(turnkeyClient, organiationId, signWith, typedData);
+
+	return _encodeSignature(webAuthnSignature);
+}
+
+const _signUserOperationHash = async (hash: Hex, turnkeyClient: TurnkeyClient, organiationId: string, signWith: Address): Promise<Hex> => {
+
+	const message = encodePacked(["uint8", "uint48", "bytes32"], [1, 0, hash]);
+	return _signMessage(message, turnkeyClient, organiationId, signWith);
+}
+
+export const _getSmartWallet = async (client: WalletClient, turnkeyClient: TurnkeyClient, organiationId: string, deviceUniqueIdentifier: string, deviceWalletOwnerKey: P256Key, salt: bigint, sender?: Address): Promise<SmartContractAccount> => {
+
+	const chainID = await client.getChainId();
+	const values = _getChainSpecificConstants(chainID);
+
+	if (!client.account) throw new Error ('Error: No signer account found with WalletClient')
+	const signWith = client.account.address;
+
+	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, {addressOverride: values.factoryAddresses.ENTRY_POINT}), 
+
+		getAccountInitCode: async (): Promise<Hex> => 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 (): Promise<Hash> => "0xfffffffffffffffffffffffffffffff0000000000000000000000000000000007aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1c", //from Alchemy docs
+		
+		// given a UO in the form of {target, data, value} should output the calldata for calling your contract's execution method
+		encodeExecute: async (uo): Promise<Hash> => _encodeExecute(uo),
+		
+		signMessage: async ({ message }): Promise<Hash> => _signMessage(message, turnkeyClient, organiationId, signWith),
+
+		signTypedData: async (typedData): Promise<Hash> => _signTypedData(typedData, turnkeyClient, organiationId, signWith),
+		
+		/// 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, sender),
+		// 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): Promise<Hash> => _encodeBatchExecute(uos),
+		// if your contract expects a different signing scheme than the default signMessage scheme, you can override that here
+		signUserOperationHash: async (hash): Promise<Hash> => _signUserOperationHash(hash, turnkeyClient, organiationId, signWith),
+		// allows you to define the calldata for upgrading your account
+		// encodeUpgradeToAndCall: async (params): Promise<Hash> => "0x...",
+	});
+}
+
+export const _getSmartWalletClient = async (client: WalletClient, account: SmartContractAccount) => {
+
+	const chainID = await client.getChainId();
+	const values = _getChainSpecificConstants(chainID);
+
+	return createSmartAccountClient({
+		// created above
+		account: account,
+		chain: values.chain,
+		transport: http(values.rpcURL),
+	});
+}

package/src/logic/constants.ts

@@ -0,0 +1,188 @@
+import * as dotenv from 'dotenv';
+dotenv.config();
+
+import { WalletClient } from "viem";
+
+import {
+    mainnet,
+    sepolia,
+    optimism,
+    optimismSepolia,
+    arbitrum,
+    arbitrumSepolia
+} from "viem/chains";
+
+export const ZERO = BigInt('0');
+
+export const API_KEY = process.env.API_KEY;
+
+export enum CHAIN_ID  {
+    MAINNET = 1,
+    SEPOLIA = 11155111,
+    OPTIMISM_MAINNET = 10,
+    OPTIMISM_SEPOLIA = 11155420,
+    ARBITRUM_ONE = 42161,
+    ARBITRUM_SEPOLIA = 421614,
+}
+
+export const rpcURLs: Record<string, string> = {
+    mainnet: `https://eth-mainnet.g.alchemy.com/v2/${API_KEY}`,
+    sepolia: `https://eth-sepolia.g.alchemy.com/v2/${API_KEY}`,
+    optimismMainnet : `https://opt-mainnet.g.alchemy.com/v2/${API_KEY}`,
+    optimismSepolia: `https://opt-sepolia.g.alchemy.com/v2/${API_KEY}`,
+    arbitrum: `https://arb-mainnet.g.alchemy.com/v2/${API_KEY}`,
+    arbitrumSepolia: `https://arb-sepolia.g.alchemy.com/v2/${API_KEY}`,
+}
+
+export interface chainSpecifcConstants {
+    factoryAddresses: 
+        typeof sepoliaFactoryAddresses |
+        typeof mainnetFactoryAddresses |
+        typeof optimismMainnetFactoryAddresses |
+        typeof optimismSepoliaFactoryAddresses |
+        typeof arbitrumOneFactoryAddresses |
+        typeof arbitrumSepoliaFactoryAddresses;
+    chain: 
+        typeof mainnet |
+        typeof sepolia |
+        typeof optimism |
+        typeof optimismSepolia |
+        typeof arbitrum |
+        typeof arbitrumSepolia
+    rpcURL: string; 
+    customErrors: typeof customErrors;
+}
+
+export const sepoliaFactoryAddresses: Record<string, `0x${string}`> = {
+    DEVICE_WALLET_FACTORY: '0x63005d8214533fC7209678Aa39F7b9b0b51a7bcB',
+    ESIM_WALLET_FACTORY: '0xB4473979ff8cE4e09161B08f74EEb66BD7718076',
+    LAZY_WALLET_REGISTRY: '0x8a1E53b903efcc6b252CE4bD3b255202318505Ef',
+    REGISTRY: '0xCa447f5C75C57f6C59027304A5Fb5A09F0E005c9',
+    ENTRY_POINT: '0x0000000071727De22E5E9d8BAf0edAc6f37da032',
+    SENDER_CREATOR: '0x9406Cc6185a346906296840746125a0E44976454',
+    P256VERIFIER: '0xF04f3b3935aD461D17d4a8a78E7ea21d4a61AEb1'
+}
+
+export const mainnetFactoryAddresses: Record<string, `0x${string}`> = {
+    DEVICE_WALLET_FACTORY: '0x',
+    ESIM_WALLET_FACTORY: '0x',
+    LAZY_WALLET_REGISTRY: '0x',
+    REGISTRY: '0x',
+    ENTRY_POINT: '0x',
+    SENDER_CREATOR: '0x',
+    P256VERIFIER: '0x'
+}
+
+export const optimismMainnetFactoryAddresses: Record<string, `0x${string}`> = {
+    DEVICE_WALLET_FACTORY: '0x',
+    ESIM_WALLET_FACTORY: '0x',
+    LAZY_WALLET_REGISTRY: '0x',
+    REGISTRY: '0x',
+    ENTRY_POINT: '0x',
+    SENDER_CREATOR: '0x',
+    P256VERIFIER: '0x'
+}
+
+export const optimismSepoliaFactoryAddresses: Record<string, `0x${string}`> = {
+    DEVICE_WALLET_FACTORY: '0x3feA4dB0C0bBB73142d5bB6b776EE238884a3705',
+    ESIM_WALLET_FACTORY: '0xaD2Ba6248D0e6990a844C94ACE78F8775A68b631',
+    LAZY_WALLET_REGISTRY: '0x29b98C32D83604664fd0742b9112b0825a74849F',
+    REGISTRY: '0xaeB98F0f092fCb4a476ea3a5EB6A4B9E3D63A686',
+    ENTRY_POINT: '0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789',
+    SENDER_CREATOR: '0x7fc98430eaedbb6070b35b39d798725049088348',
+    P256VERIFIER: '0x5349aEA97Faa6D5d6D78A8847068300a4eC9D39E'
+}
+
+export const arbitrumOneFactoryAddresses: Record<string, `0x${string}`> = {
+    DEVICE_WALLET_FACTORY: '0x',
+    ESIM_WALLET_FACTORY: '0x',
+    LAZY_WALLET_REGISTRY: '0x',
+    REGISTRY: '0x',
+    ENTRY_POINT: '0x',
+    SENDER_CREATOR: '0x',
+    P256VERIFIER: '0x'
+}
+
+export const arbitrumSepoliaFactoryAddresses: Record<string, `0x${string}`> = {
+    DEVICE_WALLET_FACTORY: '0x',
+    ESIM_WALLET_FACTORY: '0x',
+    LAZY_WALLET_REGISTRY: '0x',
+    REGISTRY: '0x',
+    ENTRY_POINT: '0x',
+    SENDER_CREATOR: '0x',
+    P256VERIFIER: '0x'
+}
+
+export const customErrors: Record<string, string> = {
+    NULL_OR_UNDEFINED_VALUE: "Error: Null or undefined value provided",
+    MISSING_SMART_WALLET: "Error: Client does not have smart wallet account associated",
+    MISSING_EOA_WALLET: "Error: Client does not have EOA wallet associated"
+}
+
+export const _extractChainID = async (client: WalletClient) => {
+
+    if (!client) {
+        throw "Invalid Signer or Provider instance";
+    }
+    return client.getChainId();
+}
+
+export const _getChainSpecificConstants = (
+    chainID: 
+        CHAIN_ID.SEPOLIA | 
+        CHAIN_ID.MAINNET | 
+        CHAIN_ID.OPTIMISM_MAINNET | 
+        CHAIN_ID.OPTIMISM_SEPOLIA |
+        CHAIN_ID.ARBITRUM_ONE |
+        CHAIN_ID.ARBITRUM_SEPOLIA
+    ): chainSpecifcConstants => {
+
+    if (chainID == CHAIN_ID.SEPOLIA) {
+        return {
+            factoryAddresses: sepoliaFactoryAddresses,
+            chain: sepolia,
+            rpcURL: rpcURLs.sepolia,
+            customErrors: customErrors
+        }
+    }
+    else if (chainID == CHAIN_ID.MAINNET) {
+        return {
+            factoryAddresses: mainnetFactoryAddresses,
+            chain: mainnet,
+            rpcURL: rpcURLs.mainnet,
+            customErrors: customErrors
+        }
+    }
+    else if (chainID == CHAIN_ID.OPTIMISM_MAINNET) {
+        return {
+            factoryAddresses: optimismMainnetFactoryAddresses,
+            chain: optimism,
+            rpcURL: rpcURLs.optimismMainnet,
+            customErrors: customErrors
+        }
+    }
+    else if (chainID == CHAIN_ID.OPTIMISM_SEPOLIA) {
+        return {
+            factoryAddresses: optimismSepoliaFactoryAddresses,
+            chain: optimismSepolia,
+            rpcURL: rpcURLs.optimismSepolia,
+            customErrors: customErrors
+        }
+    }
+    else if (chainID == CHAIN_ID.ARBITRUM_ONE) {
+        return {
+            factoryAddresses: arbitrumOneFactoryAddresses,
+            chain: arbitrum,
+            rpcURL: rpcURLs.arbitrum,
+            customErrors: customErrors
+        }
+    }
+    else {
+        return {
+            factoryAddresses: arbitrumSepoliaFactoryAddresses,
+            chain: arbitrumSepolia,
+            rpcURL: rpcURLs.arbitrumSepolia,
+            customErrors: customErrors
+        }
+    }
+}