@swapkit/wallet-hardware 4.9.34 → 4.11.0

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

@@ -15,9 +15,9 @@ export declare const trezorWallet: {
         }) => (chains: Chain[], derivationPath: readonly [44, 118, 0, 0, 0] | readonly [44, 931, 0, 0, 0] | readonly [number, number, number, number, number] | readonly [44, 683, 0, 0] | readonly [44, 637, 0, 0, 0] | readonly [44, 60, 0, 0, 0] | readonly [44, 397, 0, 0, 0] | readonly [0, 0, 0, 0, 0] | readonly [44, 144, 0, 0, 0] | readonly [44, 501, 0, 0, 0] | readonly [8797555, 1, 0, 0, 0] | readonly [44, 607, 0, 0, 0] | readonly [44, 195, 0, 0, 0] | readonly [44, 148, 0, 0, 0] | readonly [44, 784, 0, 0, 0] | readonly [1852, 1815, 0, 0, 0] | readonly [44, 9004, 0, 0, 0] | readonly [number, number, number, number, (number | undefined)?] | readonly [44, 145, 0, 0, 0] | readonly [84, 2, 0, 0, 0] | readonly [44, 3, 0, 0, 0] | readonly [44, 5, 0, 0, 0] | readonly [44, 133, 0, 0, 0], params_2?: ConnectTrezorOptions | undefined) => Promise<boolean>;
         directSigningSupport: import("@swapkit/wallet-core").DirectSigningSupport;
         getExtendedPublicKey?: import("@swapkit/wallet-core").GetExtendedPublicKey;
-        supportedChains: (Chain.Arbitrum | Chain.Aurora | Chain.Avalanche | Chain.Base | Chain.Berachain | Chain.BinanceSmartChain | Chain.Bitcoin | Chain.BitcoinCash | Chain.Dash | Chain.Dogecoin | Chain.Ethereum | Chain.Gnosis | Chain.Litecoin | Chain.Monad | Chain.Optimism | Chain.Polygon | Chain.XLayer | Chain.Zcash)[];
+        supportedChains: (Chain.Arbitrum | Chain.Arc | Chain.Aurora | Chain.Avalanche | Chain.Base | Chain.Berachain | Chain.BinanceSmartChain | Chain.Bitcoin | Chain.BitcoinCash | Chain.Dash | Chain.Dogecoin | Chain.Ethereum | Chain.Gnosis | Chain.Litecoin | Chain.Monad | Chain.Optimism | Chain.Polygon | Chain.XLayer | Chain.Zcash)[];
     };
 };
-export declare const TREZOR_SUPPORTED_CHAINS: (Chain.Arbitrum | Chain.Aurora | Chain.Avalanche | Chain.Base | Chain.Berachain | Chain.BinanceSmartChain | Chain.Bitcoin | Chain.BitcoinCash | Chain.Dash | Chain.Dogecoin | Chain.Ethereum | Chain.Gnosis | Chain.Litecoin | Chain.Monad | Chain.Optimism | Chain.Polygon | Chain.XLayer | Chain.Zcash)[];
+export declare const TREZOR_SUPPORTED_CHAINS: (Chain.Arbitrum | Chain.Arc | Chain.Aurora | Chain.Avalanche | Chain.Base | Chain.Berachain | Chain.BinanceSmartChain | Chain.Bitcoin | Chain.BitcoinCash | Chain.Dash | Chain.Dogecoin | Chain.Ethereum | Chain.Gnosis | Chain.Litecoin | Chain.Monad | Chain.Optimism | Chain.Polygon | Chain.XLayer | Chain.Zcash)[];
 export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/types/trezor/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/trezor/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,EACL,KAAK,mBAAmB,EAQxB,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAC;AAa1B,OAAO,EAA0C,KAAK,6BAA6B,EAAE,MAAM,sBAAsB,CAAC;AAKlH,KAAK,oBAAoB,GAAG;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAgIjD,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,UA6B9E;AAqED,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,2BAS1E;AAg9BD,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,KAAK,EACZ,cAAc,CAAC,EAAE,mBAAmB,EACpC,EAAE,YAAY,EAAE,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/C,OAAO,CAAC,6BAA6B,GAAG,SAAS,CAAC,CA0CpD;AAED,eAAO,MAAM,YAAY;;;;;;;;;CA+GvB,CAAC;AAEH,eAAO,MAAM,uBAAuB,6SAAyC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/trezor/index.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,EACL,KAAK,mBAAmB,EAQxB,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAC;AAa1B,OAAO,EAA0C,KAAK,6BAA6B,EAAE,MAAM,sBAAsB,CAAC;AAKlH,KAAK,oBAAoB,GAAG;IAAE,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAgIjD,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,UA6B9E;AAqED,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,2BAS1E;AAi9BD,wBAAsB,0BAA0B,CAC9C,KAAK,EAAE,KAAK,EACZ,cAAc,CAAC,EAAE,mBAAmB,EACpC,EAAE,YAAY,EAAE,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,CAAA;CAAO,GAC/C,OAAO,CAAC,6BAA6B,GAAG,SAAS,CAAC,CA0CpD;AAED,eAAO,MAAM,YAAY;;;;;;;;;CAiHvB,CAAC;AAEH,eAAO,MAAM,uBAAuB,yTAAyC,CAAC"}

package/package.json

@@ -9,7 +9,7 @@
     "@ledgerhq/errors": "~6.29.0",
     "@ledgerhq/hw-app-btc": "~10.17.0",
     "@ledgerhq/hw-app-cosmos": "~6.33.0",
-    "@ledgerhq/hw-app-eth": "~7.4.2",
+    "@ledgerhq/hw-app-eth": "~7.8.18",
     "@ledgerhq/hw-app-near": "~6.32.0",
     "@ledgerhq/hw-app-sui": "~1.5.0",
     "@ledgerhq/hw-app-trx": "~6.32.0",
@@ -22,10 +22,10 @@
     "@near-js/transactions": "~2.5.0",
     "@scure/base": "2.2.0",
     "@scure/bip32": "2.2.0",
-    "@swapkit/helpers": "^5.2.1",
-    "@swapkit/toolboxes": "^5.2.1",
-    "@swapkit/utxo-signer": "^3.0.0",
-    "@swapkit/wallet-core": "^5.0.5",
+    "@swapkit/helpers": "^5.4.1",
+    "@swapkit/toolboxes": "^5.4.1",
+    "@swapkit/utxo-signer": "^3.1.0",
+    "@swapkit/wallet-core": "^5.0.8",
     "@trezor/connect-web": "~9.7.3",
     "cosmjs-types": "~0.10.1",
     "ethers": "^6.14.0",
@@ -44,7 +44,7 @@
     "@ledgerhq/errors": "6.29.0",
     "@ledgerhq/hw-app-btc": "10.17.0",
     "@ledgerhq/hw-app-cosmos": "6.33.0",
-    "@ledgerhq/hw-app-eth": "7.4.2",
+    "@ledgerhq/hw-app-eth": "7.8.18",
     "@ledgerhq/hw-app-near": "6.32.0",
     "@ledgerhq/hw-app-sui": "1.5.0",
     "@ledgerhq/hw-app-trx": "6.32.0",
@@ -109,5 +109,5 @@
     "type-check:go": "tsgo"
   },
   "type": "module",
-  "version": "4.9.34"
+  "version": "4.11.0"
 }

package/src/ledger/clients/evm.ts

@@ -16,6 +16,32 @@ import {
 } from "ethers";
 
 import { getLedgerTransport } from "../helpers/getLedgerTransport";
+import {
+  fetchLedgerNetworkCertificate,
+  fetchLedgerNetworkDescriptor,
+  provideLedgerCertificate,
+  provideLedgerNetworkInformation,
+} from "../helpers/ledgerNetworkInfo";
+
+const LEDGER_INCORRECT_DATA = 0x6a80;
+
+const ARC_CHAIN_ID = Number(ChainId.Arc);
+
+type LedgerTransactionResolution = Awaited<
+  ReturnType<typeof import("@ledgerhq/hw-app-eth")["ledgerService"]["resolveTransaction"]>
+>;
+
+function isLedgerIncorrectDataError(error: unknown) {
+  return (
+    error instanceof Error &&
+    "statusCode" in error &&
+    (error as { statusCode: number }).statusCode === LEDGER_INCORRECT_DATA
+  );
+}
+
+function hasClearSigningPayload(resolution: LedgerTransactionResolution | null) {
+  return Object.values(resolution ?? {}).some((entries) => Array.isArray(entries) && entries.length);
+}
 
 function parseLedgerSignatureV(v: number | string) {
   if (typeof v === "number") return v;
@@ -31,6 +57,7 @@ class EVMLedgerInterface extends AbstractSigner {
   ledgerTimeout = 50000;
   private transport?: Transport;
   private readonly injectedTransport?: Transport;
+  private arcNetworkRegistered = false;
 
   constructor({
     provider,
@@ -172,9 +199,22 @@ class EVMLedgerInterface extends AbstractSigner {
 
     const { ledgerService } = await import("@ledgerhq/hw-app-eth");
 
-    const resolution = await ledgerService.resolveTransaction(unsignedTx, {}, { erc20: true, externalPlugins: true });
+    const chainId = Number(baseTx.chainId);
+    const isArc = chainId === ARC_CHAIN_ID;
+
+    const resolution = await ledgerService
+      .resolveTransaction(unsignedTx, {}, { erc20: true, externalPlugins: true })
+      .catch((error) => {
+        if (!isArc) throw error;
+
+        console.warn("Ledger: could not fetch clear-signing metadata for Arc, signing blind");
+
+        return null;
+      });
+
+    if (isArc && !this.arcNetworkRegistered) await this.registerNetworkOnDevice(chainId);
 
-    const signature = await this.ledgerApp?.signTransaction(this.derivationPath, unsignedTx, resolution);
+    const signature = await this.signWithLedgerApp(unsignedTx, resolution, chainId);
 
     if (!signature) throw new SwapKitError("wallet_ledger_signing_error");
 
@@ -183,12 +223,55 @@ class EVMLedgerInterface extends AbstractSigner {
     return Transaction.from({ ...baseTx, signature: { r: `0x${r}`, s: `0x${s}`, v: parseLedgerSignatureV(v) } })
       .serialized;
   };
+
+  private signWithLedgerApp = async (
+    unsignedTx: string,
+    resolution: LedgerTransactionResolution | null,
+    chainId: number,
+  ) => {
+    try {
+      return await this.ledgerApp?.signTransaction(this.derivationPath, unsignedTx, resolution);
+    } catch (error) {
+      const canSignBlind =
+        chainId === ARC_CHAIN_ID && isLedgerIncorrectDataError(error) && hasClearSigningPayload(resolution);
+
+      if (!canSignBlind) throw error;
+
+      console.warn("Ledger: the app rejected the Arc metadata, signing blind");
+
+      return await this.ledgerApp?.signTransaction(this.derivationPath, unsignedTx, null);
+    }
+  };
+
+  private registerNetworkOnDevice = async (chainId: number) => {
+    const deviceModelId = this.transport?.deviceModel?.id;
+
+    if (!(this.transport && deviceModelId)) return;
+
+    try {
+      const [descriptor, certificate] = await Promise.all([
+        fetchLedgerNetworkDescriptor(chainId, deviceModelId),
+        fetchLedgerNetworkCertificate(deviceModelId),
+      ]);
+
+      if (!descriptor) return;
+
+      if (certificate) await provideLedgerCertificate(this.transport, certificate);
+
+      await provideLedgerNetworkInformation(this.transport, descriptor);
+
+      this.arcNetworkRegistered = true;
+    } catch {
+      // the app will reject the metadata and signWithLedgerApp falls back to blind signing
+    }
+  };
 }
 
 type LedgerParams = { provider: Provider; derivationPath?: DerivationPathArray; transport?: Transport };
 
 export const ArbitrumLedger = (params: LedgerParams) =>
   new EVMLedgerInterface({ ...params, chainId: ChainId.Arbitrum });
+export const ArcLedger = (params: LedgerParams) => new EVMLedgerInterface({ ...params, chainId: ChainId.Arc });
 export const AuroraLedger = (params: LedgerParams) => new EVMLedgerInterface({ ...params, chainId: ChainId.Aurora });
 export const AvalancheLedger = (params: LedgerParams) =>
   new EVMLedgerInterface({ ...params, chainId: ChainId.Avalanche });

package/src/ledger/helpers/getLedgerAddress.ts

@@ -31,6 +31,7 @@ export const getLedgerAddress = async <
     case Chain.Avalanche:
     case Chain.Polygon:
     case Chain.Arbitrum:
+    case Chain.Arc:
     case Chain.Berachain:
     case Chain.Optimism:
     case Chain.Base:

package/src/ledger/helpers/getLedgerClient.ts

@@ -4,6 +4,7 @@ import { Chain, type DerivationPathArray, type EVMChain, SwapKitError, WalletOpt
 import { CosmosLedger } from "../clients/cosmos";
 import {
   ArbitrumLedger,
+  ArcLedger,
   AuroraLedger,
   AvalancheLedger,
   BaseLedger,
@@ -32,6 +33,7 @@ import { XRPLedger } from "../clients/xrp";
 
 type LedgerSignerMap = {
   [Chain.Arbitrum]: ReturnType<typeof ArbitrumLedger>;
+  [Chain.Arc]: ReturnType<typeof ArcLedger>;
   [Chain.Aurora]: ReturnType<typeof AuroraLedger>;
   [Chain.Avalanche]: ReturnType<typeof AvalancheLedger>;
   [Chain.Base]: ReturnType<typeof BaseLedger>;
@@ -94,6 +96,7 @@ export const getLedgerClient = async <T extends LedgerSupportedChain>({
       })
       .with(
         Chain.Arbitrum,
+        Chain.Arc,
         Chain.Aurora,
         Chain.Avalanche,
         Chain.Berachain,
@@ -113,6 +116,7 @@ export const getLedgerClient = async <T extends LedgerSupportedChain>({
             .with(Chain.BinanceSmartChain, () => BinanceSmartChainLedger(params) as LedgerSignerMap[T])
             .with(Chain.Avalanche, () => AvalancheLedger(params) as LedgerSignerMap[T])
             .with(Chain.Arbitrum, () => ArbitrumLedger(params) as LedgerSignerMap[T])
+            .with(Chain.Arc, () => ArcLedger(params) as LedgerSignerMap[T])
             .with(Chain.Berachain, () => BerachainLedger(params) as LedgerSignerMap[T])
             .with(Chain.Optimism, () => OptimismLedger(params) as LedgerSignerMap[T])
             .with(Chain.Polygon, () => PolygonLedger(params) as LedgerSignerMap[T])

package/src/ledger/helpers/ledgerNetworkInfo.ts

@@ -0,0 +1,127 @@
+import type Transport from "@ledgerhq/hw-transport";
+
+const LEDGER_CAL_SERVICE_URL = "https://crypto-assets-service.api.ledger.com/v1";
+
+const LEDGER_DEVICE_TO_CAL_MODEL: Record<string, string> = {
+  apex: "apexp",
+  europa: "flex",
+  nanoS: "nanos",
+  nanoSP: "nanosp",
+  nanoX: "nanox",
+  stax: "stax",
+};
+
+const APDU_CLA = 0xe0;
+const APDU_CLA_PKI = 0xb0;
+const APDU_INS_LOAD_CERTIFICATE = 0x06;
+const LEDGER_KEY_USAGE_NETWORK = 0x0c;
+const APDU_INS_PROVIDE_NETWORK_INFORMATION = 0x30;
+const APDU_P1_FIRST_CHUNK = 0x01;
+const APDU_P1_FOLLOWING_CHUNK = 0x00;
+const APDU_P2_NETWORK_CONFIG = 0x00;
+const APDU_P2_NETWORK_ICON = 0x01;
+const APDU_MAX_CHUNK_SIZE = 0xff;
+const TLV_TAG_DER_SIGNATURE = 0x15;
+
+export type LedgerNetworkDescriptor = { data: string; icon?: string; signature: string };
+
+type CalNetwork = {
+  chain_id: number;
+  descriptors?: Record<string, { data?: string; signatures?: { prod?: string } }>;
+  icons?: Record<string, string>;
+};
+
+export async function fetchLedgerNetworkCertificate(
+  deviceModelId: string,
+  fetchFn: typeof fetch = fetch,
+): Promise<string | null> {
+  const calModel = LEDGER_DEVICE_TO_CAL_MODEL[deviceModelId];
+  if (!calModel) return null;
+
+  const url = `${LEDGER_CAL_SERVICE_URL}/certificates?output=descriptor&public_key_usage=network&target_device=${calModel}`;
+  const response = await fetchFn(url);
+  if (!response.ok) return null;
+
+  const certificates = (await response.json()) as Array<{
+    descriptor?: { data?: string; signatures?: { prod?: string } };
+  }>;
+  const descriptor = certificates[0]?.descriptor;
+  const signature = descriptor?.signatures?.prod;
+
+  if (!(descriptor?.data && signature)) return null;
+
+  return `${descriptor.data}${appendSignatureTlv(signature)}`;
+}
+
+export async function provideLedgerCertificate(transport: Transport, payloadHex: string) {
+  await transport.send(
+    APDU_CLA_PKI,
+    APDU_INS_LOAD_CERTIFICATE,
+    LEDGER_KEY_USAGE_NETWORK,
+    0x00,
+    Buffer.from(payloadHex, "hex"),
+  );
+}
+
+export async function fetchLedgerNetworkDescriptor(
+  chainId: number,
+  deviceModelId: string,
+  fetchFn: typeof fetch = fetch,
+): Promise<LedgerNetworkDescriptor | null> {
+  const calModel = LEDGER_DEVICE_TO_CAL_MODEL[deviceModelId];
+  if (!calModel) return null;
+
+  const url = `${LEDGER_CAL_SERVICE_URL}/networks?chain_id=${chainId}&output=chain_id,descriptors,icons`;
+  const response = await fetchFn(url);
+  if (!response.ok) return null;
+
+  const networks = (await response.json()) as CalNetwork[];
+  const network = networks.find((entry) => entry.chain_id === chainId);
+  const descriptor = network?.descriptors?.[calModel];
+  const signature = descriptor?.signatures?.prod;
+
+  if (!(descriptor?.data && signature)) return null;
+
+  return { data: descriptor.data, icon: network?.icons?.[calModel], signature };
+}
+
+function appendSignatureTlv(signature: string) {
+  return encodeTlv(TLV_TAG_DER_SIGNATURE, Buffer.from(signature, "hex")).toString("hex");
+}
+
+function encodeTlv(tag: number, value: Buffer) {
+  return Buffer.concat([Buffer.from([tag, value.length]), value]);
+}
+
+export function encodeNetworkInfoPayload({ data, signature }: LedgerNetworkDescriptor) {
+  const tlv = Buffer.concat([
+    Buffer.from(data, "hex"),
+    encodeTlv(TLV_TAG_DER_SIGNATURE, Buffer.from(signature, "hex")),
+  ]);
+  const length = Buffer.alloc(2);
+  length.writeUInt16BE(tlv.length, 0);
+  return Buffer.concat([length, tlv]);
+}
+
+async function sendChunked(transport: Transport, p2: number, payload: Buffer) {
+  for (let offset = 0; offset < payload.length; offset += APDU_MAX_CHUNK_SIZE) {
+    const p1 = offset === 0 ? APDU_P1_FIRST_CHUNK : APDU_P1_FOLLOWING_CHUNK;
+    const chunk = payload.subarray(offset, offset + APDU_MAX_CHUNK_SIZE);
+    await transport.send(APDU_CLA, APDU_INS_PROVIDE_NETWORK_INFORMATION, p1, p2, chunk);
+  }
+}
+
+export async function provideLedgerNetworkInformation(transport: Transport, descriptor: LedgerNetworkDescriptor) {
+  const payload = encodeNetworkInfoPayload(descriptor);
+  await sendChunked(transport, APDU_P2_NETWORK_CONFIG, payload);
+
+  if (!descriptor.icon) return { iconAccepted: false };
+
+  try {
+    await sendChunked(transport, APDU_P2_NETWORK_ICON, Buffer.from(descriptor.icon, "hex"));
+    return { iconAccepted: true };
+  } catch {
+    await sendChunked(transport, APDU_P2_NETWORK_CONFIG, payload);
+    return { iconAccepted: false };
+  }
+}

package/src/ledger/index.ts

@@ -60,6 +60,7 @@ export const ledgerWallet = createWallet({
     },
   directSigningSupport: {
     [Chain.Arbitrum]: true,
+    [Chain.Arc]: true,
     [Chain.Aurora]: true,
     [Chain.Avalanche]: true,
     [Chain.Base]: true,
@@ -88,6 +89,7 @@ export const ledgerWallet = createWallet({
   name: "connectLedger",
   supportedChains: [
     Chain.Arbitrum,
+    Chain.Arc,
     Chain.Aurora,
     Chain.Avalanche,
     Chain.Base,
@@ -400,6 +402,7 @@ async function getWalletMethods({
     case Chain.Ethereum:
     case Chain.Avalanche:
     case Chain.Arbitrum:
+    case Chain.Arc:
     case Chain.Berachain:
     case Chain.Optimism:
     case Chain.Polygon:

package/src/trezor/evmSigner.ts

@@ -123,14 +123,13 @@ export async function getEVMSigner({ chain, derivationPath, provider }: TrezorEV
       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;
+      // Check presence, not truthiness: a zero-wei tip is legitimate on chains with a negligible
+      // priority fee, such as Arc, where it used to be read as missing fee data.
+      const isEIP1559 = maxFeePerGas != null || maxPriorityFeePerGas != null;
 
       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 } });
       }

package/src/trezor/index.ts

@@ -498,6 +498,7 @@ async function getTrezorWallet<T extends Chain>({
 }) {
   switch (chain) {
     case Chain.Arbitrum:
+    case Chain.Arc:
     case Chain.Aurora:
     case Chain.Avalanche:
     case Chain.Base:
@@ -1358,6 +1359,7 @@ export const trezorWallet = createWallet({
     },
   directSigningSupport: {
     [Chain.Arbitrum]: true,
+    [Chain.Arc]: true,
     [Chain.Aurora]: true,
     [Chain.Avalanche]: true,
     [Chain.Base]: true,
@@ -1380,6 +1382,7 @@ export const trezorWallet = createWallet({
   name: "connectTrezor",
   supportedChains: [
     Chain.Arbitrum,
+    Chain.Arc,
     Chain.Aurora,
     Chain.Avalanche,
     Chain.Base,

package/dist/chunk-qs60k0yv.js

@@ -1,4 +0,0 @@
-import{d as Q}from"./chunk-n05bv2n5.js";import{ChainToChainId as b,derivationPathToString as $,SwapKitError as B,WalletOption as K}from"@swapkit/helpers";async function G({chain:_,derivationPath:f,provider:C}){let{AbstractSigner:H}=await import("ethers");class A extends H{address;chain;derivationPath;provider;constructor({chain:j,derivationPath:q,provider:J}){super(J);this.address="",this.chain=j,this.derivationPath=q,this.provider=J}getAddress=async()=>{if(!this.address){let q=await(await import("@trezor/connect-web")).default.ethereumGetAddress({path:$(this.derivationPath),showOnTrezor:!0});if(!q.success)throw new B({errorKey:"wallet_trezor_failed_to_get_address",info:{...q,chain:this.chain,derivationPath:this.derivationPath}});this.address=q.payload.address}return this.address};signMessage=async(j)=>{let J=await(await import("@trezor/connect-web")).default.ethereumSignMessage({message:j,path:$(this.derivationPath)});if(!J.success)throw new B({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{...J,chain:this.chain,derivationPath:this.derivationPath,message:j}});return J.payload.signature};signTypedData=async(j,q,J,N)=>{let O=(await import("@trezor/connect-web")).default,{buildEIP712DomainType:V}=await import("@swapkit/toolboxes/evm"),{TypedDataEncoder:X}=await import("ethers"),{EIP712Domain:Y,...R}=q,W=N??X.from(R).primaryType,M=V(j),D={domain:j,message:J,primaryType:W,types:{EIP712Domain:M,...R}},U=await O.ethereumSignTypedData({data:D,metamask_v4_compat:!0,path:$(this.derivationPath)});if(!U.success)throw new B({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:this.chain,error:U.payload.error}});return U.payload.signature.startsWith("0x")?U.payload.signature:`0x${U.payload.signature}`};signTransaction=async({to:j,gasLimit:q,value:J,data:N,nonce:O,maxFeePerGas:V,maxPriorityFeePerGas:X,gasPrice:Y})=>{if(!j)throw new B({errorKey:"wallet_missing_params",info:{to:j}});if(!q)throw new B({errorKey:"wallet_missing_params",info:{gasLimit:q}});let R=V&&X;if(R&&!V)throw new B({errorKey:"wallet_missing_params",info:{maxFeePerGas:V}});if(R&&!X)throw new B({errorKey:"wallet_missing_params",info:{maxPriorityFeePerGas:X}});if(!(R||Y))throw new B({errorKey:"wallet_missing_params",info:{gasPrice:Y}});let W=(await import("@trezor/connect-web")).default,{toHexString:M}=await import("@swapkit/toolboxes/evm"),D=R?{maxFeePerGas:M(BigInt(V?.toString()||0)),maxPriorityFeePerGas:M(BigInt(X?.toString()||0))}:Y&&{gasPrice:M(BigInt(Y?.toString()||0))}||{gasPrice:"0x0"},U=M(BigInt(O||await this.provider.getTransactionCount(await this.getAddress(),"pending"))),I={chainId:Number.parseInt(b[this.chain],10),data:N?.toString()||"0x",gasLimit:M(BigInt(q?.toString()||0)),nonce:U,to:j.toString(),value:M(BigInt(J?.toString()||0)),...D},{success:L,payload:Z}=await W.ethereumSignTransaction({path:$(this.derivationPath),transaction:I});if(!L)throw new B({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{...Z,chain:this.chain,derivationPath:this.derivationPath}});let k=Z.serializedTx?Z.serializedTx.startsWith("0x")?Z.serializedTx:`0x${Z.serializedTx}`:void 0;if(!k)throw new B({errorKey:"wallet_trezor_failed_to_sign_transaction",info:{chain:this.chain,derivationPath:this.derivationPath}});return k};connect=(j)=>{if(!j)throw new B({errorKey:"wallet_provider_not_found",info:{chain:this.chain,derivationPath:this.derivationPath,wallet:K.TREZOR}});return new A({chain:this.chain,derivationPath:this.derivationPath,provider:j})}}return new A({chain:_,derivationPath:f,provider:C})}export{G as getEVMSigner};
-
-//# debugId=654BE0775B0291CD64756E2164756E21
-//# sourceMappingURL=chunk-qs60k0yv.js.map