@swapkit/wallet-hardware 4.9.13 → 4.9.15

package/src/trezor/index.ts

@@ -22,7 +22,7 @@ import {
   type UTXOToolboxes,
   type UTXOType,
 } from "@swapkit/toolboxes/utxo";
-import type { BTCNetwork, PCZT, Transaction, ZcashTransaction } from "@swapkit/utxo-signer";
+import type { BTCNetwork, PCZT, Transaction, ZcashPSBT, ZcashTransaction } from "@swapkit/utxo-signer";
 import { BCHSigHash, NETWORKS, ZcashConsensusBranchId, ZcashVersionGroupId } from "@swapkit/utxo-signer";
 import { createWallet, getWalletSupportedChains, type HardwareExtendedPublicKeyInfo } from "@swapkit/wallet-core";
 
@@ -30,6 +30,8 @@ type TrezorBip32Derivation = [Uint8Array, { fingerprint: number; path: number[]
 type TrezorCoreMode = "auto" | "iframe" | "popup" | "suite-desktop" | "suite-web";
 type TrezorTransport = "BridgeTransport" | "WebUsbTransport" | "NodeUsbTransport";
 type ConnectTrezorOptions = { address?: string };
+type TrezorAccountRefTransaction = { details: Record<string, never>; hex: string; txid: string };
+type ZcashSignableTransaction = PCZT | ZcashPSBT | ZcashTransaction;
 type TrezorExtendedPublicKeyInfo = {
   accountIndex: number;
   chainCode?: string;
@@ -274,7 +276,7 @@ function buildPCZTInputsForTrezor(
     inputs.push({
       address_n,
       amount: input.value.toString(),
-      prev_hash: hexEncode.encode(new Uint8Array([...input.txid].reverse())),
+      prev_hash: hexEncode.encode(input.txid),
       prev_index: input.index,
       script_type: "SPENDADDRESS" as const,
     });
@@ -363,8 +365,8 @@ function buildZcashTxInputsForTrezor(
     const utxoInfo = utxoInputs[i];
     inputs.push({
       address_n,
-      amount: utxoInfo?.value?.toString() || "0",
-      prev_hash: input.txid ? hexEncode.encode(new Uint8Array([...input.txid].reverse())) : "",
+      amount: utxoInfo?.value?.toString() || input.value?.toString() || "0",
+      prev_hash: input.txid ? hexEncode.encode(input.txid) : "",
       prev_index: input.index ?? 0,
       script_type: "SPENDADDRESS" as const,
     });
@@ -465,6 +467,25 @@ function shouldUseTrezorSerializedSigner(chain: Chain) {
   return chain === Chain.BitcoinCash || chain === Chain.Dash || chain === Chain.Dogecoin;
 }
 
+function buildTrezorRefTxs(chain: Chain, inputs: UTXOType[]): TrezorAccountRefTransaction[] | undefined {
+  if (chain !== Chain.Dash) return undefined;
+
+  const refs = new Map<string, TrezorAccountRefTransaction>();
+
+  for (const input of inputs) {
+    if (!input.txHex) {
+      throw new SwapKitError({
+        errorKey: "wallet_trezor_failed_to_sign_transaction",
+        info: { chain, error: `Missing previous transaction hex for ${input.hash}:${input.index}` },
+      });
+    }
+
+    refs.set(input.hash, { details: {}, hex: input.txHex, txid: input.hash });
+  }
+
+  return [...refs.values()];
+}
+
 async function getTrezorWallet<T extends Chain>({
   address: providedAddress,
   chain,
@@ -517,158 +538,115 @@ async function getTrezorWallet<T extends Chain>({
         return payload.address;
       };
 
-      const address = await getAddress();
-
-      const signer = {
-        getAddress: async () => address,
-
-        signPCZT: async (pczt: PCZT): Promise<PCZT> => {
-          const TrezorConnect = (await import("@trezor/connect-web")).default;
-          const { hex: hexEncode } = await import("@scure/base");
-          const address_n = hardenDerivationPath(derivationPath);
-          const global = pczt.getGlobal();
-
-          const inputs = buildPCZTInputsForTrezor(pczt, address_n, hexEncode);
-          const outputs = await buildPCZTOutputsForTrezor(pczt, address_n, address, chain);
-
-          const result = await TrezorConnect.signTransaction({
-            branchId: global.consensusBranchId,
-            coin: "zcash",
-            expiry: global.expiryHeight,
-            inputs,
-            locktime: global.lockTime,
-            outputs: outputs as any,
-            overwintered: true,
-            version: global.txVersion,
-            versionGroupId: global.versionGroupId,
-          });
-
-          if (!result.success) {
-            throw new SwapKitError({
-              errorKey: "wallet_trezor_failed_to_sign_transaction",
-              info: { chain, error: (result.payload as { error: string; code?: string }).error },
-            });
-          }
-
-          return extractSignaturesFromSignedTx(result.payload.serializedTx, pczt);
-        },
+      const address = providedAddress ?? (await getAddress());
 
-        signTransaction: async (tx: ZcashTransaction, utxoInputs: UTXOType[]) => {
-          const TrezorConnect = (await import("@trezor/connect-web")).default;
-          const { hex: hexEncode } = await import("@scure/base");
-          const address_n = hardenDerivationPath(derivationPath);
-
-          const inputs = buildZcashTxInputsForTrezor(tx, utxoInputs, address_n, hexEncode);
-          const outputs = buildZcashTxOutputsForTrezor(tx, address_n, address, chain);
-
-          const result = await TrezorConnect.signTransaction({
-            branchId: ZcashConsensusBranchId.NU6,
-            coin: "zcash",
-            expiry: 0,
-            inputs,
-            locktime: 0,
-            outputs: outputs as any,
-            overwintered: true,
-            version: 4,
-            versionGroupId: ZcashVersionGroupId.SAPLING,
-          });
+      const signPCZTWithSerializedTx = async (pczt: PCZT) => {
+        const TrezorConnect = (await import("@trezor/connect-web")).default;
+        const { hex: hexEncode } = await import("@scure/base");
+        const address_n = hardenDerivationPath(derivationPath);
+        const global = pczt.getGlobal();
 
-          if (result.success) {
-            return result.payload.serializedTx;
-          }
+        const inputs = buildPCZTInputsForTrezor(pczt, address_n, hexEncode);
+        const outputs = await buildPCZTOutputsForTrezor(pczt, address_n, address, chain);
+        const result = await TrezorConnect.signTransaction({
+          branchId: global.consensusBranchId,
+          coin: "zcash",
+          expiry: global.expiryHeight,
+          inputs,
+          locktime: global.lockTime,
+          outputs: outputs as any,
+          overwintered: true,
+          version: global.txVersion,
+          versionGroupId: global.versionGroupId,
+        });
 
+        if (!result.success) {
           throw new SwapKitError({
             errorKey: "wallet_trezor_failed_to_sign_transaction",
             info: { chain, error: (result.payload as { error: string; code?: string }).error },
           });
-        },
+        }
+
+        return {
+          serializedTx: result.payload.serializedTx,
+          signedPczt: await extractSignaturesFromSignedTx(result.payload.serializedTx, pczt),
+        };
       };
 
-      const toolbox = getUtxoToolbox(Chain.Zcash);
+      const parseSignedZcashTransaction = async (signedTxHex: string) => {
+        const { ZcashTransaction: ZcashTx } = await import("@swapkit/utxo-signer");
+        return ZcashTx.fromHex(signedTxHex, { allowUnknownOutputs: true });
+      };
 
-      const transfer = async (params: GenericTransferParams) => {
-        if (!(address && params.recipient)) {
-          throw new SwapKitError({
-            errorKey: "wallet_missing_params",
-            info: { address, recipient: params.recipient, wallet: WalletOption.TREZOR },
-          });
-        }
+      const signZcashTransaction = async (tx: ZcashTransaction) => {
+        const TrezorConnect = (await import("@trezor/connect-web")).default;
+        const { hex: hexEncode } = await import("@scure/base");
+        const address_n = hardenDerivationPath(derivationPath);
 
-        const feeRate = params.feeRate || (await toolbox.getFeeRates())[params.feeOptionKey || FeeOption.Fast];
+        const inputs = buildZcashTxInputsForTrezor(tx, [], address_n, hexEncode);
+        const outputs = buildZcashTxOutputsForTrezor(tx, address_n, address, chain);
 
-        const { tx, inputs: txInputs } = await toolbox.createTransaction({
-          ...params,
-          feeRate,
-          fetchTxHex: false,
-          sender: address,
+        const result = await TrezorConnect.signTransaction({
+          branchId: ZcashConsensusBranchId.NU6,
+          coin: "zcash",
+          expiry: 0,
+          inputs,
+          locktime: 0,
+          outputs: outputs as any,
+          overwintered: true,
+          version: 4,
+          versionGroupId: ZcashVersionGroupId.SAPLING,
         });
 
-        const txHex = await signer.signTransaction(tx, txInputs);
-        const broadcastResult = await toolbox.broadcastTx(txHex);
+        if (result.success) {
+          return parseSignedZcashTransaction(result.payload.serializedTx);
+        }
 
-        return broadcastResult;
+        throw new SwapKitError({
+          errorKey: "wallet_trezor_failed_to_sign_transaction",
+          info: { chain, error: (result.payload as { error: string; code?: string }).error },
+        });
       };
 
-      const transferWithPCZT = async (params: GenericTransferParams) => {
-        if (!(address && params.recipient)) {
-          throw new SwapKitError({
-            errorKey: "wallet_missing_params",
-            info: { address, recipient: params.recipient, wallet: WalletOption.TREZOR },
-          });
-        }
-
-        const { createPCZT, OutScript } = await import("@swapkit/utxo-signer");
-        const { hex: hexEncode } = await import("@scure/base");
-        const { getUtxoApi } = await import("@swapkit/toolboxes/utxo");
+      const signer = {
+        getAddress: async () => address,
 
-        const feeRate = params.feeRate || (await toolbox.getFeeRates())[params.feeOptionKey || FeeOption.Fast];
+        signPCZT: async (pczt: PCZT): Promise<PCZT> => {
+          return (await signPCZTWithSerializedTx(pczt)).signedPczt;
+        },
 
-        const utxos = await getUtxoApi(Chain.Zcash).getUtxos({ address });
+        signTransaction: async (tx: ZcashSignableTransaction): Promise<ZcashTransaction> => {
+          if ("toPCZT" in tx) {
+            const { serializedTx } = await signPCZTWithSerializedTx(tx.toPCZT());
+            return parseSignedZcashTransaction(serializedTx);
+          }
 
-        const { tx, inputs: txInputs } = await toolbox.createTransaction({
-          ...params,
-          feeRate,
-          fetchTxHex: false,
-          sender: address,
-        });
+          if ("getGlobal" in tx) {
+            const { serializedTx } = await signPCZTWithSerializedTx(tx);
+            return parseSignedZcashTransaction(serializedTx);
+          }
 
-        const pczt = createPCZT();
+          return signZcashTransaction(tx);
+        },
+      };
 
-        for (const utxoInput of txInputs) {
-          const utxo = utxos.find((u) => u.hash === utxoInput.hash && u.index === utxoInput.index);
-          const scriptPubkey = utxo?.witnessUtxo?.script
-            ? new Uint8Array(utxo.witnessUtxo.script)
-            : OutScript.encode({ hash: hexEncode.decode((utxoInput as any).address || ""), type: "pkh" });
+      const toolbox = getUtxoToolbox(Chain.Zcash, { signer });
 
-          pczt.addInput({
-            index: utxoInput.index,
-            scriptPubkey,
-            txid: hexEncode.decode(utxoInput.hash).reverse() as unknown as Uint8Array,
-            value: BigInt(utxoInput.value),
-          });
+      const signAndBroadcastTransaction = async (tx: ZcashSignableTransaction) => {
+        if ("toPCZT" in tx) {
+          const { serializedTx } = await signPCZTWithSerializedTx(tx.toPCZT());
+          return toolbox.broadcastTx(serializedTx);
         }
 
-        for (let i = 0; i < tx.outputsLength; i++) {
-          const output = tx.getOutput(i);
-          pczt.addOutput({ scriptPubkey: output.script || new Uint8Array(), value: output.amount || 0n });
+        if ("getGlobal" in tx) {
+          const { serializedTx } = await signPCZTWithSerializedTx(tx);
+          return toolbox.broadcastTx(serializedTx);
         }
 
-        const signedPczt = await signer.signPCZT(pczt);
-        signedPczt.finalizeAllInputs();
-        const finalTx = signedPczt.extract();
-        const broadcastResult = await toolbox.broadcastTx(finalTx.toHex());
-
-        return broadcastResult;
+        return toolbox.signAndBroadcastTransaction(tx);
       };
 
-      return {
-        ...toolbox,
-        address,
-        signPCZT: signer.signPCZT,
-        signTransaction: signer.signTransaction,
-        transfer,
-        transferWithPCZT,
-      };
+      return { ...toolbox, address, signAndBroadcastTransaction, signPCZT: signer.signPCZT };
     }
 
     case Chain.Bitcoin:
@@ -739,7 +717,12 @@ async function getTrezorWallet<T extends Chain>({
           script_type: resolvedScriptType.input,
         }));
 
-        const result = await TrezorConnect.signTransaction({ coin, inputs: trezorInputs, outputs });
+        const result = await TrezorConnect.signTransaction({
+          coin,
+          inputs: trezorInputs,
+          outputs,
+          refTxs: buildTrezorRefTxs(chain, inputs) as never,
+        });
 
         if (result.success) {
           return result.payload.serializedTx;
@@ -910,7 +893,14 @@ async function getTrezorWallet<T extends Chain>({
 
       const signTransactionWithMultipleInputs = async (
         tx: Transaction,
-        inputs: Array<{ hash: string; index: number; value: number; derivationIndex: number; isChange: boolean }>,
+        inputs: Array<{
+          derivationIndex: number;
+          hash: string;
+          index: number;
+          isChange: boolean;
+          txHex?: string;
+          value: number;
+        }>,
         memo = "",
       ) => {
         const TrezorConnect = (await import("@trezor/connect-web")).default;
@@ -941,7 +931,12 @@ async function getTrezorWallet<T extends Chain>({
           };
         });
 
-        const result = await TrezorConnect.signTransaction({ coin, inputs: trezorInputs, outputs });
+        const result = await TrezorConnect.signTransaction({
+          coin,
+          inputs: trezorInputs,
+          outputs,
+          refTxs: buildTrezorRefTxs(chain, inputs) as never,
+        });
 
         if (result.success) {
           return result.payload.serializedTx;
@@ -982,7 +977,7 @@ async function getTrezorWallet<T extends Chain>({
         const { tx, inputs: selectedInputs } = await toolbox.createTransaction({
           assetValue: assetValue as any,
           feeRate: txFeeRate,
-          fetchTxHex: true,
+          fetchTxHex: chain === Chain.Dash,
           memo,
           recipient,
           sender: address,
@@ -990,7 +985,12 @@ async function getTrezorWallet<T extends Chain>({
 
         const inputsWithDerivation = selectedInputs.map((input: { hash: string; index: number; value: number }) => {
           const utxoInfo = utxos.find((u) => u.hash === input.hash && u.index === input.index);
-          return { ...input, derivationIndex: utxoInfo?.derivationIndex ?? 0, isChange: utxoInfo?.isChange ?? false };
+          return {
+            ...input,
+            derivationIndex: utxoInfo?.derivationIndex ?? 0,
+            isChange: utxoInfo?.isChange ?? false,
+            txHex: utxoInfo?.txHex,
+          };
         });
 
         const signedTxHex = await signTransactionWithMultipleInputs(tx as Transaction, inputsWithDerivation, memo);
@@ -1020,7 +1020,7 @@ async function getTrezorWallet<T extends Chain>({
         const { tx, inputs } = await createTxMethod({
           ...rest,
           feeRate,
-          fetchTxHex: true,
+          fetchTxHex: chain === Chain.Dash,
           memo,
           recipient,
           sender: address,
@@ -1041,6 +1041,8 @@ async function getTrezorWallet<T extends Chain>({
       const signAndBroadcastTransaction = shouldUseTrezorSerializedSigner(chain)
         ? async (tx: Transaction) => baseToolbox.broadcastTx(await signSerializedTransaction(tx))
         : toolbox.signAndBroadcastTransaction;
+      const walletSignTransaction = shouldUseTrezorPsbtSigner(chain) ? toolbox.signTransaction : signTransaction;
+      const walletTransfer = shouldUseTrezorPsbtSigner(chain) ? toolbox.transfer : transfer;
 
       async function getExtendedPublicKeyInfo({ accountIndex }: { accountIndex?: number } = {}) {
         const TrezorConnect = (await import("@trezor/connect-web")).default;
@@ -1200,9 +1202,9 @@ async function getTrezorWallet<T extends Chain>({
         getExtendedPublicKey,
         getExtendedPublicKeyInfo,
         signAndBroadcastTransaction,
-        signTransaction,
+        signTransaction: walletSignTransaction,
         signTransactionWithMultipleInputs,
-        transfer,
+        transfer: walletTransfer,
         transferFromMultipleAddresses,
       };
     }
@@ -1217,14 +1219,14 @@ export async function getTrezorExtendedPublicKey(
   derivationPath?: DerivationPathArray,
   { accountIndex }: { accountIndex?: number } = {},
 ): Promise<HardwareExtendedPublicKeyInfo | undefined> {
-  if (![Chain.BitcoinCash, Chain.Bitcoin, Chain.Dash, Chain.Dogecoin, Chain.Litecoin].includes(chain)) {
+  if (![Chain.BitcoinCash, Chain.Bitcoin, Chain.Dash, Chain.Dogecoin, Chain.Litecoin, Chain.Zcash].includes(chain)) {
     throw new SwapKitError({ errorKey: "wallet_chain_not_supported", info: { chain, wallet: WalletOption.TREZOR } });
   }
 
   const { TrezorConnect } = await initTrezorConnect();
   const utxoChain = chain as UTXOChain;
   const resolvedDerivationPath = derivationPath ?? (NetworkDerivationPath[chain] as DerivationPathArray);
-  const coin = chain.toLowerCase();
+  const coin = chain === Chain.Zcash ? "zcash" : chain.toLowerCase();
 
   const resolvedAccountPath = getUTXOAccountPath({
     accountIndex,
@@ -1346,7 +1348,7 @@ export const trezorWallet = createWallet({
     [Chain.Optimism]: true,
     [Chain.Polygon]: true,
     [Chain.XLayer]: true,
-    // ZEC: pending PCZT/TrezorConnect validation
+    [Chain.Zcash]: true,
   },
   getExtendedPublicKey: getTrezorExtendedPublicKey,
   name: "connectTrezor",