@web3auth/no-modal 10.0.0-alpha.0 → 10.0.0-alpha.1

package/dist/types/providers/solana-provider/interface.d.ts

@@ -1,39 +1,22 @@
 import type { Transaction, VersionedTransaction } from "@solana/web3.js";
-import BN from "bn.js";
 import { RequestArguments } from "../../base";
-import { InjectedProvider } from "./providers";
 export type TransactionOrVersionedTransaction = Transaction | VersionedTransaction;
 export interface ISolanaWallet {
     publicKey?: {
         toBytes(): Uint8Array;
     };
-    signAndSendTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<{
-        signature: string;
-    }>;
-    signTransaction?<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<T>;
-    signAllTransactions?<T extends TransactionOrVersionedTransaction>(transactions: T[]): Promise<T[]>;
-    signMessage(message: Uint8Array, display?: string): Promise<Uint8Array>;
+    signAndSendTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<string>;
+    signTransaction?<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<string>;
+    signAllTransactions?<T extends TransactionOrVersionedTransaction>(transactions: T[]): Promise<string[]>;
+    signMessage(message: string, pubKey: string): Promise<string>;
     request<T, U>(args: RequestArguments<T>): Promise<U>;
 }
 export interface IBaseWalletProvider {
     publicKey?: {
         toBytes(): Uint8Array;
     };
-    signMessage?(message: Uint8Array, display?: "hex" | "utf8"): Promise<{
-        signature: Uint8Array;
-        publicKey: BN;
-    }>;
-    signTransaction?<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<T>;
-    signAllTransactions?<T extends TransactionOrVersionedTransaction>(transactions: T[]): Promise<T[]>;
-    signAndSendTransaction?<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<{
-        signature: string;
-    }>;
-}
-export interface ITorusWalletProvider extends InjectedProvider {
-    sendTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<string>;
-    signTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<T>;
-    signAllTransactions<T extends TransactionOrVersionedTransaction>(transactions: T[]): Promise<T[]>;
-    signMessage(data: Uint8Array): Promise<Uint8Array>;
-}
-export interface IWalletStandardProviderHandler extends IBaseWalletProvider {
+    signMessage?(message: string, pubKey: string, display?: "hex" | "utf8"): Promise<string>;
+    signTransaction?(transaction: string): Promise<string>;
+    signAllTransactions?(transactions: string[]): Promise<string[]>;
+    signAndSendTransaction?(transaction: string): Promise<string>;
 }

package/dist/types/providers/solana-provider/providers/injectedProviders/base/baseInjectedProvider.d.ts

@@ -9,8 +9,8 @@ export declare abstract class BaseInjectedProvider<P> extends BaseProvider<BaseP
     switchChain(_: {
         chainId: string;
     }): Promise<void>;
-    setupProvider(injectedProvider: P): Promise<void>;
-    protected lookupNetwork(): Promise<string>;
+    setupProvider(injectedProvider: P, chainId: string): Promise<void>;
+    protected lookupNetwork(_injectedProvider: P, chainId: string): Promise<string>;
     protected getInjectedProviderProxy(_: P): JRPCMiddleware<unknown, unknown>;
     protected abstract getProviderHandlers(injectedProvider: P): ISolanaProviderHandlers;
 }

package/dist/types/providers/solana-provider/providers/injectedProviders/index.d.ts

@@ -1,3 +1,2 @@
-export * from "./interface";
-export * from "./torus/torusInjectedProvider";
+export * from "./utils";
 export * from "./walletStandardProvider";

package/dist/types/providers/solana-provider/providers/injectedProviders/utils.d.ts

@@ -0,0 +1,3 @@
+import { IdentifierString } from "@wallet-standard/base";
+import { CustomChainConfig } from "../../../../base";
+export declare const getSolanaChainByChainConfig: (chainConfig: CustomChainConfig) => IdentifierString;

package/dist/types/providers/solana-provider/providers/injectedProviders/walletStandardProvider.d.ts

@@ -1,6 +1,9 @@
-import { IWalletStandardProviderHandler } from "../../interface";
-import { ISolanaProviderHandlers } from "../../rpc";
+import { type SolanaSignAndSendTransactionFeature, type SolanaSignMessageFeature, type SolanaSignTransactionFeature } from "@solana/wallet-standard-features";
+import { type WalletWithFeatures } from "@wallet-standard/base";
+import { type StandardConnectFeature, type StandardDisconnectFeature, type StandardEventsFeature } from "@wallet-standard/features";
+import { type ISolanaProviderHandlers } from "../../rpc";
 import { BaseInjectedProvider } from "./base/baseInjectedProvider";
-export declare class WalletStandardProvider extends BaseInjectedProvider<IWalletStandardProviderHandler> {
-    protected getProviderHandlers(injectedProvider: IWalletStandardProviderHandler): ISolanaProviderHandlers;
+export type WalletStandard = WalletWithFeatures<StandardConnectFeature & StandardEventsFeature & StandardDisconnectFeature & SolanaSignAndSendTransactionFeature & SolanaSignMessageFeature & SolanaSignTransactionFeature>;
+export declare class WalletStandardProvider extends BaseInjectedProvider<WalletStandard> {
+    protected getProviderHandlers(wallet: WalletStandard): ISolanaProviderHandlers;
 }

package/dist/types/providers/solana-provider/providers/privateKeyProvider/solanaPrivateKeyProvider.d.ts

@@ -1,7 +1,6 @@
 import { CustomChainConfig } from "../../../../base";
 import { BaseProvider, BaseProviderConfig, BaseProviderState } from "../../../base-provider";
 export interface SolanaPrivKeyProviderConfig extends BaseProviderConfig {
-    chainConfig: CustomChainConfig;
 }
 export interface SolanaPrivKeyProviderState extends BaseProviderState {
     privateKey?: string;
@@ -14,18 +13,19 @@ export declare class SolanaPrivateKeyProvider extends BaseProvider<BaseProviderC
     });
     static getProviderInstance: (params: {
         privKey: string;
-        chainConfig: CustomChainConfig;
+        chain: CustomChainConfig;
+        chains: CustomChainConfig[];
     }) => Promise<SolanaPrivateKeyProvider>;
     enable(): Promise<string[]>;
     getEd25519Key(privateKey: string): string;
-    setupProvider(privKey: string): Promise<void>;
+    setupProvider(privKey: string, chainId: string): Promise<void>;
     updateAccount(params: {
         privateKey: string;
     }): Promise<void>;
     switchChain(params: {
         chainId: string;
     }): Promise<void>;
-    protected lookupNetwork(): Promise<string>;
+    protected lookupNetwork(chainId: string): Promise<void>;
     private getChainSwitchMiddleware;
     private getAccountMiddleware;
 }

package/dist/types/providers/solana-provider/rpc/interfaces.d.ts

@@ -1,19 +1,5 @@
 import { JRPCRequest } from "@web3auth/auth";
-import { TransactionOrVersionedTransaction } from "../interface";
-export interface AddSolanaChainParameter {
-    chainId: string;
-    chainName: string;
-    nativeCurrency: {
-        name: string;
-        symbol: string;
-        decimals: 18;
-    };
-    rpcUrls: string[];
-    blockExplorerUrls?: string[];
-    iconUrls?: string[];
-}
 export interface ISolanaChainSwitchHandlers {
-    addNewChainConfig: (req: JRPCRequest<AddSolanaChainParameter>) => Promise<void>;
     switchSolanaChain: (req: JRPCRequest<{
         chainId: string;
     }>) => Promise<void>;
@@ -23,20 +9,19 @@ export interface ISolanaProviderHandlers {
     getAccounts: (req: JRPCRequest<unknown>) => Promise<string[]>;
     getPublicKey: (req: JRPCRequest<unknown>) => Promise<string>;
     getPrivateKey: (req: JRPCRequest<unknown>) => Promise<string>;
-    signTransaction: (req: JRPCRequest<{
-        message: TransactionOrVersionedTransaction;
-    }>) => Promise<TransactionOrVersionedTransaction>;
-    signAllTransactions: (req: JRPCRequest<{
-        message: TransactionOrVersionedTransaction[];
-    }>) => Promise<TransactionOrVersionedTransaction[]>;
-    signAndSendTransaction: (req: JRPCRequest<{
-        message: TransactionOrVersionedTransaction;
-    }>) => Promise<{
-        signature: string;
-    }>;
     getSecretKey: (req: JRPCRequest<unknown>) => Promise<string>;
     signMessage: (req: JRPCRequest<{
-        message: Uint8Array;
+        data: string;
+        from: string;
         display?: string;
-    }>) => Promise<Uint8Array>;
+    }>) => Promise<string>;
+    signTransaction: (req: JRPCRequest<{
+        message: string;
+    }>) => Promise<string>;
+    signAllTransactions: (req: JRPCRequest<{
+        message: string[];
+    }>) => Promise<string[]>;
+    signAndSendTransaction: (req: JRPCRequest<{
+        message: string;
+    }>) => Promise<string>;
 }

package/dist/types/providers/solana-provider/rpc/solanaRpcMiddlewares.d.ts

@@ -11,7 +11,7 @@ export declare function createRequestAccountsMiddleware({ requestAccounts, }: {
 }): JRPCMiddleware<unknown, unknown>;
 export declare function createGenericJRPCMiddleware<T, U>(targetMethod: string, handler: (req: JRPCRequest<T>) => Promise<U>): JRPCMiddleware<T, U>;
 export declare function createSolanaMiddleware(providerHandlers: ISolanaProviderHandlers): JRPCMiddleware<unknown, unknown>;
-export declare function createSolanaChainSwitchMiddleware({ addNewChainConfig, switchSolanaChain, }: ISolanaChainSwitchHandlers): JRPCMiddleware<unknown, unknown>;
+export declare function createSolanaChainSwitchMiddleware({ switchSolanaChain }: ISolanaChainSwitchHandlers): JRPCMiddleware<unknown, unknown>;
 export interface ISolanaAccountHandlers {
     updatePrivatekey: (req: JRPCRequest<{
         privateKey: string;

package/dist/types/providers/solana-provider/solanaWallet.d.ts

@@ -1,14 +1,28 @@
 import { IProvider, RequestArguments } from "../../base";
-import { ISolanaWallet, TransactionOrVersionedTransaction } from "./interface";
+import { ISolanaWallet, type TransactionOrVersionedTransaction } from "./interface";
 export declare class SolanaWallet implements ISolanaWallet {
     provider: IProvider;
     constructor(provider: IProvider);
     requestAccounts(): Promise<string[]>;
-    signAndSendTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<{
-        signature: string;
-    }>;
-    signTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<T>;
-    signAllTransactions<T extends TransactionOrVersionedTransaction>(transactions: T[]): Promise<T[]>;
-    signMessage(data: Uint8Array): Promise<Uint8Array>;
+    signAndSendTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<string>;
+    /**
+     * Signs a transaction and returns the signature
+     * @param transaction - The transaction to sign
+     * @returns The signature of the transaction encoded in base58
+     */
+    signTransaction<T extends TransactionOrVersionedTransaction>(transaction: T): Promise<string>;
+    /**
+     * Signs multiple transactions and returns the serialized transactions
+     * @param transactions - The transactions to sign
+     * @returns The serialized transactions encoded in base64
+     */
+    signAllTransactions<T extends TransactionOrVersionedTransaction>(transactions: T[]): Promise<string[]>;
+    /**
+     * Signs a message and returns the signature
+     * @param message - The message to sign
+     * @returns The signature of the message encoded in base58
+     */
+    signMessage(message: string, pubKey: string): Promise<string>;
     request<T, U>(args: RequestArguments<T>): Promise<U>;
+    private serializeTransaction;
 }

package/dist/types/providers/xrpl-provider/providers/privateKeyProviders/xrplPrivateKeyProvider.d.ts

@@ -1,7 +1,6 @@
 import { CustomChainConfig } from "../../../../base";
 import { BaseProvider, BaseProviderConfig, BaseProviderState } from "../../../base-provider";
 export interface XrplPrivKeyProviderConfig extends BaseProviderConfig {
-    chainConfig: CustomChainConfig & Pick<CustomChainConfig, "wsTarget">;
 }
 export interface XrplPrivKeyProviderState extends BaseProviderState {
     privateKey?: string;
@@ -14,13 +13,14 @@ export declare class XrplPrivateKeyProvider extends BaseProvider<BaseProviderCon
     });
     static getProviderInstance: (params: {
         privKey: string;
-        chainConfig: CustomChainConfig;
+        chain: CustomChainConfig;
+        chains: CustomChainConfig[];
     }) => Promise<XrplPrivateKeyProvider>;
     enable(): Promise<string[]>;
-    setupProvider(privKey: string): Promise<void>;
+    setupProvider(privKey: string, chainId: string): Promise<void>;
     switchChain(params: {
         chainId: string;
     }): Promise<void>;
-    protected lookupNetwork(): Promise<void>;
+    protected lookupNetwork(_privKey: string, chainId: string): Promise<void>;
     private getChainSwitchMiddleware;
 }

package/dist/types/providers/xrpl-provider/rpc/xrplRpcMiddlewares.d.ts

@@ -1,6 +1,5 @@
 import { JRPCMiddleware, JRPCRequest } from "@web3auth/auth";
 import type { SubmitResponse, Transaction } from "xrpl";
-import { CustomChainConfig } from "../../../base";
 export declare const RPC_METHODS: {
     GET_ACCOUNTS: string;
     GET_KEY_PAIR: string;
@@ -42,11 +41,9 @@ export declare function createGetAccountsMiddleware({ getAccounts, }: {
 }): JRPCMiddleware<unknown, unknown>;
 export declare function createGenericJRPCMiddleware<T, U>(targetMethod: string, handler: (req: JRPCRequest<T>) => Promise<U>): JRPCMiddleware<T, unknown>;
 export declare function createXRPLMiddleware(providerHandlers: IXrplProviderHandlers): JRPCMiddleware<unknown, unknown>;
-export type AddXRPLChainParameter = CustomChainConfig & Pick<CustomChainConfig, "wsTarget">;
 export interface IXrplChainSwitchHandlers {
-    addChainConfig: (req: JRPCRequest<AddXRPLChainParameter>) => Promise<void>;
     switchChain: (req: JRPCRequest<{
         chainId: string;
     }>) => Promise<void>;
 }
-export declare function creatXrplChainSwitchMiddleware({ addChainConfig, switchChain }: IXrplChainSwitchHandlers): JRPCMiddleware<unknown, unknown>;
+export declare function creatXrplChainSwitchMiddleware({ switchChain }: IXrplChainSwitchHandlers): JRPCMiddleware<unknown, unknown>;

package/dist/types/react/no-modal/interfaces.d.ts

@@ -1,15 +1,15 @@
-import type { IAdapter, IBaseWeb3AuthHookContext, IPlugin, IProvider, IWeb3AuthCoreOptions, WALLET_ADAPTER_TYPE } from "../../base";
+import type { ConnectorFn, IBaseWeb3AuthHookContext, IProvider, IWeb3AuthCoreOptions, PluginFn, WALLET_CONNECTOR_TYPE } from "../../base";
 import { Web3AuthNoModal } from "../../noModal";
 export type Web3AuthContextConfig = {
     web3AuthOptions: IWeb3AuthCoreOptions;
-    adapters?: IAdapter<unknown>[];
-    plugins?: IPlugin[];
+    connectors?: ConnectorFn[];
+    plugins?: PluginFn[];
 };
 export interface Web3AuthProviderProps {
     config: Web3AuthContextConfig;
 }
 export interface IWeb3AuthInnerContext extends IBaseWeb3AuthHookContext {
     web3Auth: Web3AuthNoModal | null;
-    connectTo<T>(walletName: WALLET_ADAPTER_TYPE, loginParams?: T): Promise<IProvider | null>;
+    connectTo<T>(walletName: WALLET_CONNECTOR_TYPE, loginParams?: T): Promise<IProvider | null>;
 }
 export type IWeb3AuthContext = IWeb3AuthInnerContext;

package/dist/types/react/wallet-services-plugin/interfaces.d.ts

@@ -1,5 +1,5 @@
 import type { IBaseWalletServicesHookContext } from "../../base";
-import type { WalletServicesPlugin } from "../../plugins/wallet-services-plugin";
+import type { WalletServicesPluginType } from "../../plugins/wallet-services-plugin";
 export interface IWalletServicesContext extends IBaseWalletServicesHookContext {
-    plugin: WalletServicesPlugin | null;
+    plugin: WalletServicesPluginType | null;
 }

package/dist/types/vue/no-modal/interfaces.d.ts

@@ -1,11 +1,11 @@
 import type { AuthUserInfo, LoginParams } from "@web3auth/auth";
 import type { Ref, ShallowRef } from "vue";
-import type { ADAPTER_STATUS_TYPE, CustomChainConfig, IAdapter, IPlugin, IProvider, IWeb3AuthCoreOptions, UserAuthInfo, WALLET_ADAPTER_TYPE } from "../../base";
+import type { CONNECTOR_STATUS_TYPE, ConnectorFn, IPlugin, IProvider, IWeb3AuthCoreOptions, PluginFn, UserAuthInfo, WALLET_CONNECTOR_TYPE } from "../../base";
 import { type Web3AuthNoModal } from "../../noModal";
 export type Web3AuthContextConfig = {
     web3AuthOptions: IWeb3AuthCoreOptions;
-    adapters?: IAdapter<unknown>[];
-    plugins?: IPlugin[];
+    connectors?: ConnectorFn[];
+    plugins?: PluginFn[];
 };
 export interface Web3AuthProviderProps {
     config: Web3AuthContextConfig;
@@ -20,23 +20,20 @@ interface IBaseWeb3AuthComposableContext {
     isInitializing: Ref<boolean>;
     initError: Ref<Error | null>;
     isInitialized: Ref<boolean>;
-    status: Ref<ADAPTER_STATUS_TYPE | null>;
+    status: Ref<CONNECTOR_STATUS_TYPE | null>;
     enableMFA(params?: LoginParams): Promise<void>;
     manageMFA(params?: LoginParams): Promise<void>;
     logout(params?: {
         cleanup: boolean;
     }): Promise<void>;
-    addAndSwitchChain(chainConfig: CustomChainConfig): Promise<void>;
-    addPlugin(plugin: IPlugin): void;
     getPlugin(pluginName: string): IPlugin | null;
     authenticateUser(): Promise<UserAuthInfo>;
-    addChain(chainConfig: CustomChainConfig): Promise<void>;
     switchChain(params: {
         chainId: string;
     }): Promise<void>;
 }
 export interface IWeb3AuthContext extends IBaseWeb3AuthComposableContext {
     web3Auth: ShallowRef<Web3AuthNoModal | null>;
-    connectTo<T>(walletName: WALLET_ADAPTER_TYPE, loginParams?: T): Promise<IProvider | null>;
+    connectTo<T>(walletName: WALLET_CONNECTOR_TYPE, loginParams?: T): Promise<IProvider | null>;
 }
 export {};

package/dist/types/vue/wallet-services-plugin/interfaces.d.ts

@@ -1,6 +1,6 @@
 import type { BaseEmbedControllerState } from "@toruslabs/base-controllers";
 import type { Ref } from "vue";
-import type { WalletServicesPlugin } from "../../plugins/wallet-services-plugin";
+import type { WalletServicesPluginType } from "../../plugins/wallet-services-plugin";
 export interface IBaseWalletServicesComposableContext {
     isPluginConnected: Ref<boolean>;
     showWalletConnectScanner(showWalletConnectParams?: BaseEmbedControllerState["showWalletConnect"]): Promise<void>;
@@ -9,5 +9,5 @@ export interface IBaseWalletServicesComposableContext {
     showSwap(showSwapParams?: BaseEmbedControllerState["showSwap"]): Promise<void>;
 }
 export interface IWalletServicesContext extends IBaseWalletServicesComposableContext {
-    plugin: Ref<WalletServicesPlugin | null>;
+    plugin: Ref<WalletServicesPluginType | null>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@web3auth/no-modal",
-  "version": "10.0.0-alpha.0",
+  "version": "10.0.0-alpha.1",
   "description": "Multi chain wallet aggregator for web3Auth",
   "keywords": [
     "web3Auth/no-modal",
@@ -52,9 +52,10 @@
     "@ethereumjs/util": "^9.1.0",
     "@solana/wallet-standard-features": "^1.3.0",
     "@solana/web3.js": "^1.98.0",
-    "@toruslabs/base-controllers": "^7.1.1",
+    "@toruslabs/base-controllers": "^7.2.1",
     "@toruslabs/constants": "^14.2.0",
     "@toruslabs/eccrypto": "^5.0.4",
+    "@toruslabs/ethereum-controllers": "^7.2.1",
     "@toruslabs/http-helpers": "^7.0.0",
     "@toruslabs/tweetnacl-js": "^1.0.4",
     "@wallet-standard/app": "^1.1.0",
@@ -64,7 +65,7 @@
     "@walletconnect/types": "^2.17.3",
     "@walletconnect/utils": "^2.17.3",
     "@web3auth/auth": "^9.6.4",
-    "@web3auth/ws-embed": "^3.4.4",
+    "@web3auth/ws-embed": "^4.0.4",
     "assert": "^2.1.0",
     "bignumber.js": "^9.1.2",
     "bn.js": "^5.2.1",
@@ -76,14 +77,14 @@
     "jwt-decode": "^4.0.0",
     "loglevel": "^1.9.2",
     "mipd": "^0.0.7",
-    "permissionless": "^0.2.23",
+    "permissionless": "^0.2.30",
     "ripple-keypairs": "^1.3.1",
     "ts-custom-error": "^3.3.1",
-    "viem": "^2.22.5",
+    "viem": "^2.23.0",
     "xrpl": "^2.14.0"
   },
   "devDependencies": {
-    "@toruslabs/ethereum-controllers": "^7.1.3",
+    "@coinbase/wallet-sdk": "^4.2.x",
     "@types/elliptic": "6.4.18",
     "@types/json-rpc-random-id": "^1.0.3",
     "react": "^18.x",
@@ -136,5 +137,5 @@
     "node": ">=18.x",
     "npm": ">=9.x"
   },
-  "gitHead": "e466f273889600a6eaf54f2ee8bbf1746363499e"
+  "gitHead": "d22af091d1b195115c5c570be82c64ee92353245"
 }

package/dist/757.noModal.cjs.js

@@ -1,226 +0,0 @@
-"use strict";
-(self["webpackChunk_web3auth_no_modal"] = self["webpackChunk_web3auth_no_modal"] || []).push([[757],{
-
-/***/ 1757:
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
-
-
-// EXPORTS
-__webpack_require__.d(__webpack_exports__, {
-  offchainLookup: () => (/* binding */ offchainLookup),
-  offchainLookupSignature: () => (/* binding */ offchainLookupSignature)
-});
-
-// UNUSED EXPORTS: ccipRequest, offchainLookupAbiItem
-
-// EXTERNAL MODULE: ../../node_modules/viem/_esm/actions/public/call.js + 15 modules
-var call = __webpack_require__(1512);
-// EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/stringify.js
-var stringify = __webpack_require__(22);
-// EXTERNAL MODULE: ../../node_modules/viem/_esm/errors/base.js + 1 modules
-var base = __webpack_require__(4323);
-// EXTERNAL MODULE: ../../node_modules/viem/_esm/errors/utils.js
-var utils = __webpack_require__(476);
-;// ../../node_modules/viem/_esm/errors/ccip.js
-
-
-
-class OffchainLookupError extends base/* BaseError */.C {
-    constructor({ callbackSelector, cause, data, extraData, sender, urls, }) {
-        super(cause.shortMessage ||
-            'An error occurred while fetching for an offchain result.', {
-            cause,
-            metaMessages: [
-                ...(cause.metaMessages || []),
-                cause.metaMessages?.length ? '' : [],
-                'Offchain Gateway Call:',
-                urls && [
-                    '  Gateway URL(s):',
-                    ...urls.map((url) => `    ${(0,utils/* getUrl */.I)(url)}`),
-                ],
-                `  Sender: ${sender}`,
-                `  Data: ${data}`,
-                `  Callback selector: ${callbackSelector}`,
-                `  Extra data: ${extraData}`,
-            ].flat(),
-            name: 'OffchainLookupError',
-        });
-    }
-}
-class OffchainLookupResponseMalformedError extends base/* BaseError */.C {
-    constructor({ result, url }) {
-        super('Offchain gateway response is malformed. Response data must be a hex value.', {
-            metaMessages: [
-                `Gateway URL: ${(0,utils/* getUrl */.I)(url)}`,
-                `Response: ${(0,stringify/* stringify */.A)(result)}`,
-            ],
-            name: 'OffchainLookupResponseMalformedError',
-        });
-    }
-}
-class OffchainLookupSenderMismatchError extends base/* BaseError */.C {
-    constructor({ sender, to }) {
-        super('Reverted sender address does not match target contract address (`to`).', {
-            metaMessages: [
-                `Contract address: ${to}`,
-                `OffchainLookup sender address: ${sender}`,
-            ],
-            name: 'OffchainLookupSenderMismatchError',
-        });
-    }
-}
-//# sourceMappingURL=ccip.js.map
-// EXTERNAL MODULE: ../../node_modules/viem/_esm/errors/request.js
-var request = __webpack_require__(8820);
-// EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/abi/decodeErrorResult.js
-var decodeErrorResult = __webpack_require__(6395);
-// EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/abi/encodeAbiParameters.js
-var encodeAbiParameters = __webpack_require__(8470);
-// EXTERNAL MODULE: ../../node_modules/viem/_esm/errors/address.js
-var address = __webpack_require__(6077);
-// EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/address/isAddress.js
-var isAddress = __webpack_require__(5068);
-;// ../../node_modules/viem/_esm/utils/address/isAddressEqual.js
-
-
-function isAddressEqual(a, b) {
-    if (!(0,isAddress/* isAddress */.P)(a, { strict: false }))
-        throw new address/* InvalidAddressError */.M({ address: a });
-    if (!(0,isAddress/* isAddress */.P)(b, { strict: false }))
-        throw new address/* InvalidAddressError */.M({ address: b });
-    return a.toLowerCase() === b.toLowerCase();
-}
-//# sourceMappingURL=isAddressEqual.js.map
-// EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/data/concat.js
-var concat = __webpack_require__(666);
-// EXTERNAL MODULE: ../../node_modules/viem/_esm/utils/data/isHex.js
-var isHex = __webpack_require__(3785);
-;// ../../node_modules/viem/_esm/utils/ccip.js
-
-
-
-
-
-
-
-
-
-const offchainLookupSignature = '0x556f1830';
-const offchainLookupAbiItem = {
-    name: 'OffchainLookup',
-    type: 'error',
-    inputs: [
-        {
-            name: 'sender',
-            type: 'address',
-        },
-        {
-            name: 'urls',
-            type: 'string[]',
-        },
-        {
-            name: 'callData',
-            type: 'bytes',
-        },
-        {
-            name: 'callbackFunction',
-            type: 'bytes4',
-        },
-        {
-            name: 'extraData',
-            type: 'bytes',
-        },
-    ],
-};
-async function offchainLookup(client, { blockNumber, blockTag, data, to, }) {
-    const { args } = (0,decodeErrorResult/* decodeErrorResult */.W)({
-        data,
-        abi: [offchainLookupAbiItem],
-    });
-    const [sender, urls, callData, callbackSelector, extraData] = args;
-    const { ccipRead } = client;
-    const ccipRequest_ = ccipRead && typeof ccipRead?.request === 'function'
-        ? ccipRead.request
-        : ccipRequest;
-    try {
-        if (!isAddressEqual(to, sender))
-            throw new OffchainLookupSenderMismatchError({ sender, to });
-        const result = await ccipRequest_({ data: callData, sender, urls });
-        const { data: data_ } = await (0,call/* call */.T)(client, {
-            blockNumber,
-            blockTag,
-            data: (0,concat/* concat */.xW)([
-                callbackSelector,
-                (0,encodeAbiParameters/* encodeAbiParameters */.h)([{ type: 'bytes' }, { type: 'bytes' }], [result, extraData]),
-            ]),
-            to,
-        });
-        return data_;
-    }
-    catch (err) {
-        throw new OffchainLookupError({
-            callbackSelector,
-            cause: err,
-            data,
-            extraData,
-            sender,
-            urls,
-        });
-    }
-}
-async function ccipRequest({ data, sender, urls, }) {
-    let error = new Error('An unknown error occurred.');
-    for (let i = 0; i < urls.length; i++) {
-        const url = urls[i];
-        const method = url.includes('{data}') ? 'GET' : 'POST';
-        const body = method === 'POST' ? { data, sender } : undefined;
-        const headers = method === 'POST' ? { 'Content-Type': 'application/json' } : {};
-        try {
-            const response = await fetch(url.replace('{sender}', sender).replace('{data}', data), {
-                body: JSON.stringify(body),
-                headers,
-                method,
-            });
-            let result;
-            if (response.headers.get('Content-Type')?.startsWith('application/json')) {
-                result = (await response.json()).data;
-            }
-            else {
-                result = (await response.text());
-            }
-            if (!response.ok) {
-                error = new request/* HttpRequestError */.Ci({
-                    body,
-                    details: result?.error
-                        ? (0,stringify/* stringify */.A)(result.error)
-                        : response.statusText,
-                    headers: response.headers,
-                    status: response.status,
-                    url,
-                });
-                continue;
-            }
-            if (!(0,isHex/* isHex */.q)(result)) {
-                error = new OffchainLookupResponseMalformedError({
-                    result,
-                    url,
-                });
-                continue;
-            }
-            return result;
-        }
-        catch (err) {
-            error = new request/* HttpRequestError */.Ci({
-                body,
-                details: err.message,
-                url,
-            });
-        }
-    }
-    throw error;
-}
-//# sourceMappingURL=ccip.js.map
-
-/***/ })
-
-}]);