@imtbl/wallet 2.12.7-alpha.1 → 2.12.7-alpha.11

package/src/sequence/signer/privateKeySigner.ts

@@ -1,112 +0,0 @@
-import { keccak256, toBytes } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-import { WalletError, WalletErrorType } from '../../errors';
-import { User } from '@imtbl/auth';
-import { Signers } from '@0xsequence/wallet-core';
-import {
-  Payload,
-  Signature as SequenceSignature,
-} from '@0xsequence/wallet-primitives';
-import { SequenceSigner } from './types';
-import { Address } from 'ox';
-import { GetUserFunction } from '../../types';
-
-interface PrivateKeyWallet {
-  userIdentifier: string;
-  signerAddress: string;
-  signer: Signers.Pk.Pk;
-  privateKey: `0x${string}`;
-}
-
-/**
- * Private key signer for dev environments (behind VPN).
- * Uses a deterministic private key derived from the user's sub.
- */
-export class PrivateKeySigner implements SequenceSigner {
-  readonly #getUser: GetUserFunction;
-
-  #privateKeyWallet: PrivateKeyWallet | null = null;
-
-  #createWalletPromise: Promise<PrivateKeyWallet> | null = null;
-
-  constructor(getUser: GetUserFunction) {
-    this.#getUser = getUser;
-  }
-
-  async #getUserOrThrow(): Promise<User> {
-    const user = await this.#getUser();
-    if (!user) {
-      throw new WalletError('User not authenticated', WalletErrorType.NOT_LOGGED_IN_ERROR);
-    }
-    return user;
-  }
-
-  async #getWalletInstance(): Promise<PrivateKeyWallet> {
-    let privateKeyWallet = this.#privateKeyWallet;
-    if (!privateKeyWallet) {
-      privateKeyWallet = await this.#createWallet();
-    }
-
-    const user = await this.#getUserOrThrow();
-    if (user.profile.sub !== privateKeyWallet.userIdentifier) {
-      privateKeyWallet = await this.#createWallet(user);
-    }
-
-    return privateKeyWallet;
-  }
-
-  async #createWallet(user?: User): Promise<PrivateKeyWallet> {
-    if (this.#createWalletPromise) return this.#createWalletPromise;
-
-    this.#createWalletPromise = (async () => {
-      try {
-        this.#privateKeyWallet = null;
-        const authenticatedUser = user || (await this.#getUserOrThrow());
-
-        const privateKeyHash = keccak256(toBytes(`${authenticatedUser.profile.sub}-sequence`));
-        const signer = new Signers.Pk.Pk(privateKeyHash);
-        const signerAddress = signer.address;
-
-        this.#privateKeyWallet = {
-          userIdentifier: authenticatedUser.profile.sub,
-          signerAddress,
-          signer,
-          privateKey: privateKeyHash,
-        };
-
-        return this.#privateKeyWallet;
-      } catch (error) {
-        const errorMessage = `Failed to create private key wallet: ${(error as Error).message}`;
-        throw new WalletError(errorMessage, WalletErrorType.WALLET_CONNECTION_ERROR);
-      } finally {
-        this.#createWalletPromise = null;
-      }
-    })();
-
-    return this.#createWalletPromise;
-  }
-
-  async getAddress(): Promise<string> {
-    const wallet = await this.#getWalletInstance();
-    return wallet.signerAddress;
-  }
-
-  async signPayload(
-    walletAddress: Address.Address,
-    chainId: number,
-    payload: Payload.Parented,
-  ): Promise<SequenceSignature.SignatureOfSignerLeaf> {
-    const pkWallet = await this.#getWalletInstance();
-    return pkWallet.signer.sign(walletAddress, chainId, payload);
-  }
-
-  async signMessage(message: string | Uint8Array): Promise<string> {
-    const pkWallet = await this.#getWalletInstance();
-
-    // Use viem's account to sign
-    const account = privateKeyToAccount(pkWallet.privateKey);
-    const messageToSign = typeof message === 'string' ? message : { raw: message };
-
-    return await account.signMessage({ message: messageToSign });
-  }
-}

package/src/sequence/signer/types.ts

@@ -1,24 +0,0 @@
-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/src/sequence/user/index.ts

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

package/src/sequence/user/registerUser.ts

@@ -1,101 +0,0 @@
-import { MultiRollupApiClients } from '@imtbl/generated-clients';
-import { Flow } from '@imtbl/metrics';
-import type { PublicClient } from 'viem';
-import { getEip155ChainId } from '../../zkEvm/walletHelpers';
-import { JsonRpcError, RpcErrorCode } from '../../zkEvm/JsonRpcError';
-import { SequenceSigner } from '../signer';
-import { GetUserFunction } from '../../types';
-
-export type RegisterUserInput = {
-  getUser: GetUserFunction;
-  ethSigner: SequenceSigner;
-  multiRollupApiClients: MultiRollupApiClients;
-  accessToken: string;
-  rpcProvider: PublicClient;
-  flow: Flow;
-};
-
-const MESSAGE_TO_SIGN = 'Only sign this message from Immutable Passport';
-
-/**
- * Format the signature for the registration API.
- * Converts v value from 27/28 format to 0/1 recovery param format.
- */
-function formatSignature(signature: string): string {
-  const sig = signature.startsWith('0x') ? signature.slice(2) : signature;
-  const r = sig.substring(0, 64);
-  const s = sig.substring(64, 128);
-  const v = sig.substring(128, 130);
-
-  const vNum = parseInt(v, 16);
-  const recoveryParam = vNum >= 27 ? vNum - 27 : vNum;
-  const vHex = recoveryParam.toString(16).padStart(2, '0');
-
-  return `0x${r}${s}${vHex}`;
-}
-
-/**
- * Register a user for a non-zkEVM chain (e.g., Arbitrum).
- * Creates a counterfactual address for the user on the specified chain.
- */
-export async function registerUser({
-  getUser,
-  ethSigner,
-  multiRollupApiClients,
-  accessToken,
-  rpcProvider,
-  flow,
-}: RegisterUserInput): Promise<string> {
-  // Parallelize the operations that can happen concurrently
-  const getAddressPromise = ethSigner.getAddress();
-  getAddressPromise.then(() => flow.addEvent('endGetAddress'));
-
-  const signMessagePromise = ethSigner.signMessage(MESSAGE_TO_SIGN).then(formatSignature);
-  signMessagePromise.then(() => flow.addEvent('endSignRaw'));
-
-  const detectNetworkPromise = rpcProvider.getChainId();
-  detectNetworkPromise.then(() => flow.addEvent('endDetectNetwork'));
-
-  const listChainsPromise = multiRollupApiClients.chainsApi.listChains();
-  listChainsPromise.then(() => flow.addEvent('endListChains'));
-
-  const [ethereumAddress, ethereumSignature, chainId, chainListResponse] = await Promise.all([
-    getAddressPromise,
-    signMessagePromise,
-    detectNetworkPromise,
-    listChainsPromise,
-  ]);
-
-  const eipChainId = getEip155ChainId(Number(chainId));
-  const chainName = chainListResponse.data?.result?.find((chain) => chain.id === eipChainId)?.name;
-  if (!chainName) {
-    throw new JsonRpcError(
-      RpcErrorCode.INTERNAL_ERROR,
-      `Chain name does not exist for chain id ${chainId}`,
-    );
-  }
-
-  try {
-    const registrationResponse = await multiRollupApiClients.passportApi.createCounterfactualAddressV2({
-      chainName,
-      createCounterfactualAddressRequest: {
-        ethereum_address: ethereumAddress,
-        ethereum_signature: ethereumSignature,
-      },
-    }, {
-      headers: { Authorization: `Bearer ${accessToken}` },
-    });
-    flow.addEvent('endCreateCounterfactualAddress');
-
-    // Trigger background refresh to get updated user data with the new chain registration
-    getUser(true).catch(() => {});
-
-    return registrationResponse.data.counterfactual_address;
-  } catch (error) {
-    flow.addEvent('errorRegisteringUser');
-    throw new JsonRpcError(
-      RpcErrorCode.INTERNAL_ERROR,
-      `Failed to create counterfactual address: ${error}`,
-    );
-  }
-}