@swapkit/wallet-hardware 6.0.0 → 6.1.0

package/src/trezor/index.ts

@@ -199,11 +199,55 @@ function tryNormalizeTrezorExtendedPublicKey(xpub: string | undefined, chain: UT
   }
 }
 
-function decodeOpReturnData(script: Uint8Array): string | null {
-  if (script.length < 2 || script[0] !== 0x6a) return null;
-  const dataLen = script[1];
-  if (dataLen === undefined || script.length < 2 + dataLen) return null;
-  return Buffer.from(script.slice(2, 2 + dataLen)).toString("hex");
+async function decodeOpReturnData(script: Uint8Array) {
+  const { Script } = await import("@swapkit/utxo-signer");
+
+  try {
+    const [opcode, data] = Script.decode(script);
+    const bytes = data === 0 ? new Uint8Array() : data;
+    if (opcode !== "RETURN" || !(bytes instanceof Uint8Array)) return null;
+
+    // Trezor rebuilds the script from the data, so only accept scripts it reproduces byte for byte
+    return hex.encode(Script.encode(["RETURN", bytes])) === hex.encode(script) ? hex.encode(bytes) : null;
+  } catch {
+    return null;
+  }
+}
+
+async function toTrezorOpReturnOutput(script: Uint8Array, amount: bigint | undefined, chain: Chain) {
+  if (amount !== 0n) {
+    throw new SwapKitError({
+      errorKey: "wallet_trezor_failed_to_sign_transaction",
+      info: { chain, error: "OP_RETURN output carrying value cannot be signed" },
+    });
+  }
+
+  const opReturnData = await decodeOpReturnData(script);
+
+  if (opReturnData === null) {
+    throw new SwapKitError({
+      errorKey: "wallet_trezor_failed_to_sign_transaction",
+      info: { chain, error: "Malformed OP_RETURN output cannot be signed" },
+    });
+  }
+
+  return { amount: "0", op_return_data: opReturnData, script_type: "PAYTOOPRETURN" as const };
+}
+
+async function assertTransactionCarriesMemo(tx: Transaction, memo: string, chain: Chain) {
+  if (!memo) return;
+
+  const expected = hex.encode(new TextEncoder().encode(memo));
+
+  for (let i = 0; i < tx.outputsLength; i++) {
+    const script = tx.getOutput(i).script;
+    if (script?.[0] === 0x6a && (await decodeOpReturnData(script)) === expected) return;
+  }
+
+  throw new SwapKitError({
+    errorKey: "wallet_trezor_failed_to_sign_transaction",
+    info: { chain, error: "Transaction does not carry the provided memo" },
+  });
 }
 
 function getScriptType(chain: Chain, derivationPath: DerivationPathArray) {
@@ -327,16 +371,9 @@ async function buildPCZTOutputsForTrezor(pczt: PCZT, address_n: number[], myAddr
     const output = pczt.getOutput(i);
     const script = output.scriptPubkey;
 
-    if (output.value === 0n && script?.length > 0 && script[0] === 0x6a) {
-      const opReturnData = decodeOpReturnData(script);
-      if (opReturnData) {
-        outputs.push({ amount: "0", op_return_data: opReturnData, script_type: "PAYTOOPRETURN" as const });
-        continue;
-      }
-      throw new SwapKitError({
-        errorKey: "wallet_trezor_failed_to_sign_transaction",
-        info: { chain, error: "Malformed OP_RETURN output cannot be signed" },
-      });
+    if (script?.[0] === 0x6a) {
+      outputs.push(await toTrezorOpReturnOutput(script, output.value, chain));
+      continue;
     }
 
     const outputAddress = await decodeOutputAddress(script);
@@ -411,7 +448,7 @@ function buildZcashTxInputsForTrezor(
   return inputs;
 }
 
-function buildZcashTxOutputsForTrezor({
+async function buildZcashTxOutputsForTrezor({
   addressN,
   chain,
   myAddress,
@@ -430,12 +467,8 @@ function buildZcashTxOutputsForTrezor({
     const outputAddress = tx.getOutputAddress(i, network);
     const script = output.script;
 
-    if (output.amount === 0n && script?.length > 0 && script[0] === 0x6a) {
-      const opReturnData = decodeOpReturnData(script);
-      if (opReturnData) {
-        outputs.push({ amount: "0", op_return_data: opReturnData, script_type: "PAYTOOPRETURN" as const });
-        continue;
-      }
+    if (script?.[0] === 0x6a) {
+      outputs.push(await toTrezorOpReturnOutput(script, output.amount, chain));
       continue;
     }
 
@@ -453,12 +486,11 @@ function buildZcashTxOutputsForTrezor({
   return outputs;
 }
 
-function buildUtxoOutputsForTrezor(
+async function buildUtxoOutputsForTrezor(
   tx: Transaction,
   network: BTCNetwork,
   address_n: number[],
   myAddress: string,
-  memo: string,
   chain: Chain,
   scriptType: { input: string; output: string },
   toCashAddress: (addr: string) => string,
@@ -469,17 +501,12 @@ function buildUtxoOutputsForTrezor(
     const output = tx.getOutput(i);
     const outputAddress = tx.getOutputAddress(i, network);
 
-    if (!outputAddress) {
-      const opReturnData = output.script ? decodeOpReturnData(output.script) : null;
-      if (opReturnData !== null || memo) {
-        outputs.push({
-          amount: "0",
-          op_return_data: opReturnData ?? Buffer.from(memo).toString("hex"),
-          script_type: "PAYTOOPRETURN",
-        });
-        continue;
-      }
+    if (output.script?.[0] === 0x6a) {
+      outputs.push(await toTrezorOpReturnOutput(output.script, output.amount, chain));
+      continue;
+    }
 
+    if (!outputAddress) {
       throw new SwapKitError({
         errorKey: "wallet_trezor_failed_to_sign_transaction",
         info: { chain, error: "Unable to decode output address from scriptPubkey" },
@@ -571,6 +598,62 @@ async function getTrezorWallet<T extends Chain>({
       return { ...toolbox, address };
     }
 
+    case Chain.Cardano: {
+      const { getCardanoToolbox } = await import("@swapkit/toolboxes/cardano");
+      const { getCardanoSigner } = await import("./cardanoSigner");
+
+      const connect = await import("@trezor/connect-web");
+      const signer = await getCardanoSigner({ connect, derivationPath });
+      const address = signer.getAddress();
+      const toolbox = getCardanoToolbox({ signer });
+
+      return { ...toolbox, address };
+    }
+
+    case Chain.Ripple: {
+      const { getRippleToolbox } = await import("@swapkit/toolboxes/ripple");
+      const { getRippleSigner } = await import("./rippleSigner");
+
+      const signer = getRippleSigner({ derivationPath });
+      const address = providedAddress ?? (await signer.getAddress());
+      const toolbox = getRippleToolbox({ signer });
+
+      return { ...toolbox, address };
+    }
+
+    case Chain.Solana: {
+      const { getSolanaToolbox } = await import("@swapkit/toolboxes/solana");
+      const { getSolanaSigner } = await import("./solanaSigner");
+
+      const signer = getSolanaSigner({ address: providedAddress, derivationPath });
+      const address = providedAddress ?? (await signer.getAddress());
+      const toolbox = getSolanaToolbox({ signer });
+
+      return { ...toolbox, address };
+    }
+
+    case Chain.Stellar: {
+      const { getStellarToolbox } = await import("@swapkit/toolboxes/stellar");
+      const { getStellarSigner } = await import("./stellarSigner");
+
+      const signer = getStellarSigner({ derivationPath });
+      const address = providedAddress ?? (await signer.getAddress());
+      const toolbox = getStellarToolbox({ signer });
+
+      return { ...toolbox, address };
+    }
+
+    case Chain.Tron: {
+      const { getTronToolbox } = await import("@swapkit/toolboxes/tron");
+      const { getTronSigner } = await import("./tronSigner");
+
+      const signer = getTronSigner({ address: providedAddress, derivationPath });
+      const address = await signer.getAddress();
+      const toolbox = getTronToolbox({ signer });
+
+      return { ...toolbox, address };
+    }
+
     case Chain.Zcash: {
       const { getUtxoToolbox } = await import("@swapkit/toolboxes/utxo");
 
@@ -637,7 +720,7 @@ async function getTrezorWallet<T extends Chain>({
         const address_n = hardenDerivationPath(derivationPath);
 
         const inputs = buildZcashTxInputsForTrezor(tx, [], address_n, hexEncode);
-        const outputs = buildZcashTxOutputsForTrezor({
+        const outputs = await buildZcashTxOutputsForTrezor({
           addressN: address_n,
           chain,
           myAddress: address,
@@ -779,16 +862,17 @@ async function getTrezorWallet<T extends Chain>({
       const baseToolbox = getUtxoToolbox(chain, toolboxParams);
 
       const signTransaction = async (tx: Transaction, inputs: UTXOType[], memo = "") => {
+        await assertTransactionCarriesMemo(tx, memo, chain);
+
         const TrezorConnect = (await import("@trezor/connect-web")).default;
         const address_n = hardenDerivationPath(derivationPath);
         const network = getNetworkForChain(chain as UTXOChain);
 
-        const outputs = buildUtxoOutputsForTrezor(
+        const outputs = await buildUtxoOutputsForTrezor(
           tx,
           network,
           address_n,
           address,
-          memo,
           chain,
           resolvedScriptType,
           toCashAddress,
@@ -902,12 +986,11 @@ async function getTrezorWallet<T extends Chain>({
           });
         }
 
-        const outputs = buildUtxoOutputsForTrezor(
+        const outputs = await buildUtxoOutputsForTrezor(
           tx,
           network,
           address_n,
           address,
-          "",
           chain,
           resolvedScriptType,
           toCashAddress,
@@ -977,12 +1060,11 @@ async function getTrezorWallet<T extends Chain>({
           });
         }
 
-        const outputs = buildUtxoOutputsForTrezor(
+        const outputs = await buildUtxoOutputsForTrezor(
           tx,
           network,
           address_n,
           address,
-          "",
           chain,
           resolvedScriptType,
           toCashAddress,
@@ -1020,16 +1102,17 @@ async function getTrezorWallet<T extends Chain>({
         }>,
         memo = "",
       ) => {
+        await assertTransactionCarriesMemo(tx, memo, chain);
+
         const TrezorConnect = (await import("@trezor/connect-web")).default;
         const network = getNetworkForChain(chain as UTXOChain);
         const baseAddressN = hardenDerivationPath(derivationPath.slice(0, 3) as unknown as DerivationPathArray);
 
-        const outputs = buildUtxoOutputsForTrezor(
+        const outputs = await buildUtxoOutputsForTrezor(
           tx,
           network,
           baseAddressN,
           address,
-          memo,
           chain,
           resolvedScriptType,
           toCashAddress,
@@ -1458,6 +1541,7 @@ export const trezorWallet = createWallet({
     [Chain.BinanceSmartChain]: true,
     [Chain.Bitcoin]: true,
     [Chain.BitcoinCash]: true,
+    [Chain.Cardano]: true,
     [Chain.Dash]: true,
     [Chain.Ethereum]: true,
     [Chain.Gnosis]: true,
@@ -1467,7 +1551,11 @@ export const trezorWallet = createWallet({
     [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,
   },
@@ -1483,6 +1571,7 @@ export const trezorWallet = createWallet({
     Chain.BinanceSmartChain,
     Chain.Bitcoin,
     Chain.BitcoinCash,
+    Chain.Cardano,
     Chain.Dash,
     Chain.Dogecoin,
     Chain.Ethereum,
@@ -1492,7 +1581,11 @@ export const trezorWallet = createWallet({
     Chain.Monad,
     Chain.Optimism,
     Chain.Polygon,
+    Chain.Ripple,
     Chain.Robinhood,
+    Chain.Solana,
+    Chain.Stellar,
+    Chain.Tron,
     Chain.XLayer,
     Chain.Zcash,
   ],

package/src/trezor/rippleSigner.ts

@@ -0,0 +1,100 @@
+import { Chain, type DerivationPathArray, derivationPathToString, SwapKitError } from "@swapkit/helpers";
+import type { RippleTransaction } from "@swapkit/toolboxes/ripple";
+import { GlobalFlags, hashes, isValidClassicAddress } from "xrpl";
+
+// Fields Trezor serializes itself; anything else would be dropped from the signed transaction
+const TREZOR_RIPPLE_FIELDS = new Set([
+  "Account",
+  "Amount",
+  "Destination",
+  "DestinationTag",
+  "Fee",
+  "Flags",
+  "LastLedgerSequence",
+  "Sequence",
+  "SigningPubKey",
+  "TransactionType",
+]);
+
+function notSupported(reason: string) {
+  return new SwapKitError({ errorKey: "wallet_trezor_method_not_supported", info: { chain: Chain.Ripple, reason } });
+}
+
+export function toTrezorRippleTransaction(transaction: RippleTransaction) {
+  const tx = transaction as unknown as Record<string, unknown>;
+
+  if (tx.TransactionType !== "Payment") {
+    throw notSupported(`Trezor only signs XRP payments, got ${String(tx.TransactionType)}`);
+  }
+
+  const unsupportedFields = Object.keys(tx).filter(
+    (field) => tx[field] !== undefined && tx[field] !== null && !TREZOR_RIPPLE_FIELDS.has(field),
+  );
+  if (unsupportedFields.length > 0) {
+    throw notSupported(`Trezor cannot sign XRP payments with ${unsupportedFields.join(", ")}`);
+  }
+
+  const { Amount, Destination, DestinationTag, Fee, Flags, LastLedgerSequence, Sequence } = tx;
+
+  if (typeof Amount !== "string" || !/^\d+$/.test(Amount)) throw notSupported("Trezor only signs native XRP amounts");
+  if (typeof Destination !== "string") throw notSupported("Missing destination");
+  if (!isValidClassicAddress(Destination)) throw notSupported("Destination must be a classic XRP address");
+  if (typeof Fee !== "string" || typeof Sequence !== "number") throw notSupported("Transaction is not autofilled");
+  if (Flags !== undefined && typeof Flags !== "number") throw notSupported("Flags must be numeric");
+  if (((Flags ?? 0) & GlobalFlags.tfInnerBatchTxn) !== 0) {
+    throw notSupported("Trezor cannot sign Batch inner XRP transactions");
+  }
+
+  return {
+    fee: Fee,
+    flags: Flags as number | undefined,
+    maxLedgerVersion: LastLedgerSequence as number | undefined,
+    payment: { amount: Amount, destination: Destination, destinationTag: DestinationTag as number | undefined },
+    sequence: Sequence,
+  };
+}
+
+export function getRippleSigner({ derivationPath }: { derivationPath: DerivationPathArray }) {
+  const path = derivationPathToString(derivationPath);
+  let address = "";
+
+  async function getAddress() {
+    if (address) return address;
+
+    const TrezorConnect = (await import("@trezor/connect-web")).default;
+    const result = await TrezorConnect.rippleGetAddress({ path, showOnTrezor: true });
+
+    if (!result.success) {
+      throw new SwapKitError({
+        errorKey: "wallet_trezor_failed_to_get_address",
+        info: { chain: Chain.Ripple, derivationPath, error: result.payload.error },
+      });
+    }
+
+    address = result.payload.address;
+    return address;
+  }
+
+  async function signTransaction(transaction: RippleTransaction) {
+    const trezorTransaction = toTrezorRippleTransaction(transaction);
+    if (transaction.Account !== (await getAddress())) {
+      throw notSupported("Transaction account does not match the Trezor address");
+    }
+
+    const TrezorConnect = (await import("@trezor/connect-web")).default;
+
+    const result = await TrezorConnect.rippleSignTransaction({ path, transaction: trezorTransaction });
+
+    if (!result.success) {
+      throw new SwapKitError({
+        errorKey: "wallet_trezor_failed_to_sign_transaction",
+        info: { chain: Chain.Ripple, error: result.payload.error },
+      });
+    }
+
+    const tx_blob = result.payload.serializedTx.toUpperCase();
+    return { hash: hashes.hashSignedTx(tx_blob), tx_blob };
+  }
+
+  return { getAddress, signTransaction };
+}

package/src/trezor/solanaSigner.ts

@@ -0,0 +1,129 @@
+import { ed25519 } from "@noble/curves/ed25519.js";
+import { hex } from "@scure/base";
+import { PublicKey, type Transaction, type VersionedTransaction } from "@solana/web3.js";
+import { Chain, type DerivationPathArray, derivationPathToString, SwapKitError } from "@swapkit/helpers";
+
+type SolanaTransaction = Transaction | VersionedTransaction;
+
+function notSupported(reason: string) {
+  return new SwapKitError({ errorKey: "wallet_trezor_method_not_supported", info: { chain: Chain.Solana, reason } });
+}
+
+function getSigners(transaction: SolanaTransaction) {
+  if ("version" in transaction) {
+    const { header, staticAccountKeys } = transaction.message;
+    return {
+      message: transaction.message.serialize(),
+      signerKeys: staticAccountKeys.slice(0, header.numRequiredSignatures),
+    };
+  }
+
+  return {
+    message: transaction.serializeMessage(),
+    signerKeys: transaction.signatures.map(({ publicKey }) => publicKey),
+  };
+}
+
+function getSolanaSigningPayload(transaction: SolanaTransaction, address: string) {
+  const { message, signerKeys } = getSigners(transaction);
+  const signerKey = signerKeys.find((key) => key.toBase58() === address);
+
+  if (!signerKey) throw notSupported("Trezor account is not a required signer of this transaction");
+
+  return { message, signerKey };
+}
+
+function addSolanaSignature<T extends SolanaTransaction>(
+  transaction: T,
+  { message, signature, signerKey }: { message: Uint8Array; signature: Uint8Array; signerKey: PublicKey },
+) {
+  if (signature.length !== 64) {
+    throw new SwapKitError({
+      errorKey: "wallet_trezor_failed_to_sign_transaction",
+      info: { chain: Chain.Solana, error: `Invalid signature length: ${signature.length}` },
+    });
+  }
+
+  if (!ed25519.verify(signature, message, signerKey.toBytes())) {
+    throw new SwapKitError({
+      errorKey: "wallet_trezor_failed_to_sign_transaction",
+      info: { chain: Chain.Solana, error: "Signature does not match the Trezor account" },
+    });
+  }
+
+  transaction.addSignature(signerKey, Buffer.from(signature));
+  return transaction;
+}
+
+export function getSolanaSigner({
+  address,
+  derivationPath,
+}: {
+  address?: string;
+  derivationPath: DerivationPathArray;
+}) {
+  // Trezor firmware only accepts m/44'/501' plus up to two more levels.
+  const [purpose, coinType] = derivationPath;
+  if (purpose !== 44 || coinType !== 501 || derivationPath.length > 4) {
+    throw new SwapKitError({
+      errorKey: "wallet_trezor_derivation_path_not_supported",
+      info: { chain: Chain.Solana, derivationPath },
+    });
+  }
+
+  const path = derivationPathToString(derivationPath, { allHardened: true });
+  const knownKey = address ? new PublicKey(address) : null;
+  let publicKey: PublicKey | null = null;
+
+  async function loadAddress(showOnTrezor: boolean) {
+    if (publicKey) return publicKey.toBase58();
+
+    const TrezorConnect = (await import("@trezor/connect-web")).default;
+    const result = await TrezorConnect.solanaGetAddress({ path, showOnTrezor });
+
+    if (!result.success) {
+      throw new SwapKitError({
+        errorKey: "wallet_trezor_failed_to_get_address",
+        info: { chain: Chain.Solana, derivationPath, error: result.payload.error },
+      });
+    }
+
+    const deviceKey = new PublicKey(result.payload.address);
+    if (knownKey && !deviceKey.equals(knownKey)) {
+      throw new SwapKitError({
+        errorKey: "wallet_trezor_failed_to_get_address",
+        info: { chain: Chain.Solana, derivationPath, error: "Trezor account does not match the restored address" },
+      });
+    }
+
+    publicKey = deviceKey;
+    return result.payload.address;
+  }
+
+  async function signTransaction<T extends SolanaTransaction>(transaction: T) {
+    const { message, signerKey } = getSolanaSigningPayload(transaction, await loadAddress(false));
+    const TrezorConnect = (await import("@trezor/connect-web")).default;
+
+    const result = await TrezorConnect.solanaSignTransaction({ path, serializedTx: hex.encode(message) });
+
+    if (!result.success) {
+      throw new SwapKitError({
+        errorKey: "wallet_trezor_failed_to_sign_transaction",
+        info: { chain: Chain.Solana, error: result.payload.error },
+      });
+    }
+
+    const signature = hex.decode(result.payload.signature.replace(/^0x/, ""));
+    return addSolanaSignature(transaction, { message, signature, signerKey });
+  }
+
+  return {
+    connect: async () => ({ publicKey: new PublicKey(await loadAddress(true)) }),
+    disconnect: () => Promise.resolve(),
+    getAddress: () => loadAddress(true),
+    get publicKey() {
+      return publicKey ?? knownKey;
+    },
+    signTransaction,
+  };
+}