kokio-sdk 0.1.2 → 0.1.4

package/dist/esm/logic/account-kit/createSmartAccount.js

@@ -0,0 +1,298 @@
+import { createSmartAccountClient, getEntryPoint, toSmartContractAccount, split, erc7677Middleware } from "@aa-sdk/core";
+import { http, encodeFunctionData, encodePacked, encodeAbiParameters, parseAbiParameters, getContract, concat, keccak256, getContractAddress, getAddress, hashMessage, stringToBytes, toHex, hexToBytes, bytesToHex } from "viem";
+import { _getChainSpecificConstants, ZERO, SIGNATURE_VALIDITY_SECONDS } from "../constants.js";
+import { _remove0x } from "../utils.js";
+import { DeviceWallet, DeviceWalletFactory } from "../../abis/index.js";
+import { isoBase64URL } from "@simplewebauthn/server/helpers";
+import { Passkey } from "react-native-passkey";
+import { p256 } from "@noble/curves/nist.js";
+var AuthenticatorTransport;
+(function (AuthenticatorTransport) {
+    AuthenticatorTransport["usb"] = "usb";
+    AuthenticatorTransport["nfc"] = "nfc";
+    AuthenticatorTransport["ble"] = "ble";
+    AuthenticatorTransport["smartCard"] = "smart-card";
+    AuthenticatorTransport["hybrid"] = "hybrid";
+    AuthenticatorTransport["internal"] = "internal";
+})(AuthenticatorTransport || (AuthenticatorTransport = {}));
+/*
+** Stamp is client-side authentication. Since the passkeys are one the user's mobile device
+** react-native-passkey helps fetch passkey for the user (provided credentialId, rpId).
+** This is exactly how the WebAuthn.sol contract needs it to be.
+*/
+export const _stamp = async (credentialId, rpId, payload) => {
+    const signingOptions = {
+        challenge: isoBase64URL.fromBuffer(hexToBytes(payload)),
+        allowCredentials: [{
+                id: credentialId,
+                type: "public-key",
+                transports: [AuthenticatorTransport.internal]
+            }],
+        rpId,
+        userVerification: "required"
+    };
+    let authenticationResult;
+    try {
+        authenticationResult = await Passkey.get(signingOptions);
+    }
+    catch (e) {
+        console.log("Failed to get authenticationResult");
+        console.error(JSON.stringify(e, Object.getOwnPropertyNames(e)));
+        throw e;
+    }
+    // See https://github.com/f-23/react-native-passkey/issues/54
+    // On Android the typedef lies. Authentication result is actually a string!
+    // TODO: remove me once the above is resolved.
+    const brokenAuthenticationResult = authenticationResult;
+    if (typeof brokenAuthenticationResult === "string") {
+        authenticationResult = JSON.parse(brokenAuthenticationResult);
+    }
+    const { clientDataJSON, authenticatorData, signature } = authenticationResult.response;
+    // 1. Decode clientDataJSON
+    const clientDataJSONBuffer = isoBase64URL.toBuffer(clientDataJSON);
+    const clientDataJSONString = new TextDecoder().decode(clientDataJSONBuffer);
+    // 2. Calculate indices for the contract (byte offsets)
+    const typeSearchString = '"type":"webauthn.get"';
+    const challengeSearchString = '"challenge":';
+    const rawTypeIndex = clientDataJSONString.indexOf(typeSearchString);
+    const challengeIndex = clientDataJSONString.indexOf(challengeSearchString);
+    let typeIndex = rawTypeIndex;
+    if (rawTypeIndex === -1) {
+        console.warn("typeIndex not found", {
+            expected: typeSearchString,
+            clientDataSnippet: clientDataJSONString.slice(0, 200),
+        });
+        typeIndex = 0;
+    }
+    if (challengeIndex === -1) {
+        throw new Error(`Could not find challenge substring '${challengeSearchString}' in clientDataJSON for index calculation.`);
+    }
+    // 3. Decode authenticatorData
+    const authenticatorDataBytes = isoBase64URL.toBuffer(authenticatorData);
+    const authenticatorDataHex = bytesToHex(authenticatorDataBytes);
+    // 4. Decode signature (ASN.1 DER encoded)
+    const signatureBytes = isoBase64URL.toBuffer(signature);
+    // let parsedSignature = p256.Signature.fromDER(signatureBytes);
+    let parsedSignature = p256.Signature.fromBytes(signatureBytes instanceof Uint8Array
+        ? signatureBytes
+        : new Uint8Array(signatureBytes), "der");
+    // Normalize s
+    const n = p256.Point.CURVE().n;
+    const halfN = n >> 1n;
+    const r = parsedSignature.r;
+    const s = parsedSignature.s > halfN
+        ? n - parsedSignature.s
+        : parsedSignature.s;
+    const webAuthnSig = {
+        authenticatorData: authenticatorDataHex,
+        clientDataJSON: clientDataJSONString,
+        challengeIndex: BigInt(challengeIndex),
+        typeIndex: BigInt(typeIndex),
+        r: r,
+        s: s
+    };
+    return webAuthnSig;
+};
+const _encodeExecute = async (tx) => {
+    return encodeFunctionData({
+        abi: DeviceWallet,
+        functionName: "execute",
+        args: [{
+                dest: tx.target,
+                value: tx.value ?? ZERO,
+                data: tx.data
+            }]
+    });
+};
+const _encodeBatchExecute = async (txs) => {
+    const new_txs = [];
+    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, deviceUniqueIdentifier, deviceWalletOwnerKey, salt) => {
+    // To send with user operations
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    const callData = encodeFunctionData({
+        abi: DeviceWalletFactory,
+        functionName: "createAccount",
+        args: [deviceUniqueIdentifier, deviceWalletOwnerKey, salt],
+    });
+    return values.factoryAddresses.DEVICE_WALLET_FACTORY.concat(_remove0x(callData));
+};
+const getInitCodeHash = async (client, deviceUniqueIdentifier, deviceWalletOwnerKey) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    // off-chain computation of the DeviceWallet address
+    const registry = values.factoryAddresses.REGISTRY;
+    const deviceWalletFactoryAddress = values.factoryAddresses.DEVICE_WALLET_FACTORY;
+    const eSIMWalletFactoryAddress = values.factoryAddresses.ESIM_WALLET_FACTORY;
+    const deviceWalletFactory = getContract({
+        abi: DeviceWalletFactory,
+        address: deviceWalletFactoryAddress,
+        client
+    });
+    const beacon = await deviceWalletFactory.read.beacon([]);
+    // Encode the DeviceWallet.init with the init params
+    const deviceWalletInitData = encodeFunctionData({
+        abi: DeviceWallet,
+        functionName: "init",
+        args: [
+            registry,
+            deviceWalletOwnerKey,
+            deviceUniqueIdentifier,
+            eSIMWalletFactoryAddress
+        ]
+    });
+    const beaconProxyBytecode = "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";
+    // Encode BeaconProxy constructor args
+    const beaconProxyConstructorArgs = encodeAbiParameters(parseAbiParameters("address, bytes"), [beacon, deviceWalletInitData]);
+    // Compute initCode
+    const initCode = concat([beaconProxyBytecode, beaconProxyConstructorArgs]);
+    return keccak256(initCode);
+};
+const getCounterFactualAddress = async (client, deviceUniqueIdentifier, deviceWalletOwnerKey, salt) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    const deviceWalletFactoryAddress = values.factoryAddresses.DEVICE_WALLET_FACTORY;
+    const uniqueSaltBytes32 = toHex(salt, { size: 32 });
+    const initCodeHash = await getInitCodeHash(client, deviceUniqueIdentifier, deviceWalletOwnerKey);
+    // Calculate deterministic address from init code hash
+    const create2Address = getContractAddress({
+        from: deviceWalletFactoryAddress,
+        salt: uniqueSaltBytes32,
+        bytecodeHash: initCodeHash,
+        opcode: "CREATE2",
+    });
+    return getAddress(create2Address);
+};
+const _encodeSignature = async (webAuthnSignature, validUntil) => {
+    const encodedWebAuthnSignatureBytes = encodeAbiParameters([
+        {
+            type: "tuple",
+            name: "WebAuthnSignature",
+            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", },
+            ],
+        },
+    ], [
+        webAuthnSignature
+    ]);
+    const signature = encodePacked(["uint8", "uint48", "bytes"], [1, validUntil, encodedWebAuthnSignatureBytes]);
+    return signature;
+};
+// message here is the original message data (string or Uint8Array) directly from the app
+const _signMessage = async (message, credentialId, rpId) => {
+    const validUntil = Math.floor(Date.now() / 1000) + SIGNATURE_VALIDITY_SECONDS;
+    const payload = hashMessage({ raw: stringToBytes(message) });
+    // The original message is passed to the stamp and sign function.
+    // The stamp and sign function creates the EIP-191 digest hash using its hashMessage function
+    // The result of the hashMessage(message) will be the `payload` used as a challenge
+    const webAuthnSignature = await _stamp(credentialId, rpId, payload);
+    return _encodeSignature(webAuthnSignature, validUntil);
+};
+const _signTypedData = async (typedData, organiationId, signWith) => {
+    // signature valid until, UNIX timestamp in seconds
+    const validUntil = Math.floor(Date.now() / 1000) + SIGNATURE_VALIDITY_SECONDS;
+    // TODO: Implement stamping for Typed Data
+    let webAuthnSignature = {
+        authenticatorData: `0x`,
+        clientDataJSON: "",
+        challengeIndex: BigInt(0),
+        typeIndex: BigInt(0),
+        r: BigInt(0),
+        s: BigInt(0)
+    };
+    return _encodeSignature(webAuthnSignature, validUntil);
+};
+const _signUserOperationHash = async (credentialId, rpId, userOpHash) => {
+    const validUntil = Math.floor(Date.now() / 1000) + SIGNATURE_VALIDITY_SECONDS;
+    const messagePrecursor = encodePacked(["uint8", "uint48", "bytes32"], [
+        1,
+        validUntil,
+        userOpHash
+    ]);
+    const payload = hashMessage({ raw: messagePrecursor });
+    const webAuthnSignature = await _stamp(credentialId, rpId, payload);
+    return _encodeSignature(webAuthnSignature, validUntil);
+};
+export const _getSmartWallet = async (client, credentialId, rpId, organiationId, deviceUniqueIdentifier, deviceWalletOwnerKey, salt) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL);
+    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, { version: "0.7.0" }),
+        getAccountInitCode: async () => 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 () => "0x",
+        // given a UO in the form of {target, data, value} should output the calldata for calling your contract's execution method
+        encodeExecute: async (uo) => _encodeExecute(uo),
+        signMessage: async ({ message }) => _signMessage(message, credentialId, rpId),
+        signTypedData: async (typedData) => _signTypedData(typedData, 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),
+        // 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) => _encodeBatchExecute(uos),
+        // if your contract expects a different signing scheme than the default signMessage scheme, you can override that here
+        signUserOperationHash: async (hash) => _signUserOperationHash(credentialId, rpId, hash),
+        // allows you to define the calldata for upgrading your account
+        // encodeUpgradeToAndCall: async (params): Promise<Hash> => "0x...",
+    });
+};
+export const _getSmartWalletClient = async (client, pimlicoAPIKey, gasPolicyId, account) => {
+    const chainID = await client.getChainId();
+    const rpcURL = client.transport.url;
+    const values = _getChainSpecificConstants(chainID, rpcURL, pimlicoAPIKey);
+    const bundlerMethods = [
+        "eth_sendUserOperation",
+        "eth_estimateUserOperationGas",
+        "eth_getUserOperationReceipt",
+        "eth_getUserOperationByHash",
+        "eth_supportedEntryPoints",
+    ];
+    // Uses Pimlico paymaster by default for above defined bundler methods and Alchemy as fallback
+    return createSmartAccountClient({
+        // created above
+        account: account,
+        chain: values.chain,
+        transport: split({
+            overrides: [
+                {
+                    methods: bundlerMethods,
+                    transport: http(`${values.pimlicoRpcURL}`),
+                },
+            ],
+            fallback: http(values.rpcURL),
+        }),
+        // transport: http(values.rpcURL),
+        ...erc7677Middleware({ context: { policyId: gasPolicyId } })
+    });
+};

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

@@ -1,55 +1,18 @@
-import { WalletClient, Address } from 'viem';
-import {
-    mainnet,
-    sepolia,
-    optimism,
-    optimismSepolia,
-    arbitrum,
-    arbitrumSepolia,
-    base,
-    baseSepolia
-} from "viem/chains";
-
+import { mainnet, sepolia, optimism, optimismSepolia, arbitrum, arbitrumSepolia, base, baseSepolia } from "viem/chains";
 export const ZERO = BigInt('0');
-
 export const SIGNATURE_VALIDITY_SECONDS = 180; // 3 minutes validity
-
-export enum CHAIN_ID  {
-    MAINNET = 1,
-    SEPOLIA = 11155111,
-    OPTIMISM_MAINNET = 10,
-    OPTIMISM_SEPOLIA = 11155420,
-    BASE_MAINNET = 8453,
-    BASE_SEPOLIA = 84532,
-    ARBITRUM_ONE = 42161,
-    ARBITRUM_SEPOLIA = 421614,
-}
-
-export interface chainSpecifcConstants {
-    factoryAddresses: 
-        typeof sepoliaFactoryAddresses |
-        typeof mainnetFactoryAddresses |
-        typeof optimismMainnetFactoryAddresses |
-        typeof optimismSepoliaFactoryAddresses |
-        typeof baseMainnetFactoryAddresses |
-        typeof baseSepoliaFactoryAddresses |
-        typeof arbitrumOneFactoryAddresses |
-        typeof arbitrumSepoliaFactoryAddresses;
-    chain: 
-        typeof mainnet |
-        typeof sepolia |
-        typeof optimism |
-        typeof optimismSepolia |
-        typeof base |
-        typeof baseSepolia |
-        typeof arbitrum |
-        typeof arbitrumSepolia
-    rpcURL: string;
-    pimlicoRpcURL: string;
-    customErrors: typeof customErrors;
-}
-
-export const sepoliaFactoryAddresses: Record<string, Address> = {
+export var CHAIN_ID;
+(function (CHAIN_ID) {
+    CHAIN_ID[CHAIN_ID["MAINNET"] = 1] = "MAINNET";
+    CHAIN_ID[CHAIN_ID["SEPOLIA"] = 11155111] = "SEPOLIA";
+    CHAIN_ID[CHAIN_ID["OPTIMISM_MAINNET"] = 10] = "OPTIMISM_MAINNET";
+    CHAIN_ID[CHAIN_ID["OPTIMISM_SEPOLIA"] = 11155420] = "OPTIMISM_SEPOLIA";
+    CHAIN_ID[CHAIN_ID["BASE_MAINNET"] = 8453] = "BASE_MAINNET";
+    CHAIN_ID[CHAIN_ID["BASE_SEPOLIA"] = 84532] = "BASE_SEPOLIA";
+    CHAIN_ID[CHAIN_ID["ARBITRUM_ONE"] = 42161] = "ARBITRUM_ONE";
+    CHAIN_ID[CHAIN_ID["ARBITRUM_SEPOLIA"] = 421614] = "ARBITRUM_SEPOLIA";
+})(CHAIN_ID || (CHAIN_ID = {}));
+export const sepoliaFactoryAddresses = {
     DEVICE_WALLET_FACTORY: '0x63005d8214533fC7209678Aa39F7b9b0b51a7bcB',
     ESIM_WALLET_FACTORY: '0xB4473979ff8cE4e09161B08f74EEb66BD7718076',
     LAZY_WALLET_REGISTRY: '0x8a1E53b903efcc6b252CE4bD3b255202318505Ef',
@@ -57,9 +20,8 @@ export const sepoliaFactoryAddresses: Record<string, Address> = {
     ENTRY_POINT: '0x0000000071727De22E5E9d8BAf0edAc6f37da032',
     SENDER_CREATOR: '0xefc2c1444ebcc4db75e7613d20c6a62ff67a167c',
     P256VERIFIER: '0xF04f3b3935aD461D17d4a8a78E7ea21d4a61AEb1'
-}
-
-export const mainnetFactoryAddresses: Record<string, Address> = {
+};
+export const mainnetFactoryAddresses = {
     DEVICE_WALLET_FACTORY: '0x',
     ESIM_WALLET_FACTORY: '0x',
     LAZY_WALLET_REGISTRY: '0x',
@@ -67,9 +29,8 @@ export const mainnetFactoryAddresses: Record<string, Address> = {
     ENTRY_POINT: '0x',
     SENDER_CREATOR: '0x',
     P256VERIFIER: '0x'
-}
-
-export const optimismMainnetFactoryAddresses: Record<string, Address> = {
+};
+export const optimismMainnetFactoryAddresses = {
     DEVICE_WALLET_FACTORY: '0x',
     ESIM_WALLET_FACTORY: '0x',
     LAZY_WALLET_REGISTRY: '0x',
@@ -77,9 +38,8 @@ export const optimismMainnetFactoryAddresses: Record<string, Address> = {
     ENTRY_POINT: '0x',
     SENDER_CREATOR: '0x',
     P256VERIFIER: '0x'
-}
-
-export const optimismSepoliaFactoryAddresses: Record<string, Address> = {
+};
+export const optimismSepoliaFactoryAddresses = {
     DEVICE_WALLET_FACTORY: '0x243cCdE6a56b0Ba740E067f39896772748E20fFD',
     ESIM_WALLET_FACTORY: '0x8444bF9C39F01e4B092e42DC11695C61f8B93957',
     LAZY_WALLET_REGISTRY: '0x3F14D060074B174B0784056bDe5e0f8970D25ff1',
@@ -87,9 +47,8 @@ export const optimismSepoliaFactoryAddresses: Record<string, Address> = {
     ENTRY_POINT: '0x0000000071727De22E5E9d8BAf0edAc6f37da032',
     SENDER_CREATOR: '0xefc2c1444ebcc4db75e7613d20c6a62ff67a167c',
     P256VERIFIER: '0x3c15a78046838481788613A9F111F972B562623C'
-}
-
-export const baseMainnetFactoryAddresses: Record<string, Address> = {
+};
+export const baseMainnetFactoryAddresses = {
     DEVICE_WALLET_FACTORY: '0x',
     ESIM_WALLET_FACTORY: '0x',
     LAZY_WALLET_REGISTRY: '0x',
@@ -97,9 +56,8 @@ export const baseMainnetFactoryAddresses: Record<string, Address> = {
     ENTRY_POINT: '0x',
     SENDER_CREATOR: '0x',
     P256VERIFIER: '0x'
-}
-
-export const baseSepoliaFactoryAddresses: Record<string, Address> = {
+};
+export const baseSepoliaFactoryAddresses = {
     DEVICE_WALLET_FACTORY: '0xB4473979ff8cE4e09161B08f74EEb66BD7718076',
     ESIM_WALLET_FACTORY: '0x63005d8214533fC7209678Aa39F7b9b0b51a7bcB',
     LAZY_WALLET_REGISTRY: '0x8a1E53b903efcc6b252CE4bD3b255202318505Ef',
@@ -107,9 +65,8 @@ export const baseSepoliaFactoryAddresses: Record<string, Address> = {
     ENTRY_POINT: '0x0000000071727De22E5E9d8BAf0edAc6f37da032',
     SENDER_CREATOR: '0xefc2c1444ebcc4db75e7613d20c6a62ff67a167c',
     P256VERIFIER: '0xF04f3b3935aD461D17d4a8a78E7ea21d4a61AEb1'
-}
-
-export const arbitrumOneFactoryAddresses: Record<string, Address> = {
+};
+export const arbitrumOneFactoryAddresses = {
     DEVICE_WALLET_FACTORY: '0x',
     ESIM_WALLET_FACTORY: '0x',
     LAZY_WALLET_REGISTRY: '0x',
@@ -117,9 +74,8 @@ export const arbitrumOneFactoryAddresses: Record<string, Address> = {
     ENTRY_POINT: '0x',
     SENDER_CREATOR: '0x',
     P256VERIFIER: '0x'
-}
-
-export const arbitrumSepoliaFactoryAddresses: Record<string, Address> = {
+};
+export const arbitrumSepoliaFactoryAddresses = {
     DEVICE_WALLET_FACTORY: '0x',
     ESIM_WALLET_FACTORY: '0x',
     LAZY_WALLET_REGISTRY: '0x',
@@ -127,36 +83,19 @@ export const arbitrumSepoliaFactoryAddresses: Record<string, Address> = {
     ENTRY_POINT: '0x',
     SENDER_CREATOR: '0x',
     P256VERIFIER: '0x'
-}
-
-export const customErrors: Record<string, string> = {
+};
+export const customErrors = {
     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) => {
-
+};
+export const _extractChainID = async (client) => {
     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.BASE_MAINNET | 
-        CHAIN_ID.BASE_SEPOLIA |
-        CHAIN_ID.ARBITRUM_ONE |
-        CHAIN_ID.ARBITRUM_SEPOLIA,
-    rpcURL: string,
-    pimlicoAPIKey?: string
-    ): chainSpecifcConstants => {
-
+};
+export const _getChainSpecificConstants = (chainID, rpcURL, pimlicoAPIKey) => {
     if (chainID == CHAIN_ID.SEPOLIA) {
         return {
             factoryAddresses: sepoliaFactoryAddresses,
@@ -164,7 +103,7 @@ export const _getChainSpecificConstants = (
             rpcURL: rpcURL,
             pimlicoRpcURL: pimlicoAPIKey ? `https://api.pimlico.io/v2/${chainID}/rpc?apikey=${pimlicoAPIKey}` : "",
             customErrors: customErrors
-        }
+        };
     }
     else if (chainID == CHAIN_ID.MAINNET) {
         return {
@@ -173,7 +112,7 @@ export const _getChainSpecificConstants = (
             rpcURL: rpcURL,
             pimlicoRpcURL: pimlicoAPIKey ? `https://api.pimlico.io/v2/${chainID}/rpc?apikey=${pimlicoAPIKey}` : "",
             customErrors: customErrors
-        }
+        };
     }
     else if (chainID == CHAIN_ID.OPTIMISM_MAINNET) {
         return {
@@ -182,7 +121,7 @@ export const _getChainSpecificConstants = (
             rpcURL: rpcURL,
             pimlicoRpcURL: pimlicoAPIKey ? `https://api.pimlico.io/v2/${chainID}/rpc?apikey=${pimlicoAPIKey}` : "",
             customErrors: customErrors
-        }
+        };
     }
     else if (chainID == CHAIN_ID.OPTIMISM_SEPOLIA) {
         return {
@@ -191,7 +130,7 @@ export const _getChainSpecificConstants = (
             rpcURL: rpcURL,
             pimlicoRpcURL: pimlicoAPIKey ? `https://api.pimlico.io/v2/${chainID}/rpc?apikey=${pimlicoAPIKey}` : "",
             customErrors: customErrors
-        }
+        };
     }
     else if (chainID == CHAIN_ID.BASE_MAINNET) {
         return {
@@ -200,7 +139,7 @@ export const _getChainSpecificConstants = (
             rpcURL: rpcURL,
             pimlicoRpcURL: pimlicoAPIKey ? `https://api.pimlico.io/v2/${chainID}/rpc?apikey=${pimlicoAPIKey}` : "",
             customErrors: customErrors
-        }
+        };
     }
     else if (chainID == CHAIN_ID.BASE_SEPOLIA) {
         return {
@@ -209,7 +148,7 @@ export const _getChainSpecificConstants = (
             rpcURL: rpcURL,
             pimlicoRpcURL: pimlicoAPIKey ? `https://api.pimlico.io/v2/${chainID}/rpc?apikey=${pimlicoAPIKey}` : "",
             customErrors: customErrors
-        }
+        };
     }
     else if (chainID == CHAIN_ID.ARBITRUM_ONE) {
         return {
@@ -218,7 +157,7 @@ export const _getChainSpecificConstants = (
             rpcURL: rpcURL,
             pimlicoRpcURL: pimlicoAPIKey ? `https://api.pimlico.io/v2/${chainID}/rpc?apikey=${pimlicoAPIKey}` : "",
             customErrors: customErrors
-        }
+        };
     }
     else {
         return {
@@ -227,6 +166,6 @@ export const _getChainSpecificConstants = (
             rpcURL: rpcURL,
             pimlicoRpcURL: pimlicoAPIKey ? `https://api.pimlico.io/v2/${chainID}/rpc?apikey=${pimlicoAPIKey}` : "",
             customErrors: customErrors
-        }
+        };
     }
-}
+};