@swapkit/wallet-hardware 4.8.1 → 4.8.3

package/src/trezor/evmSigner.ts

@@ -0,0 +1,210 @@
+import {
+  type Chain,
+  ChainToChainId,
+  type DerivationPathArray,
+  derivationPathToString,
+  SwapKitError,
+  SwapKitNumber,
+  WalletOption,
+} from "@swapkit/helpers";
+import type { JsonRpcProvider, Provider, TransactionRequest, TypedDataDomain, TypedDataField } from "ethers";
+
+type TrezorEVMSignerParams = {
+  chain: Chain;
+  derivationPath: DerivationPathArray;
+  provider: Provider | JsonRpcProvider;
+};
+
+export async function getEVMSigner({ chain, derivationPath, provider }: TrezorEVMSignerParams) {
+  const { AbstractSigner, Signature } = await import("ethers");
+
+  class TrezorSigner extends AbstractSigner {
+    address: string;
+    chain: Chain;
+    derivationPath: DerivationPathArray;
+    readonly provider: Provider | JsonRpcProvider;
+
+    constructor({ chain, derivationPath, provider }: TrezorEVMSignerParams) {
+      super(provider);
+
+      this.address = "";
+      this.chain = chain;
+      this.derivationPath = derivationPath;
+      this.provider = provider;
+    }
+
+    getAddress = async () => {
+      if (!this.address) {
+        const TrezorConnect = (await import("@trezor/connect-web")).default;
+
+        const result = await TrezorConnect.ethereumGetAddress({
+          path: derivationPathToString(this.derivationPath),
+          showOnTrezor: true,
+        });
+
+        if (!result.success) {
+          throw new SwapKitError({
+            errorKey: "wallet_trezor_failed_to_get_address",
+            info: { ...result, chain: this.chain, derivationPath: this.derivationPath },
+          });
+        }
+
+        this.address = result.payload.address;
+      }
+
+      return this.address;
+    };
+
+    signMessage = async (message: string) => {
+      const TrezorConnect = (await import("@trezor/connect-web")).default;
+
+      const result = await TrezorConnect.ethereumSignMessage({
+        message,
+        path: derivationPathToString(this.derivationPath),
+      });
+
+      if (!result.success) {
+        throw new SwapKitError({
+          errorKey: "wallet_trezor_failed_to_sign_transaction",
+          info: { ...result, chain: this.chain, derivationPath: this.derivationPath, message },
+        });
+      }
+
+      return result.payload.signature;
+    };
+
+    signTypedData = async (
+      domain: TypedDataDomain,
+      types: Record<string, TypedDataField[]>,
+      value: Record<string, unknown>,
+      explicitPrimaryType?: string,
+    ) => {
+      const TrezorConnect = (await import("@trezor/connect-web")).default;
+      const { buildEIP712DomainType } = await import("@swapkit/toolboxes/evm");
+      const { TypedDataEncoder } = await import("ethers");
+
+      const { EIP712Domain: _, ...filteredTypes } = types;
+      const primaryType = explicitPrimaryType ?? TypedDataEncoder.from(filteredTypes).primaryType;
+      const domainTypes = buildEIP712DomainType(domain);
+
+      const data = {
+        domain: domain as Record<string, unknown>,
+        message: value,
+        primaryType,
+        types: { EIP712Domain: domainTypes, ...filteredTypes },
+      };
+
+      const result = await TrezorConnect.ethereumSignTypedData({
+        data: data as Parameters<typeof TrezorConnect.ethereumSignTypedData>[0]["data"],
+        metamask_v4_compat: true,
+        path: derivationPathToString(this.derivationPath),
+      });
+
+      if (!result.success) {
+        throw new SwapKitError({
+          errorKey: "wallet_trezor_failed_to_sign_transaction",
+          info: { chain: this.chain, error: result.payload.error },
+        });
+      }
+
+      return result.payload.signature.startsWith("0x") ? result.payload.signature : `0x${result.payload.signature}`;
+    };
+
+    signTransaction = async ({
+      to,
+      gasLimit,
+      value,
+      data,
+      nonce,
+      maxFeePerGas,
+      maxPriorityFeePerGas,
+      gasPrice,
+      // biome-ignore lint/complexity/noExcessiveCognitiveComplexity: any: refactor
+    }: TransactionRequest) => {
+      if (!to) throw new SwapKitError({ errorKey: "wallet_missing_params", info: { to } });
+      if (!gasLimit) throw new SwapKitError({ errorKey: "wallet_missing_params", info: { gasLimit } });
+
+      const isEIP1559 = maxFeePerGas && maxPriorityFeePerGas;
+
+      if (isEIP1559 && !maxFeePerGas) {
+        throw new SwapKitError({ errorKey: "wallet_missing_params", info: { maxFeePerGas } });
+      }
+      if (isEIP1559 && !maxPriorityFeePerGas) {
+        throw new SwapKitError({ errorKey: "wallet_missing_params", info: { maxPriorityFeePerGas } });
+      }
+      if (!(isEIP1559 || gasPrice)) {
+        throw new SwapKitError({ errorKey: "wallet_missing_params", info: { gasPrice } });
+      }
+
+      const TrezorConnect = (await import("@trezor/connect-web")).default;
+      const { toHexString } = await import("@swapkit/toolboxes/evm");
+      const { Transaction } = await import("ethers");
+
+      const additionalFields = isEIP1559
+        ? {
+            maxFeePerGas: toHexString(BigInt(maxFeePerGas?.toString() || 0)),
+            maxPriorityFeePerGas: toHexString(BigInt(maxPriorityFeePerGas?.toString() || 0)),
+          }
+        : (gasPrice && { gasPrice: toHexString(BigInt(gasPrice?.toString() || 0)) }) || { gasPrice: "0x0" };
+
+      const hexifiedNonce = toHexString(
+        BigInt(nonce || (await this.provider.getTransactionCount(await this.getAddress(), "pending"))),
+      );
+
+      const formattedTx = {
+        chainId: Number.parseInt(ChainToChainId[this.chain], 10),
+        data: data?.toString() || "0x",
+        gasLimit: toHexString(BigInt(gasLimit?.toString() || 0)),
+        nonce: hexifiedNonce,
+        to: to.toString(),
+        value: toHexString(BigInt(value?.toString() || 0)),
+        ...additionalFields,
+      };
+
+      const { success, payload } = await TrezorConnect.ethereumSignTransaction({
+        path: derivationPathToString(this.derivationPath),
+        transaction: formattedTx,
+      });
+
+      if (!success) {
+        throw new SwapKitError({
+          errorKey: "wallet_trezor_failed_to_sign_transaction",
+          info: { ...payload, chain: this.chain, derivationPath: this.derivationPath },
+        });
+      }
+
+      const { r, s, v } = payload;
+
+      const signature = Signature.from({ r, s, v: new SwapKitNumber(BigInt(v)).getBaseValue("number") });
+
+      const serializedTx = Transaction.from({
+        ...formattedTx,
+        nonce: Number.parseInt(formattedTx.nonce, 16),
+        signature,
+        type: isEIP1559 ? 2 : 0,
+      }).serialized;
+
+      if (!serializedTx) {
+        throw new SwapKitError({
+          errorKey: "wallet_trezor_failed_to_sign_transaction",
+          info: { chain: this.chain, derivationPath: this.derivationPath },
+        });
+      }
+
+      return serializedTx;
+    };
+
+    connect = (provider: Provider | null) => {
+      if (!provider) {
+        throw new SwapKitError({
+          errorKey: "wallet_provider_not_found",
+          info: { chain: this.chain, derivationPath: this.derivationPath, wallet: WalletOption.TREZOR },
+        });
+      }
+
+      return new TrezorSigner({ chain: this.chain, derivationPath: this.derivationPath, provider });
+    };
+  }
+
+  return new TrezorSigner({ chain, derivationPath, provider });
+}