@rango-dev/provider-trezor 0.28.1-next.2 → 0.29.0

package/src/signers/utxo.ts

@@ -1,90 +0,0 @@
-import type { GenericSigner, Transfer } from 'rango-types';
-
-import { Networks } from '@rango-dev/wallets-shared';
-import { SignerError } from 'rango-types';
-
-import { getBitcoinDerivationPath } from '../state.js';
-import { getTrezorModule } from '../utils.js';
-import { BITCOIN_COIN_NAME } from '../utxo/config.js';
-import { buildTrezorBitcoinTransaction } from '../utxo/psbt.js';
-
-function getTrezorErrorMessage(payload: { error: string; code?: string }) {
-  return new Error(
-    payload.code ? `${payload.error} (${payload.code})` : payload.error
-  );
-}
-
-export class BTCSigner implements GenericSigner<Transfer> {
-  async signMessage(): Promise<string> {
-    throw SignerError.UnimplementedError('signMessage');
-  }
-
-  async signAndSendTx(tx: Transfer): Promise<{ hash: string }> {
-    const { blockchain } = tx.asset;
-    if (blockchain !== Networks.BTC) {
-      throw new Error(
-        `Signing ${blockchain} transactions is not supported by Trezor.`
-      );
-    }
-
-    const { psbt } = tx;
-    if (!psbt) {
-      throw new Error(
-        'No PSBT found to sign. Ensure a valid PSBT is provided.'
-      );
-    }
-
-    const path = getBitcoinDerivationPath();
-    if (!path) {
-      throw new Error(
-        'No connected Bitcoin account found. Please connect the wallet first.'
-      );
-    }
-
-    const TrezorConnect = await getTrezorModule();
-    const { inputs, outputs, version, locktime } =
-      buildTrezorBitcoinTransaction(psbt.unsignedPsbtBase64, path);
-
-    // `push: true` signs and broadcasts via Trezor's Blockbook backend.
-    const result = await TrezorConnect.signTransaction({
-      coin: BITCOIN_COIN_NAME,
-      inputs,
-      outputs,
-      version,
-      locktime,
-      push: true,
-    });
-
-    if (!result.success) {
-      throw getTrezorErrorMessage(result.payload);
-    }
-
-    return { hash: await this.#resolveHash(result.payload) };
-  }
-
-  /**
-   * `push: true` usually returns the txid directly. If it isn't present (older
-   * firmware/connect), push the serialized transaction explicitly as a fallback.
-   */
-  async #resolveHash(payload: {
-    txid?: string;
-    serializedTx?: string;
-  }): Promise<string> {
-    if (payload.txid) {
-      return payload.txid;
-    }
-    if (!payload.serializedTx) {
-      throw new Error('Trezor did not return a transaction id.');
-    }
-
-    const TrezorConnect = await getTrezorModule();
-    const pushResult = await TrezorConnect.pushTransaction({
-      tx: payload.serializedTx,
-      coin: BITCOIN_COIN_NAME,
-    });
-    if (!pushResult.success) {
-      throw getTrezorErrorMessage(pushResult.payload);
-    }
-    return pushResult.payload.txid;
-  }
-}

package/src/utxo/config.ts

@@ -1,67 +0,0 @@
-/*
- * Trezor needs the input `script_type` to sign a Bitcoin input. It is determined by the
- * BIP-43 `purpose` of the derivation path the address was derived from, so we expose the
- * four common address types and let the user connect whichever one they hold funds on.
- */
-export type TrezorInputScriptType =
-  | 'SPENDADDRESS'
-  | 'SPENDP2SHWITNESS'
-  | 'SPENDWITNESS'
-  | 'SPENDTAPROOT';
-
-export interface BitcoinAddressType {
-  /** Stable id used in the derivationPath metadata entries. */
-  id: 'legacy' | 'nested-segwit' | 'native-segwit' | 'taproot';
-  label: string;
-  /** BIP-43 purpose: 44 legacy, 49 nested segwit, 84 native segwit, 86 taproot. */
-  purpose: number;
-  inputScriptType: TrezorInputScriptType;
-}
-
-export const BITCOIN_COIN_NAME = 'btc';
-
-export const BITCOIN_ADDRESS_TYPES: readonly BitcoinAddressType[] = [
-  {
-    id: 'native-segwit',
-    label: 'Native SegWit',
-    purpose: 84,
-    inputScriptType: 'SPENDWITNESS',
-  },
-  {
-    id: 'nested-segwit',
-    label: 'Nested SegWit',
-    purpose: 49,
-    inputScriptType: 'SPENDP2SHWITNESS',
-  },
-  {
-    id: 'legacy',
-    label: 'Legacy',
-    purpose: 44,
-    inputScriptType: 'SPENDADDRESS',
-  },
-  {
-    id: 'taproot',
-    label: 'Taproot',
-    purpose: 86,
-    inputScriptType: 'SPENDTAPROOT',
-  },
-] as const;
-
-/**
- * Resolve the Trezor input script type for a derivation path by reading its BIP-43
- * purpose (the first hardened level). The path always comes from one of our own
- * derivation templates, so an unknown purpose is a programming error.
- */
-export function resolveBitcoinScriptType(path: string): TrezorInputScriptType {
-  const purpose = Number.parseInt(
-    path.replace(/^m\//, '').split('/')[0]?.replace(/['h]$/, '') ?? '',
-    10
-  );
-  const addressType = BITCOIN_ADDRESS_TYPES.find(
-    (type) => type.purpose === purpose
-  );
-  if (!addressType) {
-    throw new Error(`Unsupported Bitcoin derivation path: ${path}`);
-  }
-  return addressType.inputScriptType;
-}

package/src/utxo/psbt.test.ts

@@ -1,162 +0,0 @@
-/* eslint-disable @typescript-eslint/no-magic-numbers */
-import * as ecc from '@bitcoinerlab/secp256k1';
-import * as bitcoin from 'bitcoinjs-lib';
-import { describe, expect, it } from 'vitest';
-
-import { buildTrezorBitcoinTransaction } from './psbt.js';
-
-bitcoin.initEccLib(ecc);
-const NETWORK = bitcoin.networks.bitcoin;
-
-const PRIVATE_KEY = Buffer.alloc(32, 7);
-const PUBKEY = Buffer.from(
-  ecc.pointFromScalar(PRIVATE_KEY, true) as Uint8Array
-);
-const { address: OWN_ADDRESS } = bitcoin.payments.p2wpkh({
-  pubkey: PUBKEY,
-  network: NETWORK,
-});
-
-const NATIVE_SEGWIT_PATH = "m/84'/0'/0'/0/0";
-
-// Non-palindromic on purpose, so the txid byte-reversal is actually exercised.
-const FAKE_PREV_TXID =
-  '0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef';
-const RECIPIENT = 'bc1qar0srrr7xfkvy5l643lydnw9re59gtzzwf5mdq';
-
-function nativeSegwitInput() {
-  const witnessScript = bitcoin.payments.p2wpkh({
-    pubkey: PUBKEY,
-    network: NETWORK,
-  }).output as Buffer;
-  return {
-    hash: FAKE_PREV_TXID,
-    index: 0,
-    witnessUtxo: { script: witnessScript, value: 100_000 },
-  };
-}
-
-describe('buildTrezorBitcoinTransaction', () => {
-  it('maps each input to the connected path and its script type', () => {
-    const psbt = new bitcoin.Psbt({ network: NETWORK });
-    psbt.addInput(nativeSegwitInput());
-    psbt.addOutput({ address: RECIPIENT, value: 90_000 });
-
-    const { inputs } = buildTrezorBitcoinTransaction(
-      psbt.toBase64(),
-      NATIVE_SEGWIT_PATH,
-      NETWORK
-    );
-
-    expect(inputs).toHaveLength(1);
-    expect(inputs[0].address_n).toBe(NATIVE_SEGWIT_PATH);
-    expect(inputs[0].script_type).toBe('SPENDWITNESS');
-    expect(inputs[0].prev_hash).toBe(FAKE_PREV_TXID);
-    expect(inputs[0].prev_index).toBe(0);
-    expect(inputs[0].amount).toBe('100000');
-  });
-
-  it('preserves version, locktime and per-input sequence from the PSBT', () => {
-    const psbt = new bitcoin.Psbt({ network: NETWORK });
-    psbt.setVersion(2);
-    psbt.setLocktime(800_000);
-    // RBF-signaling sequence.
-    psbt.addInput({ ...nativeSegwitInput(), sequence: 0xfffffffd });
-    psbt.addOutput({ address: RECIPIENT, value: 90_000 });
-
-    const { inputs, version, locktime } = buildTrezorBitcoinTransaction(
-      psbt.toBase64(),
-      NATIVE_SEGWIT_PATH,
-      NETWORK
-    );
-
-    expect(version).toBe(2);
-    expect(locktime).toBe(800_000);
-    expect(inputs[0].sequence).toBe(0xfffffffd);
-  });
-
-  it('rejects an input with a non-SIGHASH_ALL sighash type', () => {
-    const psbt = new bitcoin.Psbt({ network: NETWORK });
-    psbt.addInput({
-      ...nativeSegwitInput(),
-      sighashType: bitcoin.Transaction.SIGHASH_SINGLE,
-    });
-    psbt.addOutput({ address: RECIPIENT, value: 90_000 });
-
-    expect(() =>
-      buildTrezorBitcoinTransaction(
-        psbt.toBase64(),
-        NATIVE_SEGWIT_PATH,
-        NETWORK
-      )
-    ).toThrow(/only SIGHASH_ALL is supported/);
-  });
-
-  it('reconstructs outputs as address payments', () => {
-    const psbt = new bitcoin.Psbt({ network: NETWORK });
-    psbt.addInput(nativeSegwitInput());
-    psbt.addOutput({ address: RECIPIENT, value: 60_000 });
-    psbt.addOutput({ address: OWN_ADDRESS as string, value: 39_000 });
-
-    const { outputs } = buildTrezorBitcoinTransaction(
-      psbt.toBase64(),
-      NATIVE_SEGWIT_PATH,
-      NETWORK
-    );
-
-    expect(outputs).toEqual([
-      { script_type: 'PAYTOADDRESS', address: RECIPIENT, amount: '60000' },
-      { script_type: 'PAYTOADDRESS', address: OWN_ADDRESS, amount: '39000' },
-    ]);
-  });
-
-  it('derives the script type from the path purpose (legacy P2PKH)', () => {
-    const p2pkh = bitcoin.payments.p2pkh({ pubkey: PUBKEY, network: NETWORK });
-
-    // A previous transaction that funds the legacy address at vout 0.
-    const prevTx = new bitcoin.Transaction();
-    prevTx.version = 2;
-    prevTx.addInput(Buffer.alloc(32, 1), 0);
-    prevTx.addOutput(p2pkh.output as Buffer, 100_000);
-
-    const psbt = new bitcoin.Psbt({ network: NETWORK });
-    psbt.addInput({
-      hash: prevTx.getId(),
-      index: 0,
-      nonWitnessUtxo: prevTx.toBuffer(),
-    });
-    psbt.addOutput({ address: RECIPIENT, value: 90_000 });
-
-    const { inputs } = buildTrezorBitcoinTransaction(
-      psbt.toBase64(),
-      "m/44'/0'/0'/0/0",
-      NETWORK
-    );
-
-    expect(inputs[0].script_type).toBe('SPENDADDRESS');
-    expect(inputs[0].amount).toBe('100000');
-  });
-
-  it('encodes an OP_RETURN output as PAYTOOPRETURN', () => {
-    const memo = Buffer.from('rango', 'utf8');
-    const psbt = new bitcoin.Psbt({ network: NETWORK });
-    psbt.addInput(nativeSegwitInput());
-    psbt.addOutput({ address: RECIPIENT, value: 90_000 });
-    psbt.addOutput({
-      script: bitcoin.payments.embed({ data: [memo] }).output as Buffer,
-      value: 0,
-    });
-
-    const { outputs } = buildTrezorBitcoinTransaction(
-      psbt.toBase64(),
-      NATIVE_SEGWIT_PATH,
-      NETWORK
-    );
-
-    expect(outputs[1]).toEqual({
-      script_type: 'PAYTOOPRETURN',
-      amount: '0',
-      op_return_data: memo.toString('hex'),
-    });
-  });
-});

package/src/utxo/psbt.ts

@@ -1,96 +0,0 @@
-import type { SignTransaction } from '@trezor/connect-web';
-
-import * as ecc from '@bitcoinerlab/secp256k1';
-import * as bitcoin from 'bitcoinjs-lib';
-
-import { resolveBitcoinScriptType } from './config.js';
-
-// Lets bitcoinjs-lib decode taproot (witness v1) output addresses.
-bitcoin.initEccLib(ecc);
-
-type TrezorInput = SignTransaction['inputs'][number];
-type TrezorOutput = SignTransaction['outputs'][number];
-
-export interface TrezorBitcoinTransaction {
-  inputs: TrezorInput[];
-  outputs: TrezorOutput[];
-  /** Transaction version from the PSBT — preserved so the signed tx matches Rango's. */
-  version: number;
-  /** Transaction locktime from the PSBT (e.g. for CLTV) — preserved as-is. */
-  locktime: number;
-}
-
-const reverseTxid = (hash: Buffer) =>
-  Buffer.from(hash).reverse().toString('hex');
-
-/**
- * Translate Rango's unsigned PSBT into the transaction Trezor's `signTransaction` expects
- * (Trezor has no "sign this PSBT" call). Every field that affects the resulting bytes is
- * preserved: `version`, `locktime`, and per-input `sequence` (RBF / locktime signaling),
- * alongside each input's amount and script.
- *
- * Rango's PSBT carries no derivation data, so the connected `path` (and the script type
- * from its BIP-43 purpose) is applied to every input — Rango funds the swap from that
- * single address. `refTxs` are omitted: Trezor Connect fetches previous transactions from
- * its Blockbook backend. Pure function -> unit testable.
- *
- * Only SIGHASH_ALL is supported: a non-default per-input sighash can't be honored through
- * Trezor's signTransaction, so we reject it rather than sign the wrong thing. Multisig /
- * script-path spends are out of scope (Rango funds from a single-key address).
- */
-export function buildTrezorBitcoinTransaction(
-  unsignedPsbtBase64: string,
-  path: string,
-  network: bitcoin.Network = bitcoin.networks.bitcoin
-): TrezorBitcoinTransaction {
-  const psbt = bitcoin.Psbt.fromBase64(unsignedPsbtBase64, { network });
-  const scriptType = resolveBitcoinScriptType(path);
-
-  const inputs = psbt.txInputs.map((input, index): TrezorInput => {
-    const data = psbt.data.inputs[index];
-
-    if (
-      data.sighashType != null &&
-      data.sighashType !== bitcoin.Transaction.SIGHASH_ALL
-    ) {
-      throw new Error(
-        `PSBT input #${index} uses sighash type ${data.sighashType}; only SIGHASH_ALL is supported.`
-      );
-    }
-
-    const utxo =
-      data.witnessUtxo ??
-      bitcoin.Transaction.fromBuffer(data.nonWitnessUtxo as Buffer).outs[
-        input.index
-      ];
-    return {
-      // Trezor Connect accepts the path string directly (like our EVM signer).
-      address_n: path,
-      prev_hash: reverseTxid(input.hash),
-      prev_index: input.index,
-      amount: utxo.value.toString(),
-      script_type: scriptType,
-      sequence: input.sequence,
-    };
-  });
-
-  const outputs = psbt.txOutputs.map(
-    (output): TrezorOutput =>
-      output.address
-        ? {
-            script_type: 'PAYTOADDRESS',
-            address: output.address,
-            amount: output.value.toString(),
-          }
-        : {
-            script_type: 'PAYTOOPRETURN',
-            amount: '0',
-            op_return_data: (
-              bitcoin.script.decompile(output.script)?.find(Buffer.isBuffer) ??
-              Buffer.alloc(0)
-            ).toString('hex'),
-          }
-  );
-
-  return { inputs, outputs, version: psbt.version, locktime: psbt.locktime };
-}