@imtbl/wallet 2.12.5-alpha.8 → 2.12.5

package/src/constants.ts

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

package/src/guardian/index.ts

@@ -232,6 +232,7 @@ export default class GuardianClient {
         messageId,
         user.zkEvm.ethAddress,
         'eip712',
+        chainID,
       );
 
       if (!confirmationResult.confirmed) {
@@ -286,6 +287,7 @@ export default class GuardianClient {
         messageId,
         user.zkEvm.ethAddress,
         'erc191',
+        String(chainID),
       );
 
       if (!confirmationResult.confirmed) {

package/src/index.ts

@@ -5,20 +5,32 @@ export { connectWallet } from './connectWallet';
 export {
   IMMUTABLE_ZKEVM_MAINNET_CHAIN_ID,
   IMMUTABLE_ZKEVM_TESTNET_CHAIN_ID,
+  ARBITRUM_ONE_CHAIN_ID,
+  ARBITRUM_SEPOLIA_CHAIN_ID,
 } from './constants';
 
 // Export presets (public API)
 export {
+  // zkEVM chains
   IMMUTABLE_ZKEVM_MAINNET,
   IMMUTABLE_ZKEVM_TESTNET,
   IMMUTABLE_ZKEVM_MULTICHAIN,
   IMMUTABLE_ZKEVM_MAINNET_CHAIN,
   IMMUTABLE_ZKEVM_TESTNET_CHAIN,
   DEFAULT_CHAINS,
-} from './presets';
+  // Arbitrum chains
+  ARBITRUM_ONE,
+  ARBITRUM_SEPOLIA,
+  ARBITRUM_ONE_CHAIN,
+  ARBITRUM_SEPOLIA_CHAIN,
+} from './network/presets';
 
-// Export main wallet provider
+// Export chain registry for looking up chain configs
+export { getChainConfig, getEvmChainFromChainId } from './network/chainRegistry';
+
+// Export main wallet providers
 export { ZkEvmProvider } from './zkEvm/zkEvmProvider';
+export { SequenceProvider } from './sequence/sequenceProvider';
 
 // Export internal configuration (for Passport/advanced usage)
 export { WalletConfiguration } from './config';

package/src/network/chainRegistry.test.ts

@@ -0,0 +1,64 @@
+import { Environment } from '@imtbl/config';
+import { getChainConfig, getEvmChainFromChainId } from './chainRegistry';
+import { EvmChain } from '../types';
+import { ARBITRUM_ONE_CHAIN, ARBITRUM_SEPOLIA_CHAIN } from './presets';
+
+describe('chainRegistry', () => {
+  describe('getChainConfig', () => {
+    it('returns Arbitrum One mainnet config for PRODUCTION', () => {
+      const config = getChainConfig(EvmChain.ARBITRUM_ONE, Environment.PRODUCTION);
+
+      expect(config).toEqual(ARBITRUM_ONE_CHAIN);
+      expect(config.chainId).toBe(42161);
+      expect(config.name).toBe('Arbitrum One');
+    });
+
+    it('returns Arbitrum Sepolia config for SANDBOX', () => {
+      const config = getChainConfig(EvmChain.ARBITRUM_ONE, Environment.SANDBOX);
+
+      expect(config).toEqual(ARBITRUM_SEPOLIA_CHAIN);
+      expect(config.chainId).toBe(421614);
+      expect(config.name).toBe('Arbitrum Sepolia');
+    });
+
+    it('throws error for unsupported chain', () => {
+      expect(() => {
+        getChainConfig('unsupported_chain' as any, Environment.PRODUCTION);
+      }).toThrow('Chain unsupported_chain is not supported');
+    });
+  });
+
+  describe('getEvmChainFromChainId', () => {
+    it('returns ZKEVM for mainnet chainId', () => {
+      expect(getEvmChainFromChainId(13371)).toBe(EvmChain.ZKEVM);
+    });
+
+    it('returns ZKEVM for testnet chainId', () => {
+      expect(getEvmChainFromChainId(13473)).toBe(EvmChain.ZKEVM);
+    });
+
+    it('returns ZKEVM for devnet chainId', () => {
+      expect(getEvmChainFromChainId(15003)).toBe(EvmChain.ZKEVM);
+    });
+
+    it('returns ARBITRUM_ONE for Arbitrum mainnet chainId', () => {
+      expect(getEvmChainFromChainId(42161)).toBe(EvmChain.ARBITRUM_ONE);
+    });
+
+    it('returns ARBITRUM_ONE for Arbitrum Sepolia chainId', () => {
+      expect(getEvmChainFromChainId(421614)).toBe(EvmChain.ARBITRUM_ONE);
+    });
+
+    it('handles string chainId', () => {
+      expect(getEvmChainFromChainId('42161')).toBe(EvmChain.ARBITRUM_ONE);
+    });
+
+    it('handles eip155 format chainId', () => {
+      expect(getEvmChainFromChainId('eip155:42161')).toBe(EvmChain.ARBITRUM_ONE);
+    });
+
+    it('defaults to ZKEVM for unknown chainId', () => {
+      expect(getEvmChainFromChainId(99999)).toBe(EvmChain.ZKEVM);
+    });
+  });
+});

package/src/network/chainRegistry.ts

@@ -0,0 +1,74 @@
+import { Environment } from '@imtbl/config';
+import { ChainConfig, EvmChain } from '../types';
+import {
+  IMMUTABLE_ZKEVM_MAINNET_CHAIN,
+  IMMUTABLE_ZKEVM_TESTNET_CHAIN,
+  ARBITRUM_ONE_CHAIN,
+  ARBITRUM_SEPOLIA_CHAIN,
+} from './presets';
+import { ChainId } from './chains';
+
+/**
+ * Registry mapping (EvmChain, Environment) to ChainConfig
+ */
+const CHAIN_REGISTRY: Record<EvmChain, Record<Environment, ChainConfig>> = {
+  [EvmChain.ZKEVM]: {
+    [Environment.PRODUCTION]: IMMUTABLE_ZKEVM_MAINNET_CHAIN,
+    [Environment.SANDBOX]: IMMUTABLE_ZKEVM_TESTNET_CHAIN,
+  },
+  [EvmChain.ARBITRUM_ONE]: {
+    [Environment.PRODUCTION]: ARBITRUM_ONE_CHAIN,
+    [Environment.SANDBOX]: ARBITRUM_SEPOLIA_CHAIN,
+  },
+};
+
+/**
+ * Build chainId → EvmChain mapping from CHAIN_REGISTRY (derived, not manual)
+ */
+function buildChainIdToEvmChainMap(): Record<number, EvmChain> {
+  const map: Record<number, EvmChain> = {};
+  for (const [evmChain, envConfigs] of Object.entries(CHAIN_REGISTRY)) {
+    for (const config of Object.values(envConfigs)) {
+      map[config.chainId] = evmChain as EvmChain;
+    }
+  }
+  // Devnet doesn't have a preset
+  map[ChainId.IMTBL_ZKEVM_DEVNET] = EvmChain.ZKEVM;
+  return map;
+}
+
+const CHAIN_ID_TO_EVM_CHAIN = buildChainIdToEvmChainMap();
+
+/**
+ * Get chain config for non-zkEVM chains
+ * @throws Error if chain is not in registry
+ */
+export function getChainConfig(
+  chain: Exclude<EvmChain, EvmChain.ZKEVM>,
+  environment: Environment,
+): ChainConfig {
+  const envConfigs = CHAIN_REGISTRY[chain];
+  if (!envConfigs) {
+    throw new Error(`Chain ${chain} is not supported`);
+  }
+
+  const config = envConfigs[environment];
+  if (!config) {
+    throw new Error(`Chain ${chain} is not configured for environment ${environment}`);
+  }
+
+  return config;
+}
+
+/**
+ * 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 function getEvmChainFromChainId(chainId: string | number): EvmChain {
+  const numericChainId = typeof chainId === 'string'
+    ? parseInt(chainId.includes(':') ? chainId.split(':')[1] : chainId, 10)
+    : chainId;
+
+  return CHAIN_ID_TO_EVM_CHAIN[numericChainId] ?? EvmChain.ZKEVM;
+}

package/src/{presets.ts → network/presets.ts}

@@ -1,9 +1,11 @@
-import { ChainConfig } from './types';
+import { ChainConfig } from '../types';
 import {
   IMMUTABLE_ZKEVM_MAINNET_CHAIN_ID,
   IMMUTABLE_ZKEVM_TESTNET_CHAIN_ID,
+  ARBITRUM_ONE_CHAIN_ID,
+  ARBITRUM_SEPOLIA_CHAIN_ID,
   MAGIC_CONFIG,
-} from './constants';
+} from '../constants';
 
 /**
  * Immutable zkEVM Mainnet chain configuration
@@ -35,6 +37,36 @@ export const IMMUTABLE_ZKEVM_TESTNET_CHAIN: ChainConfig = {
   magicTeeBasePath: 'https://tee.express.magiclabs.com',
 };
 
+/**
+ * Arbitrum One Mainnet chain configuration
+ */
+export const ARBITRUM_ONE_CHAIN: ChainConfig = {
+  chainId: ARBITRUM_ONE_CHAIN_ID,
+  name: 'Arbitrum One',
+  rpcUrl: 'https://arb1.arbitrum.io/rpc',
+  relayerUrl: 'https://next-arbitrum-one-relayer.sequence.app',
+  nodeUrl: 'https://next-nodes.sequence.app/arbitrum-one',
+  apiUrl: 'https://api.immutable.com',
+  passportDomain: 'https://passport.immutable.com',
+  feeTokenSymbol: 'ETH',
+  sequenceIdentityInstrumentEndpoint: 'https://next-identity.sequence.app',
+};
+
+/**
+ * Arbitrum Sepolia Testnet chain configuration
+ */
+export const ARBITRUM_SEPOLIA_CHAIN: ChainConfig = {
+  chainId: ARBITRUM_SEPOLIA_CHAIN_ID,
+  name: 'Arbitrum Sepolia',
+  rpcUrl: 'https://sepolia-rollup.arbitrum.io/rpc',
+  relayerUrl: 'https://next-arbitrum-sepolia-relayer.sequence.app',
+  nodeUrl: 'https://next-nodes.sequence.app/arbitrum-sepolia',
+  apiUrl: 'https://api.sandbox.immutable.com',
+  passportDomain: 'https://passport.sandbox.immutable.com',
+  feeTokenSymbol: 'ETH',
+  sequenceIdentityInstrumentEndpoint: 'https://next-identity.sequence-dev.app',
+};
+
 /**
  * Default chains (testnet + mainnet)
  * Testnet is first (default initial chain)
@@ -90,3 +122,33 @@ export const IMMUTABLE_ZKEVM_TESTNET = {
 export const IMMUTABLE_ZKEVM_MULTICHAIN = {
   chains: DEFAULT_CHAINS,
 };
+
+/**
+ * Arbitrum mainnet only preset
+ *
+ * @example
+ * ```typescript
+ * const provider = await connectWallet({
+ *   ...ARBITRUM_ONE_MAINNET,
+ *   auth,
+ * });
+ * ```
+ */
+export const ARBITRUM_ONE = {
+  chains: [ARBITRUM_ONE_CHAIN],
+};
+
+/**
+ * Arbitrum testnet only preset
+ *
+ * @example
+ * ```typescript
+ * const provider = await connectWallet({
+ *   ...ARBITRUM_SEPOLIA,
+ *   auth,
+ * });
+ * ```
+ */
+export const ARBITRUM_SEPOLIA = {
+  chains: [ARBITRUM_SEPOLIA_CHAIN],
+};

package/src/sequence/sequenceProvider.ts

@@ -0,0 +1,276 @@
+import {
+  createPublicClient,
+  http,
+  toHex,
+  type PublicClient,
+} from 'viem';
+import { MultiRollupApiClients } from '@imtbl/generated-clients';
+import { Auth, TypedEventEmitter, User } from '@imtbl/auth';
+import { trackFlow, trackError, identify } from '@imtbl/metrics';
+import {
+  Provider,
+  ProviderEvent,
+  ProviderEventMap,
+  RequestArguments,
+  ChainConfig,
+  EvmChain,
+} from '../types';
+import { JsonRpcError, ProviderErrorCode, RpcErrorCode } from '../zkEvm/JsonRpcError';
+import GuardianClient from '../guardian';
+import { SequenceSigner } from './signer';
+import { registerUser } from './user';
+import { getEvmChainFromChainId } from '../network/chainRegistry';
+
+export type SequenceProviderInput = {
+  auth: Auth;
+  chainConfig: ChainConfig;
+  multiRollupApiClients: MultiRollupApiClients;
+  guardianClient: GuardianClient;
+  ethSigner: SequenceSigner;
+  passportEventEmitter: TypedEventEmitter<ProviderEventMap>;
+};
+
+/** Non-zkEVM chain type */
+type SequenceChain = Exclude<EvmChain, EvmChain.ZKEVM>;
+
+/**
+ * Check if user is registered for a non-zkEVM chain.
+ * The chain data is stored as user[chainName] (e.g., user.arbitrum_one).
+ */
+function isUserRegisteredForChain(user: User, chain: SequenceChain): boolean {
+  return chain in user && !!(user as any)[chain]?.ethAddress;
+}
+
+/**
+ * Get the user's eth address for a non-zkEVM chain.
+ */
+function getUserChainAddress(user: User, chain: SequenceChain): string | undefined {
+  const chainData = (user as any)[chain];
+  return chainData?.ethAddress;
+}
+
+export class SequenceProvider implements Provider {
+  readonly #auth: Auth;
+
+  readonly #chainConfig: ChainConfig;
+
+  readonly #multiRollupApiClients: MultiRollupApiClients;
+
+  readonly #rpcProvider: PublicClient;
+
+  readonly #providerEventEmitter: TypedEventEmitter<ProviderEventMap>;
+
+  readonly #guardianClient: GuardianClient;
+
+  readonly #ethSigner: SequenceSigner;
+
+  readonly #evmChain: SequenceChain;
+
+  public readonly isPassport: boolean = true;
+
+  constructor({
+    auth,
+    chainConfig,
+    multiRollupApiClients,
+    guardianClient,
+    ethSigner,
+    passportEventEmitter,
+  }: SequenceProviderInput) {
+    // Validate this is not a zkEVM chain
+    const evmChain = getEvmChainFromChainId(chainConfig.chainId);
+    if (evmChain === EvmChain.ZKEVM) {
+      throw new Error('SequenceProvider cannot be used for zkEVM chains. Use ZkEvmProvider instead.');
+    }
+    this.#evmChain = evmChain;
+
+    this.#auth = auth;
+    this.#chainConfig = chainConfig;
+    this.#multiRollupApiClients = multiRollupApiClients;
+    this.#guardianClient = guardianClient;
+    this.#ethSigner = ethSigner;
+    this.#providerEventEmitter = passportEventEmitter;
+
+    // Create PublicClient for reading from the chain using viem
+    this.#rpcProvider = createPublicClient({
+      transport: http(this.#chainConfig.rpcUrl),
+    });
+  }
+
+  /**
+   * Get the user's address for this chain if already registered.
+   */
+  async #getChainAddress(): Promise<string | undefined> {
+    const user = await this.#auth.getUser();
+    if (user && isUserRegisteredForChain(user, this.#evmChain)) {
+      return getUserChainAddress(user, this.#evmChain);
+    }
+    return undefined;
+  }
+
+  async #performRequest(request: RequestArguments): Promise<any> {
+    switch (request.method) {
+      case 'eth_requestAccounts': {
+        // Check if already registered
+        const existingAddress = await this.#getChainAddress();
+        if (existingAddress) return [existingAddress];
+
+        const flow = trackFlow('passport', 'ethRequestAccounts');
+
+        try {
+          const user = await this.#auth.getUserOrLogin();
+          flow.addEvent('endGetUserOrLogin');
+
+          let userEthAddress: string | undefined;
+
+          if (!isUserRegisteredForChain(user, this.#evmChain)) {
+            flow.addEvent('startUserRegistration');
+
+            userEthAddress = await registerUser({
+              auth: this.#auth,
+              ethSigner: this.#ethSigner,
+              multiRollupApiClients: this.#multiRollupApiClients,
+              accessToken: user.accessToken,
+              rpcProvider: this.#rpcProvider,
+              flow,
+            });
+            flow.addEvent('endUserRegistration');
+          } else {
+            userEthAddress = getUserChainAddress(user, this.#evmChain);
+          }
+
+          if (!userEthAddress) {
+            throw new JsonRpcError(
+              RpcErrorCode.INTERNAL_ERROR,
+              'Failed to get user address after registration',
+            );
+          }
+
+          this.#providerEventEmitter.emit(ProviderEvent.ACCOUNTS_CHANGED, [
+            userEthAddress,
+          ]);
+          identify({
+            passportId: user.profile.sub,
+          });
+          return [userEthAddress];
+        } catch (error) {
+          if (error instanceof Error) {
+            trackError('passport', 'ethRequestAccounts', error, { flowId: flow.details.flowId });
+          } else {
+            flow.addEvent('errored');
+          }
+          throw error;
+        } finally {
+          flow.addEvent('End');
+        }
+      }
+
+      case 'eth_accounts': {
+        const address = await this.#getChainAddress();
+        return address ? [address] : [];
+      }
+
+      // TODO: Implement eth_sendTransaction
+      case 'eth_sendTransaction': {
+        throw new JsonRpcError(
+          ProviderErrorCode.UNSUPPORTED_METHOD,
+          'eth_sendTransaction not yet implemented for this chain',
+        );
+      }
+
+      // TODO: Implement personal_sign
+      case 'personal_sign': {
+        throw new JsonRpcError(
+          ProviderErrorCode.UNSUPPORTED_METHOD,
+          'personal_sign not yet implemented for this chain',
+        );
+      }
+
+      // TODO: Implement eth_signTypedData
+      case 'eth_signTypedData':
+      case 'eth_signTypedData_v4': {
+        throw new JsonRpcError(
+          ProviderErrorCode.UNSUPPORTED_METHOD,
+          'eth_signTypedData not yet implemented for this chain',
+        );
+      }
+
+      case 'eth_chainId': {
+        const chainId = await this.#rpcProvider.getChainId();
+        return toHex(chainId);
+      }
+
+      // Pass through methods
+      case 'eth_getBalance':
+      case 'eth_getCode':
+      case 'eth_getTransactionCount': {
+        const [address, blockNumber] = request.params || [];
+        return this.#rpcProvider.request({
+          method: request.method as any,
+          params: [address, blockNumber || 'latest'],
+        });
+      }
+
+      case 'eth_getStorageAt': {
+        const [address, storageSlot, blockNumber] = request.params || [];
+        return this.#rpcProvider.request({
+          method: 'eth_getStorageAt',
+          params: [address, storageSlot, blockNumber || 'latest'],
+        });
+      }
+
+      case 'eth_call':
+      case 'eth_estimateGas': {
+        const [transaction, blockNumber] = request.params || [];
+        return this.#rpcProvider.request({
+          method: request.method as any,
+          params: [transaction, blockNumber || 'latest'],
+        });
+      }
+
+      case 'eth_gasPrice':
+      case 'eth_blockNumber':
+      case 'eth_getBlockByHash':
+      case 'eth_getBlockByNumber':
+      case 'eth_getTransactionByHash':
+      case 'eth_getTransactionReceipt': {
+        return this.#rpcProvider.request({
+          method: request.method as any,
+          params: (request.params || []) as any,
+        });
+      }
+
+      default: {
+        throw new JsonRpcError(
+          ProviderErrorCode.UNSUPPORTED_METHOD,
+          'Method not supported',
+        );
+      }
+    }
+  }
+
+  public async request(request: RequestArguments): Promise<any> {
+    try {
+      return this.#performRequest(request);
+    } catch (error: unknown) {
+      if (error instanceof JsonRpcError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, error.message);
+      }
+
+      throw new JsonRpcError(RpcErrorCode.INTERNAL_ERROR, 'Internal error');
+    }
+  }
+
+  public on(event: string, listener: (...args: any[]) => void): void {
+    this.#providerEventEmitter.on(event, listener);
+  }
+
+  public removeListener(
+    event: string,
+    listener: (...args: any[]) => void,
+  ): void {
+    this.#providerEventEmitter.removeListener(event, listener);
+  }
+}