@imtbl/wallet 2.10.7-alpha.2

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+export { ZkEvmProvider } from './zkEvm/zkEvmProvider';
+export { WalletConfiguration } from './config';
+export * from './types';
+export { WalletError, WalletErrorType } from './errors';
+export { JsonRpcError, ProviderErrorCode, RpcErrorCode } from './zkEvm/JsonRpcError';
+export { RelayerClient } from './zkEvm/relayerClient';
+export * as walletHelpers from './zkEvm/walletHelpers';
+export { default as GuardianClient } from './guardian';
+export { default as MagicTEESigner } from './magic/magicTEESigner';
+export { default as TypedEventEmitter } from './utils/typedEventEmitter';
+export { retryWithDelay } from './network/retry';
+export { announceProvider, passportProviderInfo } from './provider/eip6963';

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

@@ -0,0 +1 @@
+export { default as MagicTEESigner } from './magicTEESigner';

package/dist/types/magic/magicTEESigner.d.ts

@@ -0,0 +1,24 @@
+import { AbstractSigner, Signer } from 'ethers';
+import { MagicTeeApiClients } from '@imtbl/generated-clients';
+import { AuthManager } from '@imtbl/auth';
+export default class MagicTEESigner extends AbstractSigner {
+    private readonly authManager;
+    private readonly magicTeeApiClient;
+    private userWallet;
+    private createWalletPromise;
+    constructor(authManager: AuthManager, magicTeeApiClient: MagicTeeApiClients);
+    private getUserWallet;
+    /**
+     * This method calls the createWallet endpoint. The user's wallet must be created before it can be used to sign messages.
+     * The createWallet endpoint is idempotent, so it can be called multiple times without causing an error.
+     * If a createWallet request is already in flight, return the existing promise.
+     */
+    private createWallet;
+    private getUserOrThrow;
+    private static getHeaders;
+    getAddress(): Promise<string>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+    connect(): Signer;
+    signTransaction(): Promise<string>;
+    signTypedData(): Promise<string>;
+}

package/dist/types/network/chains.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Enum representing different chain IDs.
+ * @enum {number}
+ * @property {number} IMTBL_ZKEVM_MAINNET - The chain ID for IMTBL ZKEVM Mainnet.
+ * @property {number} IMTBL_ZKEVM_TESTNET - The chain ID for IMTBL ZKEVM Testnet.
+ * @property {number} IMTBL_ZKEVM_DEVNET - The chain ID for IMTBL ZKEVM Devnet.
+ * @property {number} ETHEREUM - The chain ID for Ethereum.
+ * @property {number} SEPOLIA - The chain ID for Sepolia.
+ */
+export declare enum ChainId {
+    IMTBL_ZKEVM_MAINNET = 13371,
+    IMTBL_ZKEVM_TESTNET = 13473,
+    IMTBL_ZKEVM_DEVNET = 15003,
+    ETHEREUM = 1,
+    SEPOLIA = 11155111
+}
+/**
+ * Enum representing different chain names.
+ * @enum {number}
+ * @property {number} IMTBL_ZKEVM_MAINNET - The chain name for IMTBL ZKEVM Mainnet.
+ * @property {number} IMTBL_ZKEVM_TESTNET - The chain name for IMTBL ZKEVM Testnet.
+ * @property {number} IMTBL_ZKEVM_DEVNET - The chain name for IMTBL ZKEVM Devnet.
+ * @property {number} ETHEREUM - The chain name for Ethereum.
+ * @property {number} SEPOLIA - The chain name for Sepolia.
+ */
+export declare enum ChainName {
+    ETHEREUM = "Ethereum",
+    SEPOLIA = "Sepolia",
+    IMTBL_ZKEVM_TESTNET = "Immutable zkEVM Test",
+    IMTBL_ZKEVM_DEVNET = "Immutable zkEVM Dev",
+    IMTBL_ZKEVM_MAINNET = "Immutable zkEVM"
+}

package/dist/types/network/constants.d.ts

@@ -0,0 +1,3 @@
+import { ChainId, ChainName } from './chains';
+export type ChainMap = Map<ChainId, ChainName>;
+export declare const CHAIN_NAME_MAP: ChainMap;

package/dist/types/network/retry.d.ts

@@ -0,0 +1,8 @@
+export declare const MAX_RETRIES = 3;
+export type RetryOption = {
+    retries?: number;
+    interval?: number;
+    finalErr?: Error;
+    finallyFn?: () => void;
+};
+export declare const retryWithDelay: <T>(fn: () => Promise<T>, options?: RetryOption) => Promise<T>;

package/dist/types/provider/eip6963.d.ts

@@ -0,0 +1,3 @@
+import { EIP6963ProviderDetail, EIP6963ProviderInfo } from '../types';
+export declare const passportProviderInfo: EIP6963ProviderInfo;
+export declare function announceProvider(detail: EIP6963ProviderDetail): void;

package/dist/types/types.d.ts

@@ -0,0 +1,163 @@
+import { Environment, ModuleConfiguration } from '@imtbl/config';
+import { Flow } from '@imtbl/metrics';
+import { User } from '@imtbl/auth';
+import { BigNumberish } from 'ethers';
+import { JsonRpcError } from './zkEvm/JsonRpcError';
+export type { User, UserProfile, UserImx, UserZkEvm, DirectLoginMethod, } from '@imtbl/auth';
+export { isUserImx, isUserZkEvm } from '@imtbl/auth';
+export type { RollupType } from '@imtbl/auth';
+export declare enum PassportEvents {
+    LOGGED_OUT = "loggedOut",
+    LOGGED_IN = "loggedIn",
+    ACCOUNTS_REQUESTED = "accountsRequested"
+}
+export type AccountsRequestedEvent = {
+    environment: Environment;
+    sendTransaction: (params: Array<any>, flow: Flow) => Promise<string>;
+    walletAddress: string;
+    passportClient: string;
+    flow?: Flow;
+};
+export interface PassportEventMap extends Record<string, any> {
+    [PassportEvents.LOGGED_OUT]: [];
+    [PassportEvents.LOGGED_IN]: [User];
+    [PassportEvents.ACCOUNTS_REQUESTED]: [AccountsRequestedEvent];
+}
+export type Provider = {
+    request: (request: RequestArguments) => Promise<any>;
+    on: (event: string, listener: (...args: any[]) => void) => void;
+    removeListener: (event: string, listener: (...args: any[]) => void) => void;
+    isPassport: boolean;
+};
+export interface RequestArguments {
+    method: string;
+    params?: Array<any>;
+}
+export type JsonRpcRequestPayload = RequestArguments & {
+    jsonrpc?: string;
+    id?: string | number;
+};
+export interface JsonRpcRequestCallback {
+    (err: JsonRpcError | null, result?: JsonRpcResponsePayload | (JsonRpcResponsePayload | null)[] | null): void;
+}
+export interface JsonRpcResponsePayload {
+    result?: Array<any> | null;
+    error?: JsonRpcError | null;
+    jsonrpc?: string;
+    id?: string | number;
+}
+export interface TypedDataPayload {
+    types: {
+        EIP712Domain: Array<{
+            name: string;
+            type: string;
+        }>;
+        [key: string]: Array<{
+            name: string;
+            type: string;
+        }>;
+    };
+    domain: {
+        name?: string;
+        version?: string;
+        chainId?: number | string;
+        verifyingContract?: string;
+        salt?: string;
+    } | {
+        name?: string;
+        version?: string;
+        chainId?: number;
+        verifyingContract?: string;
+        salt?: string;
+    };
+    primaryType: string;
+    message: Record<string, any>;
+}
+export interface MetaTransaction {
+    to: string;
+    value?: BigNumberish | null;
+    data?: string | null;
+    nonce?: BigNumberish;
+    gasLimit?: BigNumberish;
+    delegateCall?: boolean;
+    revertOnError?: boolean;
+}
+export interface MetaTransactionNormalised {
+    delegateCall: boolean;
+    revertOnError: boolean;
+    gasLimit: BigNumberish;
+    target: string;
+    value: BigNumberish;
+    data: string;
+}
+export declare enum ProviderEvent {
+    ACCOUNTS_CHANGED = "accountsChanged"
+}
+export type AccountsChangedEvent = Array<string>;
+export interface ProviderEventMap extends Record<string, any> {
+    [ProviderEvent.ACCOUNTS_CHANGED]: [AccountsChangedEvent];
+}
+export declare enum RelayerTransactionStatus {
+    PENDING = "PENDING",
+    SUBMITTED = "SUBMITTED",
+    SUCCESSFUL = "SUCCESSFUL",
+    REVERTED = "REVERTED",
+    FAILED = "FAILED",
+    CANCELLED = "CANCELLED"
+}
+export interface RelayerTransaction {
+    status: RelayerTransactionStatus;
+    chainId: string;
+    relayerId: string;
+    hash: string;
+    statusMessage?: string;
+}
+export interface FeeOption {
+    tokenPrice: string;
+    tokenSymbol: string;
+    tokenDecimals: number;
+    tokenAddress: string;
+    recipientAddress: string;
+}
+/**
+ * Event detail from the `eip6963:announceProvider` event.
+ */
+export interface EIP6963ProviderDetail {
+    info: EIP6963ProviderInfo;
+    provider: Provider;
+}
+/**
+ * Metadata of the EIP-1193 Provider.
+ */
+export interface EIP6963ProviderInfo {
+    icon: `data:image/${string}`;
+    name: string;
+    rdns: string;
+    uuid: string;
+}
+/**
+ * Event type to announce an EIP-1193 Provider.
+ */
+export interface EIP6963AnnounceProviderEvent extends CustomEvent<EIP6963ProviderDetail> {
+    type: 'eip6963:announceProvider';
+}
+export interface WalletOverrides {
+    passportDomain: string;
+    zkEvmRpcUrl: string;
+    relayerUrl: string;
+    indexerMrBasePath: string;
+}
+export interface WalletModuleConfiguration extends ModuleConfiguration<WalletOverrides> {
+    /**
+     * Optional referrer URL to be sent with JSON-RPC requests.
+     */
+    jsonRpcReferrer?: string;
+    /**
+     * If true, forces SCW deployment before allowing message signature.
+     */
+    forceScwDeployBeforeMessageSignature?: boolean;
+    /**
+     * This flag indicates that Wallet is being used in a cross-sdk bridge scenario.
+     */
+    crossSdkBridgeEnabled?: boolean;
+}

package/dist/types/utils/metrics.d.ts

@@ -0,0 +1,3 @@
+import { Flow } from '@imtbl/metrics';
+export declare const withMetrics: <T>(fn: (flow: Flow) => T, flowName: string, trackStartEvent?: boolean, trackEndEvent?: boolean) => T;
+export declare const withMetricsAsync: <T>(fn: (flow: Flow) => Promise<T>, flowName: string, trackStartEvent?: boolean, trackEndEvent?: boolean) => Promise<T>;

package/dist/types/utils/string.d.ts

@@ -0,0 +1 @@
+export declare const hexToString: (hex: string) => string;

package/dist/types/utils/typedEventEmitter.d.ts

@@ -0,0 +1,6 @@
+export default class TypedEventEmitter<TEvents extends Record<string, any>> {
+    private emitter;
+    emit<TEventName extends keyof TEvents & string>(eventName: TEventName, ...eventArg: TEvents[TEventName]): void;
+    on<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
+    removeListener<TEventName extends keyof TEvents & string>(eventName: TEventName, handler: (...eventArg: TEvents[TEventName]) => void): void;
+}

package/dist/types/zkEvm/JsonRpcError.d.ts

@@ -0,0 +1,25 @@
+/**
+ * ProviderErrors should take priority over RpcErrorCodes
+ * https://eips.ethereum.org/EIPS/eip-1193#provider-errors
+ * https://eips.ethereum.org/EIPS/eip-1474#error-codes
+ */
+export declare enum ProviderErrorCode {
+    USER_REJECTED_REQUEST = 4001,
+    UNAUTHORIZED = 4100,
+    UNSUPPORTED_METHOD = 4200,
+    DISCONNECTED = 4900
+}
+export declare enum RpcErrorCode {
+    RPC_SERVER_ERROR = -32000,
+    INVALID_REQUEST = -32600,
+    METHOD_NOT_FOUND = -32601,
+    INVALID_PARAMS = -32602,
+    INTERNAL_ERROR = -32603,
+    PARSE_ERROR = -32700,
+    TRANSACTION_REJECTED = -32003
+}
+export declare class JsonRpcError extends Error {
+    readonly message: string;
+    readonly code: ProviderErrorCode | RpcErrorCode;
+    constructor(code: ProviderErrorCode | RpcErrorCode, message: string);
+}

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

@@ -0,0 +1,2 @@
+export * from './zkEvmProvider';
+export * from './types';

package/dist/types/zkEvm/personalSign.d.ts

@@ -0,0 +1,15 @@
+import { Flow } from '@imtbl/metrics';
+import { Signer, JsonRpcProvider } from 'ethers';
+import GuardianClient from '../guardian';
+import { RelayerClient } from './relayerClient';
+interface PersonalSignParams {
+    ethSigner: Signer;
+    rpcProvider: JsonRpcProvider;
+    params: any[];
+    zkEvmAddress: string;
+    guardianClient: GuardianClient;
+    relayerClient: RelayerClient;
+    flow: Flow;
+}
+export declare const personalSign: ({ params, ethSigner, zkEvmAddress, rpcProvider, guardianClient, relayerClient, flow, }: PersonalSignParams) => Promise<string>;
+export {};

package/dist/types/zkEvm/provider/eip6963.d.ts

@@ -0,0 +1,3 @@
+import { EIP6963ProviderDetail, EIP6963ProviderInfo } from '../types';
+export declare const passportProviderInfo: EIP6963ProviderInfo;
+export declare function announceProvider(detail: EIP6963ProviderDetail): void;

package/dist/types/zkEvm/relayerClient.d.ts

@@ -0,0 +1,60 @@
+import { BytesLike, JsonRpcProvider } from 'ethers';
+import { AuthManager } from '@imtbl/auth';
+import { WalletConfiguration } from '../config';
+import { FeeOption, RelayerTransaction, TypedDataPayload } from './types';
+export type RelayerClientInput = {
+    config: WalletConfiguration;
+    rpcProvider: JsonRpcProvider;
+    authManager: AuthManager;
+};
+type EthSendTransactionRequest = {
+    method: 'eth_sendTransaction';
+    params: {
+        to: string;
+        data: BytesLike;
+        chainId: string;
+    }[];
+};
+type ImGetTransactionByHashRequest = {
+    method: 'im_getTransactionByHash';
+    params: string[];
+};
+type ImGetFeeOptionsRequest = {
+    method: 'im_getFeeOptions';
+    params: {
+        userAddress: string;
+        data: BytesLike;
+        chainId: string;
+    }[];
+};
+type ImSignRequest = {
+    method: 'im_sign';
+    params: {
+        chainId: string;
+        address: string;
+        message: string;
+    }[];
+};
+type ImSignTypedDataRequest = {
+    method: 'im_signTypedData';
+    params: {
+        chainId: string;
+        address: string;
+        eip712Payload: TypedDataPayload;
+    }[];
+};
+export type RelayerTransactionRequest = EthSendTransactionRequest | ImGetTransactionByHashRequest | ImGetFeeOptionsRequest | ImSignTypedDataRequest | ImSignRequest;
+export declare class RelayerClient {
+    private readonly config;
+    private readonly rpcProvider;
+    private readonly authManager;
+    constructor({ config, rpcProvider, authManager }: RelayerClientInput);
+    private static getResponsePreview;
+    private postToRelayer;
+    ethSendTransaction(to: string, data: BytesLike): Promise<string>;
+    imGetTransactionByHash(hash: string): Promise<RelayerTransaction>;
+    imGetFeeOptions(userAddress: string, data: BytesLike): Promise<FeeOption[] | undefined>;
+    imSignTypedData(address: string, eip712Payload: TypedDataPayload): Promise<string>;
+    imSign(address: string, message: string): Promise<string>;
+}
+export {};

package/dist/types/zkEvm/sendDeployTransactionAndPersonalSign.d.ts

@@ -0,0 +1,6 @@
+import { TransactionParams } from './transactionHelpers';
+type EthSendDeployTransactionParams = TransactionParams & {
+    params: Array<any>;
+};
+export declare const sendDeployTransactionAndPersonalSign: ({ params, ethSigner, rpcProvider, relayerClient, guardianClient, zkEvmAddress, flow, }: EthSendDeployTransactionParams) => Promise<string>;
+export {};

package/dist/types/zkEvm/sendTransaction.d.ts

@@ -0,0 +1,6 @@
+import { TransactionParams } from './transactionHelpers';
+type EthSendTransactionParams = TransactionParams & {
+    params: Array<any>;
+};
+export declare const sendTransaction: ({ params, ethSigner, rpcProvider, relayerClient, guardianClient, zkEvmAddress, flow, nonceSpace, isBackgroundTransaction, }: EthSendTransactionParams) => Promise<string>;
+export {};

package/dist/types/zkEvm/sessionActivity/errorBoundary.d.ts

@@ -0,0 +1 @@
+export declare function errorBoundary<T extends (...args: any[]) => any>(fn: T, fallbackResult?: ReturnType<T>): (...args: Parameters<T>) => ReturnType<T>;

package/dist/types/zkEvm/sessionActivity/request.d.ts

@@ -0,0 +1,15 @@
+import { Environment } from '@imtbl/config';
+export declare const setupClient: (environment: Environment) => void;
+type CheckParams = {
+    clientId: string;
+    wallet?: string;
+    checkCount?: number;
+    sendCount?: number;
+};
+export type CheckResponse = {
+    contractAddress?: string;
+    functionName?: string;
+    delay?: number;
+};
+export declare function get(queries: CheckParams): Promise<CheckResponse | undefined>;
+export {};

package/dist/types/zkEvm/sessionActivity/sessionActivity.d.ts

@@ -0,0 +1,2 @@
+import { AccountsRequestedEvent } from '../../types';
+export declare const trackSessionActivity: (args: AccountsRequestedEvent) => Promise<void>;

package/dist/types/zkEvm/signEjectionTransaction.d.ts

@@ -0,0 +1,6 @@
+import { EjectionTransactionParams, EjectionTransactionResponse } from './transactionHelpers';
+type EthSendTransactionEjectionParams = EjectionTransactionParams & {
+    params: Array<any>;
+};
+export declare const signEjectionTransaction: ({ params, ethSigner, zkEvmAddress, flow, }: EthSendTransactionEjectionParams) => Promise<EjectionTransactionResponse>;
+export {};

package/dist/types/zkEvm/signTypedDataV4.d.ts

@@ -0,0 +1,14 @@
+import { Flow } from '@imtbl/metrics';
+import { Signer, JsonRpcProvider } from 'ethers';
+import GuardianClient from '../guardian';
+import { RelayerClient } from './relayerClient';
+export type SignTypedDataV4Params = {
+    ethSigner: Signer;
+    rpcProvider: JsonRpcProvider;
+    relayerClient: RelayerClient;
+    method: string;
+    params: Array<any>;
+    guardianClient: GuardianClient;
+    flow: Flow;
+};
+export declare const signTypedDataV4: ({ params, method, ethSigner, rpcProvider, relayerClient, guardianClient, flow, }: SignTypedDataV4Params) => Promise<string>;

package/dist/types/zkEvm/transactionHelpers.d.ts

@@ -0,0 +1,31 @@
+import { Flow } from '@imtbl/metrics';
+import { Signer, TransactionRequest, JsonRpcProvider, BigNumberish } from 'ethers';
+import { RelayerClient } from './relayerClient';
+import GuardianClient from '../guardian';
+export type TransactionParams = {
+    ethSigner: Signer;
+    rpcProvider: JsonRpcProvider;
+    guardianClient: GuardianClient;
+    relayerClient: RelayerClient;
+    zkEvmAddress: string;
+    flow: Flow;
+    nonceSpace?: bigint;
+    isBackgroundTransaction?: boolean;
+};
+export type EjectionTransactionParams = Pick<TransactionParams, 'ethSigner' | 'zkEvmAddress' | 'flow'>;
+export type EjectionTransactionResponse = {
+    to: string;
+    data: string;
+    chainId: string;
+};
+export declare const pollRelayerTransaction: (relayerClient: RelayerClient, relayerId: string, flow: Flow) => Promise<import("./types").RelayerTransaction>;
+export declare const prepareAndSignTransaction: ({ transactionRequest, ethSigner, rpcProvider, guardianClient, relayerClient, zkEvmAddress, flow, nonceSpace, isBackgroundTransaction, }: TransactionParams & {
+    transactionRequest: TransactionRequest;
+}) => Promise<{
+    signedTransactions: string;
+    relayerId: string;
+    nonce: BigNumberish;
+}>;
+export declare const prepareAndSignEjectionTransaction: ({ transactionRequest, ethSigner, zkEvmAddress, flow, }: EjectionTransactionParams & {
+    transactionRequest: TransactionRequest;
+}) => Promise<EjectionTransactionResponse>;

package/dist/types/zkEvm/types.d.ts

@@ -0,0 +1,120 @@
+import { BigNumberish } from 'ethers';
+import { JsonRpcError } from './JsonRpcError';
+export declare enum RelayerTransactionStatus {
+    PENDING = "PENDING",
+    SUBMITTED = "SUBMITTED",
+    SUCCESSFUL = "SUCCESSFUL",
+    REVERTED = "REVERTED",
+    FAILED = "FAILED",
+    CANCELLED = "CANCELLED"
+}
+export interface RelayerTransaction {
+    status: RelayerTransactionStatus;
+    chainId: string;
+    relayerId: string;
+    hash: string;
+    statusMessage?: string;
+}
+export interface FeeOption {
+    tokenPrice: string;
+    tokenSymbol: string;
+    tokenDecimals: number;
+    tokenAddress: string;
+    recipientAddress: string;
+}
+export interface MetaTransaction {
+    to: string;
+    value?: BigNumberish | null;
+    data?: string | null;
+    nonce?: BigNumberish;
+    gasLimit?: BigNumberish;
+    delegateCall?: boolean;
+    revertOnError?: boolean;
+}
+export interface MetaTransactionNormalised {
+    delegateCall: boolean;
+    revertOnError: boolean;
+    gasLimit: BigNumberish;
+    target: string;
+    value: BigNumberish;
+    data: string;
+}
+export interface TypedDataPayload {
+    types: {
+        EIP712Domain: Array<{
+            name: string;
+            type: string;
+        }>;
+        [key: string]: Array<{
+            name: string;
+            type: string;
+        }>;
+    };
+    domain: {
+        name?: string;
+        version?: string;
+        chainId?: number | string;
+        verifyingContract?: string;
+        salt?: string;
+    } | {
+        name?: string;
+        version?: string;
+        chainId?: number;
+        verifyingContract?: string;
+        salt?: string;
+    };
+    primaryType: string;
+    message: Record<string, any>;
+}
+export interface RequestArguments {
+    method: string;
+    params?: Array<any>;
+}
+export type JsonRpcRequestPayload = RequestArguments & {
+    jsonrpc?: string;
+    id?: string | number;
+};
+export interface JsonRpcRequestCallback {
+    (err: JsonRpcError | null, result?: JsonRpcResponsePayload | (JsonRpcResponsePayload | null)[] | null): void;
+}
+export interface JsonRpcResponsePayload {
+    result?: Array<any> | null;
+    error?: JsonRpcError | null;
+    jsonrpc?: string;
+    id?: string | number;
+}
+export type Provider = {
+    request: (request: RequestArguments) => Promise<any>;
+    on: (event: string, listener: (...args: any[]) => void) => void;
+    removeListener: (event: string, listener: (...args: any[]) => void) => void;
+    isPassport: boolean;
+};
+export declare enum ProviderEvent {
+    ACCOUNTS_CHANGED = "accountsChanged"
+}
+export type AccountsChangedEvent = Array<string>;
+export interface ProviderEventMap extends Record<string, any> {
+    [ProviderEvent.ACCOUNTS_CHANGED]: [AccountsChangedEvent];
+}
+/**
+ * Event detail from the `eip6963:announceProvider` event.
+ */
+export interface EIP6963ProviderDetail {
+    info: EIP6963ProviderInfo;
+    provider: Provider;
+}
+/**
+ * Metadata of the EIP-1193 Provider.
+ */
+export interface EIP6963ProviderInfo {
+    icon: `data:image/${string}`;
+    name: string;
+    rdns: string;
+    uuid: string;
+}
+/**
+ * Event type to announce an EIP-1193 Provider.
+ */
+export interface EIP6963AnnounceProviderEvent extends CustomEvent<EIP6963ProviderDetail> {
+    type: 'eip6963:announceProvider';
+}

package/dist/types/zkEvm/user/index.d.ts

@@ -0,0 +1 @@
+export * from './registerZkEvmUser';

package/dist/types/zkEvm/user/registerZkEvmUser.d.ts

@@ -0,0 +1,13 @@
+import { MultiRollupApiClients } from '@imtbl/generated-clients';
+import { Flow } from '@imtbl/metrics';
+import { Signer, JsonRpcProvider } from 'ethers';
+import { AuthManager } from '@imtbl/auth';
+export type RegisterZkEvmUserInput = {
+    authManager: AuthManager;
+    ethSigner: Signer;
+    multiRollupApiClients: MultiRollupApiClients;
+    accessToken: string;
+    rpcProvider: JsonRpcProvider;
+    flow: Flow;
+};
+export declare function registerZkEvmUser({ authManager, ethSigner, multiRollupApiClients, accessToken, rpcProvider, flow, }: RegisterZkEvmUserInput): Promise<string>;

package/dist/types/zkEvm/walletHelpers.d.ts

@@ -0,0 +1,33 @@
+import { BigNumberish, Signer, JsonRpcProvider } from 'ethers';
+import { MetaTransaction, MetaTransactionNormalised, TypedDataPayload } from './types';
+export declare const getNormalisedTransactions: (txs: MetaTransaction[]) => MetaTransactionNormalised[];
+export declare const digestOfTransactionsAndNonce: (nonce: BigNumberish, normalisedTransactions: MetaTransactionNormalised[]) => string;
+export declare const encodedTransactions: (normalisedTransactions: MetaTransactionNormalised[]) => string;
+/**
+ * This helper function is used to coerce the type <BigNumber | undefined> to BigNumber for the
+ * getNonce function above.
+ * @param {BigNumber} nonceSpace - An unsigned 256 bit value that can be used to encode a nonce into a distinct space.
+ * @returns {BigNumber} The passed in nonceSpace or instead initialises the nonce to 0.
+ */
+export declare const coerceNonceSpace: (nonceSpace?: bigint) => bigint;
+/**
+ * This helper function is used to encode the nonce into a 256 bit value where the space is encoded into
+ * the first 160 bits, and the nonce the remaining 96 bits.
+ * @param {BigNumber} nonceSpace - An unsigned 256 bit value that can be used to encode a nonce into a distinct space.
+ * @param nonce {BigNumber} nonce - Sequential number starting at 0, and incrementing in single steps e.g. 0,1,2,...
+ * @returns {BigNumber} The encoded value where the space is left shifted 96 bits, and the nonce is in the first 96 bits.
+ */
+export declare const encodeNonce: (nonceSpace: bigint, nonce: bigint) => bigint;
+/**
+ * When we retrieve a nonce for a smart contract wallet we can retrieve the nonce in a given 256 bit space.
+ * Nonces in each 256 bit space need to be sequential per wallet address. Nonces across 256 bit spaces per
+ * wallet address do not. This function overload can be used to invoke transactions in parallel per smart
+ * contract wallet if required.
+ */
+export declare const getNonce: (rpcProvider: JsonRpcProvider, smartContractWalletAddress: string, nonceSpace?: bigint) => Promise<bigint>;
+export declare const encodeMessageSubDigest: (chainId: bigint, walletAddress: string, digest: string) => string;
+export declare const signMetaTransactions: (metaTransactions: MetaTransaction[], nonce: BigNumberish, chainId: bigint, walletAddress: string, signer: Signer) => Promise<string>;
+export declare const packSignatures: (EOASignature: string, EOAAddress: string, relayerSignature: string) => string;
+export declare const signAndPackTypedData: (typedData: TypedDataPayload, relayerSignature: string, chainId: bigint, walletAddress: string, signer: Signer) => Promise<string>;
+export declare const signERC191Message: (chainId: bigint, payload: string, signer: Signer, walletAddress: string) => Promise<string>;
+export declare const getEip155ChainId: (chainId: number) => string;