@imtbl/wallet 2.12.5-alpha.8 → 2.12.5

package/dist/types/confirmation/confirmation.d.ts

@@ -15,7 +15,7 @@ export default class ConfirmationScreen {
     constructor(config: IAuthConfiguration);
     private getHref;
     requestConfirmation(transactionId: string, etherAddress: string, chainType: GeneratedClients.mr.TransactionApprovalRequestChainTypeEnum, chainId?: string): Promise<ConfirmationResult>;
-    requestMessageConfirmation(messageID: string, etherAddress: string, messageType?: MessageType): Promise<ConfirmationResult>;
+    requestMessageConfirmation(messageID: string, etherAddress: string, messageType: MessageType, chainId: string): Promise<ConfirmationResult>;
     showServiceUnavailable(): Promise<void>;
     loading(popupOptions?: {
         width: number;

package/dist/types/connectWallet.d.ts

@@ -1,5 +1,4 @@
-import { ZkEvmProvider } from './zkEvm/zkEvmProvider';
-import { ConnectWalletOptions } from './types';
+import { ConnectWalletOptions, Provider } from './types';
 /**
  * Connect wallet with the provided configuration
  *
@@ -32,4 +31,4 @@ import { ConnectWalletOptions } from './types';
  * });
  * ```
  */
-export declare function connectWallet(config?: ConnectWalletOptions): Promise<ZkEvmProvider>;
+export declare function connectWallet(config?: ConnectWalletOptions): Promise<Provider>;

package/dist/types/constants.d.ts

@@ -5,6 +5,13 @@
 export declare const IMMUTABLE_ZKEVM_MAINNET_CHAIN_ID = 13371;
 /** Immutable zkEVM Testnet chain ID */
 export declare const IMMUTABLE_ZKEVM_TESTNET_CHAIN_ID = 13473;
+/**
+ * Chain ID constants for Arbitrum networks
+ */
+/** Arbitrum One Mainnet chain ID */
+export declare const ARBITRUM_ONE_CHAIN_ID = 42161;
+/** Arbitrum Sepolia Testnet chain ID */
+export declare const ARBITRUM_SEPOLIA_CHAIN_ID = 421614;
 /**
  * Magic configuration for Immutable networks
  * @internal

package/dist/types/index.d.ts

@@ -1,7 +1,9 @@
 export { connectWallet } from './connectWallet';
-export { IMMUTABLE_ZKEVM_MAINNET_CHAIN_ID, IMMUTABLE_ZKEVM_TESTNET_CHAIN_ID, } from './constants';
-export { IMMUTABLE_ZKEVM_MAINNET, IMMUTABLE_ZKEVM_TESTNET, IMMUTABLE_ZKEVM_MULTICHAIN, IMMUTABLE_ZKEVM_MAINNET_CHAIN, IMMUTABLE_ZKEVM_TESTNET_CHAIN, DEFAULT_CHAINS, } from './presets';
+export { IMMUTABLE_ZKEVM_MAINNET_CHAIN_ID, IMMUTABLE_ZKEVM_TESTNET_CHAIN_ID, ARBITRUM_ONE_CHAIN_ID, ARBITRUM_SEPOLIA_CHAIN_ID, } from './constants';
+export { IMMUTABLE_ZKEVM_MAINNET, IMMUTABLE_ZKEVM_TESTNET, IMMUTABLE_ZKEVM_MULTICHAIN, IMMUTABLE_ZKEVM_MAINNET_CHAIN, IMMUTABLE_ZKEVM_TESTNET_CHAIN, DEFAULT_CHAINS, ARBITRUM_ONE, ARBITRUM_SEPOLIA, ARBITRUM_ONE_CHAIN, ARBITRUM_SEPOLIA_CHAIN, } from './network/presets';
+export { getChainConfig, getEvmChainFromChainId } from './network/chainRegistry';
 export { ZkEvmProvider } from './zkEvm/zkEvmProvider';
+export { SequenceProvider } from './sequence/sequenceProvider';
 export { WalletConfiguration } from './config';
 export * from './types';
 export { WalletError, WalletErrorType } from './errors';

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

@@ -0,0 +1,13 @@
+import { Environment } from '@imtbl/config';
+import { ChainConfig, EvmChain } from '../types';
+/**
+ * Get chain config for non-zkEVM chains
+ * @throws Error if chain is not in registry
+ */
+export declare function getChainConfig(chain: Exclude<EvmChain, EvmChain.ZKEVM>, environment: Environment): ChainConfig;
+/**
+ * Get EvmChain from chainId
+ * @param chainId - Chain ID (can be number or string like "eip155:42161")
+ * @returns EvmChain enum value, defaults to ZKEVM if not found
+ */
+export declare function getEvmChainFromChainId(chainId: string | number): EvmChain;

package/dist/types/{presets.d.ts → network/presets.d.ts}

@@ -1,4 +1,4 @@
-import { ChainConfig } from './types';
+import { ChainConfig } from '../types';
 /**
  * Immutable zkEVM Mainnet chain configuration
  */
@@ -7,6 +7,14 @@ export declare const IMMUTABLE_ZKEVM_MAINNET_CHAIN: ChainConfig;
  * Immutable zkEVM Testnet chain configuration
  */
 export declare const IMMUTABLE_ZKEVM_TESTNET_CHAIN: ChainConfig;
+/**
+ * Arbitrum One Mainnet chain configuration
+ */
+export declare const ARBITRUM_ONE_CHAIN: ChainConfig;
+/**
+ * Arbitrum Sepolia Testnet chain configuration
+ */
+export declare const ARBITRUM_SEPOLIA_CHAIN: ChainConfig;
 /**
  * Default chains (testnet + mainnet)
  * Testnet is first (default initial chain)
@@ -56,3 +64,31 @@ export declare const IMMUTABLE_ZKEVM_TESTNET: {
 export declare const IMMUTABLE_ZKEVM_MULTICHAIN: {
     chains: ChainConfig[];
 };
+/**
+ * Arbitrum mainnet only preset
+ *
+ * @example
+ * ```typescript
+ * const provider = await connectWallet({
+ *   ...ARBITRUM_ONE_MAINNET,
+ *   auth,
+ * });
+ * ```
+ */
+export declare const ARBITRUM_ONE: {
+    chains: ChainConfig[];
+};
+/**
+ * Arbitrum testnet only preset
+ *
+ * @example
+ * ```typescript
+ * const provider = await connectWallet({
+ *   ...ARBITRUM_SEPOLIA,
+ *   auth,
+ * });
+ * ```
+ */
+export declare const ARBITRUM_SEPOLIA: {
+    chains: ChainConfig[];
+};

package/dist/types/sequence/sequenceProvider.d.ts

@@ -0,0 +1,21 @@
+import { MultiRollupApiClients } from '@imtbl/generated-clients';
+import { Auth, TypedEventEmitter } from '@imtbl/auth';
+import { Provider, ProviderEventMap, RequestArguments, ChainConfig } from '../types';
+import GuardianClient from '../guardian';
+import { SequenceSigner } from './signer';
+export type SequenceProviderInput = {
+    auth: Auth;
+    chainConfig: ChainConfig;
+    multiRollupApiClients: MultiRollupApiClients;
+    guardianClient: GuardianClient;
+    ethSigner: SequenceSigner;
+    passportEventEmitter: TypedEventEmitter<ProviderEventMap>;
+};
+export declare class SequenceProvider implements Provider {
+    #private;
+    readonly isPassport: boolean;
+    constructor({ auth, chainConfig, multiRollupApiClients, guardianClient, ethSigner, passportEventEmitter, }: SequenceProviderInput);
+    request(request: RequestArguments): Promise<any>;
+    on(event: string, listener: (...args: any[]) => void): void;
+    removeListener(event: string, listener: (...args: any[]) => void): void;
+}

package/dist/types/sequence/signer/identityInstrumentSigner.d.ts

@@ -0,0 +1,15 @@
+import { Auth } from '@imtbl/auth';
+import { Address } from 'ox';
+import { Payload, Signature as SequenceSignature } from '@0xsequence/wallet-primitives';
+import { SequenceSigner } from './types';
+export interface IdentityInstrumentSignerConfig {
+    /** Sequence Identity Instrument endpoint URL */
+    identityInstrumentEndpoint: string;
+}
+export declare class IdentityInstrumentSigner implements SequenceSigner {
+    #private;
+    constructor(auth: Auth, config: IdentityInstrumentSignerConfig);
+    getAddress(): Promise<string>;
+    signPayload(walletAddress: Address.Address, chainId: number, payload: Payload.Parented): Promise<SequenceSignature.SignatureOfSignerLeaf>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+}

package/dist/types/sequence/signer/index.d.ts

@@ -0,0 +1,20 @@
+import { Auth, IAuthConfiguration } from '@imtbl/auth';
+import { SequenceSigner } from './types';
+export type { SequenceSigner } from './types';
+export { IdentityInstrumentSigner } from './identityInstrumentSigner';
+export type { IdentityInstrumentSignerConfig } from './identityInstrumentSigner';
+export { PrivateKeySigner } from './privateKeySigner';
+export interface CreateSequenceSignerConfig {
+    /** Identity Instrument endpoint (required for prod/sandbox) */
+    identityInstrumentEndpoint?: string;
+}
+/**
+ * Create the appropriate signer based on environment.
+ * - Dev environment (behind VPN): uses PrivateKeySigner
+ * - Prod/Sandbox: uses IdentityInstrumentSigner
+ *
+ * @param auth - Auth instance
+ * @param authConfig - Auth configuration (to determine environment)
+ * @param config - Signer configuration
+ */
+export declare function createSequenceSigner(auth: Auth, authConfig: IAuthConfiguration, config?: CreateSequenceSignerConfig): SequenceSigner;

package/dist/types/sequence/signer/privateKeySigner.d.ts

@@ -0,0 +1,15 @@
+import { Auth } from '@imtbl/auth';
+import { Payload, Signature as SequenceSignature } from '@0xsequence/wallet-primitives';
+import { SequenceSigner } from './types';
+import { Address } from 'ox';
+/**
+ * Private key signer for dev environments (behind VPN).
+ * Uses a deterministic private key derived from the user's sub.
+ */
+export declare class PrivateKeySigner implements SequenceSigner {
+    #private;
+    constructor(auth: Auth);
+    getAddress(): Promise<string>;
+    signPayload(walletAddress: Address.Address, chainId: number, payload: Payload.Parented): Promise<SequenceSignature.SignatureOfSignerLeaf>;
+    signMessage(message: string | Uint8Array): Promise<string>;
+}

package/dist/types/sequence/signer/types.d.ts

@@ -0,0 +1,14 @@
+import { Address } from 'ox';
+import { Payload, Signature as SequenceSignature } from '@0xsequence/wallet-primitives';
+/**
+ * Signer interface for Sequence wallet operations.
+ * Used by non-zkEVM chains (e.g., Arbitrum).
+ */
+export interface SequenceSigner {
+    /** Get the signer's address */
+    getAddress(): Promise<string>;
+    /** Sign a Sequence payload (for transactions) */
+    signPayload(walletAddress: Address.Address, chainId: number, payload: Payload.Parented): Promise<SequenceSignature.SignatureOfSignerLeaf>;
+    /** Sign a message (EIP-191 personal_sign) */
+    signMessage(message: string | Uint8Array): Promise<string>;
+}

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

@@ -0,0 +1,2 @@
+export { registerUser } from './registerUser';
+export type { RegisterUserInput } from './registerUser';

package/dist/types/sequence/user/registerUser.d.ts

@@ -0,0 +1,18 @@
+import { MultiRollupApiClients } from '@imtbl/generated-clients';
+import { Flow } from '@imtbl/metrics';
+import type { PublicClient } from 'viem';
+import { Auth } from '@imtbl/auth';
+import { SequenceSigner } from '../signer';
+export type RegisterUserInput = {
+    auth: Auth;
+    ethSigner: SequenceSigner;
+    multiRollupApiClients: MultiRollupApiClients;
+    accessToken: string;
+    rpcProvider: PublicClient;
+    flow: Flow;
+};
+/**
+ * Register a user for a non-zkEVM chain (e.g., Arbitrum).
+ * Creates a counterfactual address for the user on the specified chain.
+ */
+export declare function registerUser({ auth, ethSigner, multiRollupApiClients, accessToken, rpcProvider, flow, }: RegisterUserInput): Promise<string>;

package/dist/types/types.d.ts

@@ -1,6 +1,10 @@
 import { Flow } from '@imtbl/metrics';
 import { Auth, TypedEventEmitter, type AuthEventMap } from '@imtbl/auth';
 import { JsonRpcError } from './zkEvm/JsonRpcError';
+export declare enum EvmChain {
+    ZKEVM = "zkevm",
+    ARBITRUM_ONE = "arbitrum_one"
+}
 /**
  * A viem-compatible signer interface for wallet operations.
  * This replaces ethers' AbstractSigner/Signer.
@@ -28,7 +32,16 @@ export type AccountsRequestedEvent = {
 export interface PassportEventMap extends AuthEventMap {
     [WalletEvents.ACCOUNTS_REQUESTED]: [AccountsRequestedEvent];
 }
-export type { Provider } from './zkEvm/types';
+/**
+ * EIP-1193 Provider Interface
+ * Standard Ethereum provider interface for all chain types
+ */
+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>;
@@ -151,6 +164,14 @@ export interface ChainConfig {
      * Defaults to 'https://tee.express.magiclabs.com'
      */
     magicTeeBasePath?: string;
+    /** Preferred token symbol for relayer fees (default: 'IMX') */
+    feeTokenSymbol?: string;
+    /** Sequence RPC node URL TODO: check if this can be removed and only use rpcUrl */
+    nodeUrl?: string;
+    /**
+     * Sequence Identity Instrument endpoint (for non-zkEVM chains in prod/sandbox)
+     */
+    sequenceIdentityInstrumentEndpoint?: string;
 }
 /**
  * Popup overlay options for wallet UI

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

@@ -1,4 +1,5 @@
 import { JsonRpcError } from './JsonRpcError';
+import type { Provider as ProviderType } from '../types';
 export declare enum RelayerTransactionStatus {
     PENDING = "PENDING",
     SUBMITTED = "SUBMITTED",
@@ -82,16 +83,8 @@ export interface JsonRpcResponsePayload {
     jsonrpc?: string;
     id?: string | number;
 }
-/**
- * EIP-1193 Provider Interface
- * Standard Ethereum provider interface
- */
-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 type { Provider } from '../types';
+type Provider = ProviderType;
 export declare enum ProviderEvent {
     ACCOUNTS_CHANGED = "accountsChanged"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imtbl/wallet",
-  "version": "2.12.5-alpha.8",
+  "version": "2.12.5",
   "description": "Wallet SDK for Immutable",
   "author": "Immutable",
   "bugs": "https://github.com/immutable/ts-immutable-sdk/issues",
@@ -25,12 +25,16 @@
     }
   },
   "dependencies": {
-    "@imtbl/auth": "2.12.5-alpha.8",
-    "@imtbl/generated-clients": "2.12.5-alpha.8",
-    "@imtbl/metrics": "2.12.5-alpha.8",
+    "@imtbl/auth": "2.12.5",
+    "@imtbl/generated-clients": "2.12.5",
+    "@imtbl/metrics": "2.12.5",
     "viem": "~2.18.0"
   },
   "devDependencies": {
+    "@0xsequence/identity-instrument": "3.0.0-beta.10",
+    "@0xsequence/wallet-wdk": "3.0.0-beta.10",
+    "@0xsequence/wallet-core": "3.0.0-beta.10",
+    "@0xsequence/wallet-primitives": "3.0.0-beta.10",
     "@swc/core": "^1.3.36",
     "@swc/jest": "^0.2.37",
     "@types/jest": "^29.5.12",
@@ -38,6 +42,7 @@
     "@jest/test-sequencer": "^29.7.0",
     "jest": "^29.4.3",
     "jest-environment-jsdom": "^29.4.3",
+    "ox": "^0.9.17",
     "ts-node": "^10.9.1",
     "tsup": "^8.3.0",
     "typescript": "^5.6.2"

package/src/confirmation/confirmation.ts

@@ -10,6 +10,8 @@ import {
 import { openPopupCenter } from './popup';
 import { IAuthConfiguration } from '@imtbl/auth';
 import ConfirmationOverlay from '../overlay/confirmationOverlay';
+import { getEvmChainFromChainId } from '../network/chainRegistry';
+import { EvmChain } from '../types';
 
 const CONFIRMATION_WINDOW_TITLE = 'Confirm this transaction';
 const CONFIRMATION_WINDOW_HEIGHT = 720;
@@ -105,7 +107,10 @@ export default class ConfirmationScreen {
       if (chainType === GeneratedClients.mr.TransactionApprovalRequestChainTypeEnum.Starkex) {
         href = this.getHref('transaction', { transactionId, etherAddress, chainType });
       } else {
-        href = this.getHref('zkevm/transaction', {
+        // Get chain path from chainId (e.g., 'zkevm', 'arbitrum-one')
+        const chain = chainId ? getEvmChainFromChainId(chainId) : EvmChain.ZKEVM;
+        const chainPath = chain.replace('_', '-');
+        href = this.getHref(`${chainPath}/transaction`, {
           transactionID: transactionId, etherAddress, chainType, chainID: chainId,
         });
       }
@@ -117,7 +122,8 @@ export default class ConfirmationScreen {
   requestMessageConfirmation(
     messageID: string,
     etherAddress: string,
-    messageType?: MessageType,
+    messageType: MessageType,
+    chainId: string,
   ): Promise<ConfirmationResult> {
     return new Promise((resolve, reject) => {
       const messageHandler = ({ data, origin }: MessageEvent) => {
@@ -157,10 +163,14 @@ export default class ConfirmationScreen {
       };
 
       window.addEventListener('message', messageHandler);
-      const href = this.getHref('zkevm/message', {
+      // Get chain path from chainId (e.g., 'zkevm', 'arbitrum-one')
+      const chain = getEvmChainFromChainId(chainId);
+      const chainPath = chain.replace('_', '-');
+      const href = this.getHref(`${chainPath}/message`, {
         messageID,
         etherAddress,
-        ...(messageType ? { messageType } : {}),
+        chainID: chainId,
+        messageType,
       });
       this.showConfirmationScreen(href, messageHandler, resolve);
     });

package/src/connectWallet.test.ts

@@ -42,6 +42,18 @@ jest.mock('./zkEvm/zkEvmProvider', () => ({
   ZkEvmProvider: jest.fn(),
 }));
 
+jest.mock('./sequence/sequenceProvider', () => ({
+  SequenceProvider: jest.fn(),
+}));
+
+jest.mock('./sequence/signer', () => ({
+  createSequenceSigner: jest.fn().mockReturnValue({
+    getAddress: jest.fn().mockResolvedValue('0x1234'),
+    signPayload: jest.fn(),
+    signMessage: jest.fn(),
+  }),
+}));
+
 jest.mock('./provider/eip6963', () => ({
   announceProvider: jest.fn(),
   passportProviderInfo: { name: 'passport', rdns: 'com.immutable.passport', icon: '' },
@@ -51,8 +63,9 @@ const { connectWallet } = require('./connectWallet');
 
 const { announceProvider } = jest.requireMock('./provider/eip6963');
 const { ZkEvmProvider } = jest.requireMock('./zkEvm/zkEvmProvider');
+const { SequenceProvider } = jest.requireMock('./sequence/sequenceProvider');
 
-const chain = {
+const zkEvmChain = {
   chainId: 13473,
   rpcUrl: 'https://rpc.sandbox.immutable.com',
   relayerUrl: 'https://relayer.sandbox.immutable.com',
@@ -60,6 +73,14 @@ const chain = {
   name: 'Immutable zkEVM Testnet',
 };
 
+const arbitrumChain = {
+  chainId: 42161,
+  rpcUrl: 'https://arb1.arbitrum.io/rpc',
+  relayerUrl: 'https://next-arbitrum-one-relayer.sequence.app',
+  apiUrl: 'https://api.immutable.com',
+  name: 'Arbitrum One',
+};
+
 const createAuthStub = () => ({
   getConfig: jest.fn().mockReturnValue({
     authenticationDomain: 'https://auth.immutable.com',
@@ -82,7 +103,7 @@ describe('connectWallet', () => {
   it('announces provider by default', async () => {
     const auth = createAuthStub();
 
-    const provider = await connectWallet({ auth, chains: [chain] });
+    const provider = await connectWallet({ auth, chains: [zkEvmChain] });
 
     expect(ZkEvmProvider).toHaveBeenCalled();
     expect(announceProvider).toHaveBeenCalledWith({
@@ -94,8 +115,46 @@ describe('connectWallet', () => {
   it('does not announce provider when disabled', async () => {
     const auth = createAuthStub();
 
-    await connectWallet({ auth, chains: [chain], announceProvider: false });
+    await connectWallet({ auth, chains: [zkEvmChain], announceProvider: false });
 
     expect(announceProvider).not.toHaveBeenCalled();
   });
+
+  describe('provider selection', () => {
+    it('uses ZkEvmProvider for zkEVM chain (by chainId)', async () => {
+      const auth = createAuthStub();
+
+      await connectWallet({ auth, chains: [zkEvmChain] });
+
+      expect(ZkEvmProvider).toHaveBeenCalled();
+      expect(SequenceProvider).not.toHaveBeenCalled();
+    });
+
+    it('uses ZkEvmProvider for zkEVM devnet chain', async () => {
+      const auth = createAuthStub();
+      const devChain = {
+        chainId: 15003, // zkEVM devnet chainId
+        rpcUrl: 'https://rpc.dev.immutable.com',
+        relayerUrl: 'https://relayer.dev.immutable.com',
+        apiUrl: 'https://api.dev.immutable.com',
+        name: 'Dev Chain',
+        magicPublishableApiKey: 'pk_test_123',
+        magicProviderId: 'provider-123',
+      };
+
+      await connectWallet({ auth, chains: [devChain] });
+
+      expect(ZkEvmProvider).toHaveBeenCalled();
+      expect(SequenceProvider).not.toHaveBeenCalled();
+    });
+
+    it('uses SequenceProvider for non-zkEVM chain (Arbitrum)', async () => {
+      const auth = createAuthStub();
+
+      await connectWallet({ auth, chains: [arbitrumChain] });
+
+      expect(SequenceProvider).toHaveBeenCalled();
+      expect(ZkEvmProvider).not.toHaveBeenCalled();
+    });
+  });
 });

package/src/connectWallet.ts

@@ -10,13 +10,21 @@ import {
   mr,
 } from '@imtbl/generated-clients';
 import { ZkEvmProvider } from './zkEvm/zkEvmProvider';
-import { ConnectWalletOptions, PassportEventMap, ChainConfig } from './types';
+import { SequenceProvider } from './sequence/sequenceProvider';
+import {
+  ConnectWalletOptions, PassportEventMap, ChainConfig, Provider,
+} from './types';
 import { WalletConfiguration } from './config';
 import GuardianClient from './guardian';
 import MagicTEESigner from './magic/magicTEESigner';
 import { announceProvider, passportProviderInfo } from './provider/eip6963';
-import { DEFAULT_CHAINS } from './presets';
-import { MAGIC_CONFIG, IMMUTABLE_ZKEVM_TESTNET_CHAIN_ID } from './constants';
+import { DEFAULT_CHAINS } from './network/presets';
+import {
+  MAGIC_CONFIG,
+  IMMUTABLE_ZKEVM_TESTNET_CHAIN_ID,
+} from './constants';
+import { ChainId } from './network/chains';
+import { createSequenceSigner } from './sequence/signer';
 
 /**
  * Type guard to check if chainId is a valid key for MAGIC_CONFIG
@@ -64,6 +72,16 @@ const DEFAULT_REDIRECT_FALLBACK = 'https://auth.immutable.com/im-logged-in';
 const DEFAULT_AUTHENTICATION_DOMAIN = 'https://auth.immutable.com';
 const SANDBOX_DOMAIN_REGEX = /(sandbox|testnet)/i;
 
+const ZKEVM_CHAIN_IDS = [
+  ChainId.IMTBL_ZKEVM_MAINNET,
+  ChainId.IMTBL_ZKEVM_TESTNET,
+  ChainId.IMTBL_ZKEVM_DEVNET,
+];
+
+function isZkEvmChain(chain: ChainConfig): boolean {
+  return ZKEVM_CHAIN_IDS.includes(chain.chainId);
+}
+
 function isSandboxChain(chain: ChainConfig): boolean {
   if (chain.chainId === IMMUTABLE_ZKEVM_TESTNET_CHAIN_ID) {
     return true;
@@ -156,7 +174,7 @@ function createDefaultAuth(initialChain: ChainConfig, options: ConnectWalletOpti
  */
 export async function connectWallet(
   config: ConnectWalletOptions = {},
-): Promise<ZkEvmProvider> {
+): Promise<Provider> {
   // Use default chains if not provided (testnet + mainnet)
   const chains = config.chains && config.chains.length > 0
     ? config.chains
@@ -216,7 +234,10 @@ export async function connectWallet(
     feeTokenSymbol: config.feeTokenSymbol,
   });
 
-  // 6. Create GuardianClient
+  // 6. Create PassportEventEmitter
+  const passportEventEmitter = config.passportEventEmitter || new TypedEventEmitter<PassportEventMap>();
+
+  // 7. Create GuardianClient
   const guardianApi = new mr.GuardianApi(apiConfig);
 
   const guardianClient = new GuardianClient({
@@ -226,50 +247,66 @@ export async function connectWallet(
     authConfig,
   });
 
-  // 7. Get Magic config for initial chain (from chain config or hard-coded default)
-  const magicConfig = getMagicConfigForChain(initialChain);
+  // 8. Create provider based on chain type
+  let provider: Provider;
 
-  // 8. Create MagicTEESigner with Magic TEE base path (separate from backend API)
-  const magicTeeBasePath = initialChain.magicTeeBasePath || 'https://tee.express.magiclabs.com';
-  const magicTeeApiClients = new MagicTeeApiClients({
-    basePath: magicTeeBasePath,
-    timeout: 10000,
-    magicPublishableApiKey: magicConfig.magicPublishableApiKey,
-    magicProviderId: magicConfig.magicProviderId,
-  });
-
-  const ethSigner = new MagicTEESigner(auth, magicTeeApiClients);
-
-  // 9. Determine session activity API URL (only for mainnet, testnet, devnet)
-  let sessionActivityApiUrl: string | null = null;
-  if (initialChain.chainId === 13371) {
-    // Mainnet
-    sessionActivityApiUrl = 'https://api.immutable.com';
-  } else if (initialChain.chainId === 13473) {
-    // Testnet
-    sessionActivityApiUrl = 'https://api.sandbox.immutable.com';
-  } else if (initialChain.apiUrl) {
-    // Devnet - use the apiUrl from chain config
-    sessionActivityApiUrl = initialChain.apiUrl;
-  }
-  // For any other chain, sessionActivityApiUrl remains null (no session activity tracking)
+  if (isZkEvmChain(initialChain)) {
+    // 9. Get Magic config for initial chain (from chain config or hard-coded default)
+    const magicConfig = getMagicConfigForChain(initialChain);
 
-  // 10. Create PassportEventEmitter
-  const passportEventEmitter = config.passportEventEmitter || new TypedEventEmitter<PassportEventMap>();
+    // 10. Create MagicTEESigner with Magic TEE base path (separate from backend API)
+    const magicTeeBasePath = initialChain.magicTeeBasePath || 'https://tee.express.magiclabs.com';
+    const magicTeeApiClients = new MagicTeeApiClients({
+      basePath: magicTeeBasePath,
+      timeout: 10000,
+      magicPublishableApiKey: magicConfig.magicPublishableApiKey,
+      magicProviderId: magicConfig.magicProviderId,
+    });
+    const ethSigner = new MagicTEESigner(auth, magicTeeApiClients);
+
+    // 11. Determine session activity API URL (only for mainnet, testnet, devnet)
+    let sessionActivityApiUrl: string | null = null;
+    if (initialChain.chainId === 13371) {
+      // Mainnet
+      sessionActivityApiUrl = 'https://api.immutable.com';
+    } else if (initialChain.chainId === 13473) {
+      // Testnet
+      sessionActivityApiUrl = 'https://api.sandbox.immutable.com';
+    } else if (initialChain.apiUrl) {
+      // Devnet - use the apiUrl from chain config
+      sessionActivityApiUrl = initialChain.apiUrl;
+    }
+    // For any other chain, sessionActivityApiUrl remains null (no session activity tracking)
+
+    // 12. Create ZkEvmProvider
+    provider = new ZkEvmProvider({
+      auth,
+      config: walletConfig,
+      multiRollupApiClients,
+      passportEventEmitter,
+      guardianClient,
+      ethSigner,
+      user,
+      sessionActivityApiUrl,
+    });
+  } else {
+    // Create Sequence signer based on environment
+    const sequenceSigner = createSequenceSigner(auth, authConfig, {
+      identityInstrumentEndpoint: initialChain.sequenceIdentityInstrumentEndpoint,
+    });
 
-  // 11. Create ZkEvmProvider
-  const provider = new ZkEvmProvider({
-    auth,
-    config: walletConfig,
-    multiRollupApiClients,
-    passportEventEmitter,
-    guardianClient,
-    ethSigner,
-    user,
-    sessionActivityApiUrl,
-  });
+    // Non-zkEVM chain - use SequenceProvider
+    provider = new SequenceProvider({
+      auth,
+      chainConfig: initialChain,
+      multiRollupApiClients,
+      guardianClient,
+      ethSigner: sequenceSigner,
+      passportEventEmitter,
+    });
+  }
 
-  // 12. Announce provider via EIP-6963
+  // 13. Announce provider via EIP-6963
   if (config.announceProvider !== false) {
     announceProvider({
       info: passportProviderInfo,