@swapkit/wallet-hardware 6.1.1 → 6.3.0

package/src/trezor/index.ts

@@ -409,14 +409,25 @@ async function decodeOutputAddress(script: Uint8Array): Promise<string | undefin
   return undefined;
 }
 
+// The signed PCZT takes the v5 header Trezor signed, so the extracted transaction matches the signatures
 async function extractSignaturesFromSignedTx(signedTxHex: string, pczt: PCZT): Promise<PCZT> {
-  const { ZcashTransaction: ZcashTx, Script } = await import("@swapkit/utxo-signer");
+  const { ZcashTransaction: ZcashTx, Script, createPCZT } = await import("@swapkit/utxo-signer");
   const signedTx = ZcashTx.fromHex(signedTxHex, { allowUnknownOutputs: true });
-  const signedPczt = pczt.clone();
+  const signedPczt = createPCZT({
+    coinType: pczt.getGlobal().coinType,
+    consensusBranchId: signedTx.consensusBranchId,
+    expiryHeight: signedTx.expiryHeight,
+    lockTime: signedTx.lockTime,
+    version: signedTx.version,
+    versionGroupId: signedTx.versionGroupId,
+  });
+  for (let i = 0; i < pczt.inputsLength; i++) signedPczt.addInput(pczt.getInput(i));
+  for (let i = 0; i < pczt.outputsLength; i++) signedPczt.addOutput(pczt.getOutput(i));
 
   for (let i = 0; i < signedTx.inputsLength; i++) {
     const signedInput = signedTx.getInput(i);
-    const script = signedInput.script;
+    // utxo-signer 3.2 parses the signature script into scriptSig; 3.1 put it in script.
+    const script = signedInput.scriptSig ?? signedInput.script;
     if (script && script.length > 0) {
       const scriptParts = Script.decode(script);
       if (scriptParts.length >= 2) {
@@ -427,6 +438,33 @@ async function extractSignaturesFromSignedTx(signedTxHex: string, pczt: PCZT): P
   return signedPczt;
 }
 
+// A transaction parsed from raw bytes carries no input amounts, and v5 signing commits to them
+async function resolveZcashInputAmounts(tx: ZcashTransaction): Promise<UTXOType[]> {
+  const { hex: hexEncode } = await import("@scure/base");
+  const zcashApi = getUtxoApi(Chain.Zcash);
+  const previousTransactions = new Map<string, ReturnType<typeof zcashApi.getTransactionDetails>>();
+
+  return Promise.all(
+    Array.from({ length: tx.inputsLength }, async (_, inputIndex) => {
+      const input = tx.getInput(inputIndex);
+      const hash = hexEncode.encode(input.txid);
+      if (input.value > 0n) return { hash, index: input.index, value: Number(input.value) };
+
+      const previous = previousTransactions.get(hash) ?? zcashApi.getTransactionDetails(hash);
+      previousTransactions.set(hash, previous);
+      const output = (await previous).outputs.find(({ index }) => index === input.index);
+      if (!output || !(output.value > 0)) {
+        throw new SwapKitError({
+          errorKey: "wallet_missing_params",
+          info: { chain: Chain.Zcash, inputIndex, reason: "Unable to resolve the Zcash input amount", txid: hash },
+        });
+      }
+
+      return { hash, index: input.index, value: output.value };
+    }),
+  );
+}
+
 function buildZcashTxInputsForTrezor(
   tx: ZcashTransaction,
   utxoInputs: UTXOType[],
@@ -486,6 +524,35 @@ async function buildZcashTxOutputsForTrezor({
   return outputs;
 }
 
+type ZcashTrezorSignRequest = {
+  branchId: number;
+  expiry: number;
+  inputs: { amount: string; prev_hash: string; prev_index: number }[];
+  locktime: number;
+  outputs: { address?: string; amount: string; script_type: string }[];
+};
+
+type ZcashTrezorHeader = { version: number; versionGroupId: number };
+
+function describeZcashSignRequest({ inputs, outputs, ...header }: ZcashTrezorSignRequest & ZcashTrezorHeader) {
+  const sum = (amounts: { amount: string }[]) => amounts.reduce((total, { amount }) => total + BigInt(amount), 0n);
+  const inputTotal = sum(inputs);
+  const outputTotal = sum(outputs);
+
+  return {
+    ...header,
+    fee: (inputTotal - outputTotal).toString(),
+    inputAmounts: inputs.map(({ amount }) => amount),
+    inputs: inputs.map(({ prev_hash, prev_index }) => `${prev_hash}:${prev_index}`),
+    inputTotal: inputTotal.toString(),
+    outputs: outputs.map(({ address, amount, script_type }) => ({
+      amount,
+      kind: script_type === "PAYTOOPRETURN" ? "op_return" : address ? "external" : "change",
+    })),
+    outputTotal: outputTotal.toString(),
+  };
+}
+
 async function buildUtxoOutputsForTrezor(
   tx: Transaction,
   network: BTCNetwork,
@@ -610,6 +677,17 @@ async function getTrezorWallet<T extends Chain>({
       return { ...toolbox, address };
     }
 
+    case Chain.Hype: {
+      const { getHyperCoreToolbox } = await import("@swapkit/toolboxes/hypercore");
+      const { getHyperCoreSigner } = await import("./hypercoreSigner");
+
+      const signer = getHyperCoreSigner({ address: providedAddress, derivationPath });
+      const address = await signer.getAddress();
+      const toolbox = getHyperCoreToolbox({ signer });
+
+      return { ...toolbox, address };
+    }
+
     case Chain.Ripple: {
       const { getRippleToolbox } = await import("@swapkit/toolboxes/ripple");
       const { getRippleSigner } = await import("./rippleSigner");
@@ -657,11 +735,12 @@ async function getTrezorWallet<T extends Chain>({
     case Chain.Zcash: {
       const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
 
+      const coin = chain.toLowerCase();
       const derivationPathStr = derivationPathToString(derivationPath);
 
       const getAddress = async () => {
         const TrezorConnect = (await import("@trezor/connect-web")).default;
-        const { success, payload } = await TrezorConnect.getAddress({ coin: "zcash", path: derivationPathStr });
+        const { success, payload } = await TrezorConnect.getAddress({ coin, path: derivationPathStr });
 
         if (!success) {
           throw new SwapKitError({
@@ -675,37 +754,48 @@ async function getTrezorWallet<T extends Chain>({
 
       const address = providedAddress ?? (await getAddress());
 
-      const signPCZTWithSerializedTx = async (pczt: PCZT) => {
+      // Always v5: v4 signing makes Connect fetch previous transactions, and it cannot parse v6 ones
+      const signWithTrezor = async (request: ZcashTrezorSignRequest, signingPath: "pczt" | "transaction") => {
         const TrezorConnect = (await import("@trezor/connect-web")).default;
+        const { ZcashVersion, ZcashVersionGroupId } = await import("@swapkit/utxo-signer");
+        const signRequest = { ...request, version: ZcashVersion.NU5, versionGroupId: ZcashVersionGroupId.NU5 };
+        const result = await TrezorConnect.signTransaction({ ...signRequest, coin, overwintered: true } as Parameters<
+          typeof TrezorConnect.signTransaction
+        >[0]);
+
+        if (!result.success) {
+          throw new SwapKitError({
+            errorKey: "wallet_trezor_failed_to_sign_transaction",
+            info: {
+              ...result.payload,
+              chain,
+              derivationPath,
+              request: describeZcashSignRequest(signRequest),
+              signingPath,
+            },
+          });
+        }
+
+        return result.payload.serializedTx;
+      };
+
+      const signPCZTWithSerializedTx = async (pczt: PCZT) => {
         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({
+        const request = {
           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),
+          outputs,
         };
+        const serializedTx = await signWithTrezor(request, "pczt");
+
+        return { serializedTx, signedPczt: await extractSignaturesFromSignedTx(serializedTx, pczt) };
       };
 
       const parseSignedZcashTransaction = async (signedTxHex: string) => {
@@ -714,12 +804,11 @@ async function getTrezorWallet<T extends Chain>({
       };
 
       const signZcashTransactionWithSerializedTx = async (tx: ZcashTransaction) => {
-        const TrezorConnect = (await import("@trezor/connect-web")).default;
         const { hex: hexEncode } = await import("@scure/base");
-        const { NETWORKS, ZcashVersionGroupId } = await import("@swapkit/utxo-signer");
+        const { NETWORKS } = await import("@swapkit/utxo-signer");
         const address_n = hardenDerivationPath(derivationPath);
 
-        const inputs = buildZcashTxInputsForTrezor(tx, [], address_n, hexEncode);
+        const inputs = buildZcashTxInputsForTrezor(tx, await resolveZcashInputAmounts(tx), address_n, hexEncode);
         const outputs = await buildZcashTxOutputsForTrezor({
           addressN: address_n,
           chain,
@@ -728,29 +817,16 @@ async function getTrezorWallet<T extends Chain>({
           tx,
         });
 
-        const result = await TrezorConnect.signTransaction({
+        const request = {
           branchId: tx.consensusBranchId,
-          coin: "zcash",
-          expiry: 0,
+          expiry: tx.expiryHeight,
           inputs,
-          locktime: 0,
-          outputs: outputs as any,
-          overwintered: true,
-          version: 4,
-          versionGroupId: ZcashVersionGroupId.SAPLING,
-        });
-
-        if (result.success) {
-          return {
-            serializedTx: result.payload.serializedTx,
-            signedTx: await parseSignedZcashTransaction(result.payload.serializedTx),
-          };
-        }
+          locktime: tx.lockTime,
+          outputs,
+        };
+        const serializedTx = await signWithTrezor(request, "transaction");
 
-        throw new SwapKitError({
-          errorKey: "wallet_trezor_failed_to_sign_transaction",
-          info: { chain, error: (result.payload as { error: string; code?: string }).error },
-        });
+        return { serializedTx, signedTx: await parseSignedZcashTransaction(serializedTx) };
       };
 
       const signer = {
@@ -1427,7 +1503,7 @@ export async function getTrezorExtendedPublicKey(
   const { TrezorConnect } = await initTrezorConnect();
   const utxoChain = chain as UTXOChain;
   const resolvedDerivationPath = derivationPath ?? (NetworkDerivationPath[chain] as DerivationPathArray);
-  const coin = chain === Chain.Zcash ? "zcash" : chain.toLowerCase();
+  const coin = chain.toLowerCase();
 
   const resolvedAccountPath = getUTXOAccountPath({
     accountIndex,
@@ -1531,36 +1607,37 @@ export const trezorWallet = createWallet({
 
       return true;
     },
-  directSigningSupport: {
-    [Chain.Arbitrum]: true,
-    [Chain.Arc]: true,
-    [Chain.Aurora]: true,
-    [Chain.Avalanche]: true,
-    [Chain.Base]: true,
-    [Chain.Berachain]: true,
-    [Chain.BinanceSmartChain]: true,
-    [Chain.Bitcoin]: true,
-    [Chain.BitcoinCash]: true,
-    [Chain.Cardano]: true,
-    [Chain.Dash]: true,
-    [Chain.Ethereum]: true,
-    [Chain.Gnosis]: true,
-    [Chain.Dogecoin]: true,
-    [Chain.Hyperevm]: true,
-    [Chain.Litecoin]: true,
-    [Chain.Monad]: true,
-    [Chain.Optimism]: true,
-    [Chain.Polygon]: true,
-    [Chain.Ripple]: true,
-    [Chain.Robinhood]: true,
-    [Chain.Solana]: true,
-    [Chain.Stellar]: true,
-    [Chain.Tron]: true,
-    [Chain.XLayer]: true,
-    [Chain.Zcash]: true,
-  },
   getExtendedPublicKey: getTrezorExtendedPublicKey,
   name: "connectTrezor",
+  signingSupport: {
+    [Chain.Arbitrum]: { direct: true, typedData: true },
+    [Chain.Arc]: { direct: true, typedData: true },
+    [Chain.Aurora]: { direct: true, typedData: true },
+    [Chain.Avalanche]: { direct: true, typedData: true },
+    [Chain.Base]: { direct: true, typedData: true },
+    [Chain.Berachain]: { direct: true, typedData: true },
+    [Chain.BinanceSmartChain]: { direct: true, typedData: true },
+    [Chain.Bitcoin]: { direct: true },
+    [Chain.BitcoinCash]: { direct: true },
+    [Chain.Cardano]: { direct: true },
+    [Chain.Dash]: { direct: true },
+    [Chain.Ethereum]: { direct: true, typedData: true },
+    [Chain.Gnosis]: { direct: true, typedData: true },
+    [Chain.Dogecoin]: { direct: true },
+    [Chain.Hype]: { direct: true },
+    [Chain.Hyperevm]: { direct: true, typedData: true },
+    [Chain.Litecoin]: { direct: true },
+    [Chain.Monad]: { direct: true, typedData: true },
+    [Chain.Optimism]: { direct: true, typedData: true },
+    [Chain.Polygon]: { direct: true, typedData: true },
+    [Chain.Ripple]: { direct: true },
+    [Chain.Robinhood]: { direct: true, typedData: true },
+    [Chain.Solana]: { direct: true },
+    [Chain.Stellar]: { direct: true },
+    [Chain.Tron]: { direct: true },
+    [Chain.XLayer]: { direct: true, typedData: true },
+    [Chain.Zcash]: { direct: true },
+  },
   supportedChains: [
     Chain.Arbitrum,
     Chain.Arc,
@@ -1576,6 +1653,7 @@ export const trezorWallet = createWallet({
     Chain.Dogecoin,
     Chain.Ethereum,
     Chain.Gnosis,
+    Chain.Hype,
     Chain.Hyperevm,
     Chain.Litecoin,
     Chain.Monad,