@rango-dev/provider-trezor 0.29.0 → 0.29.1-next.1

package/src/mod.ts

@@ -1,12 +1,8 @@
 import { defineVersions } from '@hub3js/core/utils';
 
-import { buildLegacyProvider } from './legacy/index.js';
 import { buildProvider } from './provider.js';
 
 const versions = () =>
-  defineVersions()
-    .version('0.0.0', buildLegacyProvider())
-    .version('1.0.0', buildProvider())
-    .build();
+  defineVersions().version('1.0.0', buildProvider()).build();
 
 export { versions };

package/src/namespaces/evm.ts

@@ -7,15 +7,12 @@ import { standardizeAndThrowError } from '@hub3js/std/operators';
 import { ETHEREUM_CHAIN_ID } from '@rango-dev/wallets-shared';
 
 import { WALLET_ID } from '../constants.js';
+import { initTrezor } from '../init.js';
+import { setDerivationPath } from '../state.js';
 import {
   getEthereumAccounts,
-  getTrezorModule,
   getTrezorNormalizedDerivationPath,
-} from '../legacy/helpers.js';
-import { getTrezorManifest } from '../provider.js';
-import { setDerivationPath } from '../state.js';
-
-let isTrezorInitialized = false;
+} from '../utils.js';
 
 const connect = builders
   .connect()
@@ -27,14 +24,7 @@ const connect = builders
       getTrezorNormalizedDerivationPath(options.derivationPath)
     );
 
-    if (!isTrezorInitialized) {
-      const TrezorConnect = await getTrezorModule();
-      await TrezorConnect.init({
-        lazyLoad: true, // this param will prevent iframe injection until TrezorConnect.method will be called
-        manifest: getTrezorManifest(),
-      });
-      isTrezorInitialized = true;
-    }
+    await initTrezor();
 
     const result = await getEthereumAccounts();
 

package/src/namespaces/utxo.ts

@@ -0,0 +1,24 @@
+import type { UtxoActions } from '@rango-dev/wallets-core/namespaces/utxo';
+
+import { NamespaceBuilder } from '@hub3js/core';
+import * as commonBuilders from '@hub3js/std/builders';
+import { standardizeAndThrowError } from '@hub3js/std/operators';
+import { builders } from '@rango-dev/wallets-core/namespaces/utxo';
+
+import { utxoActions } from '../actions/utxo.js';
+import { WALLET_ID } from '../constants.js';
+
+const connect = builders
+  .connect()
+  .action(utxoActions.connect())
+  .or(standardizeAndThrowError)
+  .build();
+
+const disconnect = commonBuilders.disconnect<UtxoActions>().build();
+
+const utxo = new NamespaceBuilder<UtxoActions>('UTXO', WALLET_ID)
+  .action(connect)
+  .action(disconnect)
+  .build();
+
+export { utxo };

package/src/provider.ts

@@ -4,6 +4,7 @@ import { ProviderBuilder } from '@hub3js/core';
 
 import { metadata, WALLET_ID } from './constants.js';
 import { evm } from './namespaces/evm.js';
+import { utxo } from './namespaces/utxo.js';
 
 let trezorManifest: Environments['manifest'];
 
@@ -24,6 +25,7 @@ const buildProvider = () =>
     })
     .config('metadata', metadata)
     .add('evm', evm)
+    .add('utxo', utxo)
     .build();
 
 export { buildProvider };

package/src/signer.ts

@@ -8,6 +8,10 @@ export default async function getSigners(): Promise<SignerFactory> {
   const { EthereumSigner } = await dynamicImportWithRefinedError(
     async () => await import('./signers/ethereum.js')
   );
+  const { BTCSigner } = await dynamicImportWithRefinedError(
+    async () => await import('./signers/utxo.js')
+  );
   signers.registerSigner(TxType.EVM, new EthereumSigner());
+  signers.registerSigner(TxType.TRANSFER, new BTCSigner());
   return signers;
 }

package/src/signers/ethereum.ts

@@ -5,8 +5,8 @@ import { DEFAULT_ETHEREUM_RPC_URL } from '@rango-dev/wallets-shared';
 import { JsonRpcProvider, Transaction } from 'ethers';
 import { type GenericSigner } from 'rango-types';
 
-import { getTrezorModule, trezorErrorMessages } from '../legacy/helpers.js';
 import { getDerivationPath } from '../state.js';
+import { getTrezorModule, trezorErrorMessages } from '../utils.js';
 
 export function getTrezorErrorMessage(error: unknown) {
   if (

package/src/signers/utxo.ts

@@ -0,0 +1,90 @@
+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/state.ts

@@ -8,3 +8,18 @@ export function setDerivationPath(path: string) {
 export function getDerivationPath() {
   return derivationPath;
 }
+
+/*
+ * Bitcoin's connect-time path, kept for the same reason as the EVM one: Rango's PSBT
+ * carries no derivation data, so the signer must remember which path to sign with. Kept
+ * separate from the EVM path so the two namespaces never collide.
+ */
+let bitcoinDerivationPath = '';
+
+export function setBitcoinDerivationPath(path: string) {
+  bitcoinDerivationPath = path;
+}
+
+export function getBitcoinDerivationPath() {
+  return bitcoinDerivationPath;
+}

package/src/{legacy/helpers.ts → utils.ts}

@@ -3,11 +3,10 @@ import type { TrezorConnect } from '@trezor/connect-web';
 import {
   dynamicImportWithRefinedError,
   ETHEREUM_CHAIN_ID,
-  Networks,
   type ProviderConnectResult,
 } from '@rango-dev/wallets-shared';
 
-import { getDerivationPath } from '../state';
+import { getDerivationPath } from './state.js';
 
 export const trezorErrorMessages: { [statusCode: string]: string } = {
   Failure_ActionCancelled: 'User rejected the transaction.',
@@ -29,18 +28,6 @@ export async function getTrezorModule() {
   return mod.default;
 }
 
-export function getTrezorInstance() {
-  /*
-   * Instances have a required property which is `chainId` and is using in swap execution.
-   * Here we are setting it as Ethereum always since we are supporting only eth for now.
-   */
-  const instances = new Map();
-
-  instances.set(Networks.ETHEREUM, { chainId: ETHEREUM_CHAIN_ID });
-
-  return instances;
-}
-
 export async function getEthereumAccounts(): Promise<ProviderConnectResult> {
   const TrezorConnect = await getTrezorModule();
   const derivationPath = getDerivationPath();

package/src/utxo/config.ts

@@ -0,0 +1,67 @@
+/*
+ * 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

@@ -0,0 +1,162 @@
+/* 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

@@ -0,0 +1,96 @@
+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 };
+}

package/dist/chunk-DRNBRMLU.js

@@ -1,2 +0,0 @@
-var s=Object.defineProperty;var e=(t,r)=>s(t,"name",{value:r,configurable:!0});var n="";function l(t){n=t}e(l,"setDerivationPath");function a(){return n}e(a,"getDerivationPath");import{dynamicImportWithRefinedError as c,ETHEREUM_CHAIN_ID as i,Networks as u}from"@rango-dev/wallets-shared";var w={Failure_ActionCancelled:"User rejected the transaction."};async function d(){let t=await c(async()=>await import("@trezor/connect-web"));return t.default.default?t.default.default:t.default}e(d,"getTrezorModule");function E(){let t=new Map;return t.set(u.ETHEREUM,{chainId:i}),t}e(E,"getTrezorInstance");async function z(){let t=await d(),r=a(),o=await t.ethereumGetAddress({path:r});if(!o.success)throw new Error(o.payload.error);return{accounts:[o.payload.address],chainId:i,derivationPath:r}}e(z,"getEthereumAccounts");var P=e(t=>t&&!t.startsWith("m/")?"m/"+t:t,"getTrezorNormalizedDerivationPath");export{e as a,l as b,a as c,w as d,d as e,E as f,z as g,P as h};
-//# sourceMappingURL=chunk-DRNBRMLU.js.map

package/dist/chunk-DRNBRMLU.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/state.ts", "../src/legacy/helpers.ts"],
-  "sourcesContent": ["// We keep derivationPath here because we need to maintain it for signing transactions after it is set in connect method\nlet derivationPath = '';\n\nexport function setDerivationPath(path: string) {\n  derivationPath = path;\n}\n\nexport function getDerivationPath() {\n  return derivationPath;\n}\n", "import type { TrezorConnect } from '@trezor/connect-web';\n\nimport {\n  dynamicImportWithRefinedError,\n  ETHEREUM_CHAIN_ID,\n  Networks,\n  type ProviderConnectResult,\n} from '@rango-dev/wallets-shared';\n\nimport { getDerivationPath } from '../state';\n\nexport const trezorErrorMessages: { [statusCode: string]: string } = {\n  Failure_ActionCancelled: 'User rejected the transaction.',\n};\n\n// `@trezor/connect-web` is commonjs, when we are importing it dynamically, it has some differences in different tooling. for example vite (you can check widget-examples), goes throw error. this is a workaround for solving this interop issue.\nexport async function getTrezorModule() {\n  const mod = await dynamicImportWithRefinedError(\n    async () => await import('@trezor/connect-web')\n  );\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore\n  if (mod.default.default) {\n    // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n    // @ts-ignore\n    return mod.default.default as unknown as TrezorConnect;\n  }\n\n  return mod.default;\n}\n\nexport function getTrezorInstance() {\n  /*\n   * Instances have a required property which is `chainId` and is using in swap execution.\n   * Here we are setting it as Ethereum always since we are supporting only eth for now.\n   */\n  const instances = new Map();\n\n  instances.set(Networks.ETHEREUM, { chainId: ETHEREUM_CHAIN_ID });\n\n  return instances;\n}\n\nexport async function getEthereumAccounts(): Promise<ProviderConnectResult> {\n  const TrezorConnect = await getTrezorModule();\n  const derivationPath = getDerivationPath();\n  const result = await TrezorConnect.ethereumGetAddress({\n    path: derivationPath,\n  });\n\n  if (!result.success) {\n    throw new Error(result.payload.error);\n  }\n\n  return {\n    accounts: [result.payload.address],\n    chainId: ETHEREUM_CHAIN_ID,\n    derivationPath,\n  };\n}\n\nexport const getTrezorNormalizedDerivationPath = (\n  path: string // TrezorConnect needs master node to be added to derivation path\n) => (path && !path.startsWith('m/') ? 'm/' + path : path);\n"],
-  "mappings": "+EACA,IAAIA,EAAiB,GAEd,SAASC,EAAkBC,EAAc,CAC9CF,EAAiBE,CACnB,CAFgBC,EAAAF,EAAA,qBAIT,SAASG,GAAoB,CAClC,OAAOJ,CACT,CAFgBG,EAAAC,EAAA,qBCLhB,OACE,iCAAAC,EACA,qBAAAC,EACA,YAAAC,MAEK,4BAIA,IAAMC,EAAwD,CACnE,wBAAyB,gCAC3B,EAGA,eAAsBC,GAAkB,CACtC,IAAMC,EAAM,MAAMC,EAChB,SAAY,KAAM,QAAO,qBAAqB,CAChD,EAGA,OAAID,EAAI,QAAQ,QAGPA,EAAI,QAAQ,QAGdA,EAAI,OACb,CAbsBE,EAAAH,EAAA,mBAef,SAASI,GAAoB,CAKlC,IAAMC,EAAY,IAAI,IAEtB,OAAAA,EAAU,IAAIC,EAAS,SAAU,CAAE,QAASC,CAAkB,CAAC,EAExDF,CACT,CAVgBF,EAAAC,EAAA,qBAYhB,eAAsBI,GAAsD,CAC1E,IAAMC,EAAgB,MAAMT,EAAgB,EACtCU,EAAiBC,EAAkB,EACnCC,EAAS,MAAMH,EAAc,mBAAmB,CACpD,KAAMC,CACR,CAAC,EAED,GAAI,CAACE,EAAO,QACV,MAAM,IAAI,MAAMA,EAAO,QAAQ,KAAK,EAGtC,MAAO,CACL,SAAU,CAACA,EAAO,QAAQ,OAAO,EACjC,QAASL,EACT,eAAAG,CACF,CACF,CAhBsBP,EAAAK,EAAA,uBAkBf,IAAMK,EAAoCV,EAC/CW,GACIA,GAAQ,CAACA,EAAK,WAAW,IAAI,EAAI,KAAOA,EAAOA,EAFJ",
-  "names": ["derivationPath", "setDerivationPath", "path", "__name", "getDerivationPath", "dynamicImportWithRefinedError", "ETHEREUM_CHAIN_ID", "Networks", "trezorErrorMessages", "getTrezorModule", "mod", "dynamicImportWithRefinedError", "__name", "getTrezorInstance", "instances", "Networks", "ETHEREUM_CHAIN_ID", "getEthereumAccounts", "TrezorConnect", "derivationPath", "getDerivationPath", "result", "getTrezorNormalizedDerivationPath", "path"]
-}

package/dist/ethereum-AWO7VVVT.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../src/signers/ethereum.ts"],
-  "sourcesContent": ["import type { EvmTransaction } from 'rango-types/mainApi';\n\nimport { cleanEvmError, toHexQuantity } from '@rango-dev/signer-evm';\nimport { DEFAULT_ETHEREUM_RPC_URL } from '@rango-dev/wallets-shared';\nimport { JsonRpcProvider, Transaction } from 'ethers';\nimport { type GenericSigner } from 'rango-types';\n\nimport { getTrezorModule, trezorErrorMessages } from '../legacy/helpers.js';\nimport { getDerivationPath } from '../state.js';\n\nexport function getTrezorErrorMessage(error: unknown) {\n  if (\n    typeof error === 'object' &&\n    error !== null &&\n    'shortMessage' in error &&\n    typeof error.shortMessage === 'string'\n  ) {\n    /*\n     * Some error signs have lengthy, challenging-to-read messages.\n     * shortMessage is used because it is shorter and easier to understand.\n     */\n    return new Error(error.shortMessage, { cause: error });\n  }\n  return cleanEvmError(error);\n}\n\nexport class EthereumSigner implements GenericSigner<EvmTransaction> {\n  async signMessage(msg: string): Promise<string> {\n    const TrezorConnect = await getTrezorModule();\n\n    const { success, payload } = await TrezorConnect.ethereumSignMessage({\n      message: msg,\n      path: getDerivationPath(),\n    });\n    if (!success) {\n      throw new Error(payload.error);\n    }\n    return payload.signature;\n  }\n\n  async signAndSendTx(\n    tx: EvmTransaction,\n    fromAddress: string,\n    chainId: string\n  ): Promise<{ hash: string }> {\n    try {\n      const TrezorConnect = await getTrezorModule();\n      const { gasPrice, maxFeePerGas, maxPriorityFeePerGas } = tx;\n      const isEIP1559 = maxFeePerGas && maxPriorityFeePerGas;\n\n      if (isEIP1559 && !maxFeePerGas) {\n        throw new Error('Missing maxFeePerGas');\n      }\n      if (isEIP1559 && !maxPriorityFeePerGas) {\n        throw new Error('Missing maxPriorityFeePerGas');\n      }\n      if (!isEIP1559 && !gasPrice) {\n        throw new Error('Missing gasPrice');\n      }\n      const provider = new JsonRpcProvider(DEFAULT_ETHEREUM_RPC_URL); // Provider to broadcast transaction\n      const transactionCount = await provider.getTransactionCount(fromAddress); // Get nonce\n      const additionalFields = isEIP1559\n        ? {\n            maxFeePerGas: toHexQuantity(maxFeePerGas || '0'),\n            maxPriorityFeePerGas: toHexQuantity(maxPriorityFeePerGas || '0'),\n          }\n        : {\n            gasPrice: toHexQuantity(gasPrice || '0'),\n          };\n\n      const transaction = {\n        to: tx.to,\n        data: tx.data || '0x',\n        value: toHexQuantity(tx.value?.toString() || '0'),\n        gasLimit: toHexQuantity(tx.gasLimit?.toString() || '0'),\n        chainId: Number.parseInt(chainId),\n        nonce: toHexQuantity(transactionCount.toString()),\n        ...additionalFields,\n      };\n\n      const { success, payload } = await TrezorConnect.ethereumSignTransaction({\n        path: getDerivationPath(),\n        transaction,\n      });\n\n      if (!success) {\n        const errorMessage =\n          trezorErrorMessages[payload?.code || ''] || payload.error;\n        throw new Error(errorMessage);\n      }\n      const { r, s, v } = payload;\n\n      const serializedTx = Transaction.from({\n        ...transaction,\n        nonce: Number.parseInt(transaction.nonce),\n        /*\n         * Type 0: This refers to the legacy transaction type that has been used since Ethereum's inception.\n         * Type 2: This refers to the new transaction type introduced with the EIP-1559 (Ethereum Improvement Proposal 1559) update,\n         * which was part of the London hard fork.\n         */\n        type: isEIP1559 ? 2 : 0,\n        signature: { r, s, v: parseInt(v) },\n      }).serialized;\n      const broadcastResult = await provider.broadcastTransaction(serializedTx);\n\n      return { hash: broadcastResult.hash };\n    } catch (error) {\n      throw getTrezorErrorMessage(error);\n    }\n  }\n}\n"],
-  "mappings": "6DAEA,OAAS,iBAAAA,EAAe,iBAAAC,MAAqB,wBAC7C,OAAS,4BAAAC,MAAgC,4BACzC,OAAS,mBAAAC,EAAiB,eAAAC,MAAmB,SAC7C,MAAmC,cAK5B,SAASC,EAAsBC,EAAgB,CACpD,OACE,OAAOA,GAAU,UACjBA,IAAU,MACV,iBAAkBA,GAClB,OAAOA,EAAM,cAAiB,SAMvB,IAAI,MAAMA,EAAM,aAAc,CAAE,MAAOA,CAAM,CAAC,EAEhDC,EAAcD,CAAK,CAC5B,CAdgBE,EAAAH,EAAA,yBAgBT,IAAMI,EAAN,KAA8D,CA1BrE,MA0BqE,CAAAD,EAAA,uBACnE,MAAM,YAAYE,EAA8B,CAC9C,IAAMC,EAAgB,MAAMC,EAAgB,EAEtC,CAAE,QAAAC,EAAS,QAAAC,CAAQ,EAAI,MAAMH,EAAc,oBAAoB,CACnE,QAASD,EACT,KAAMK,EAAkB,CAC1B,CAAC,EACD,GAAI,CAACF,EACH,MAAM,IAAI,MAAMC,EAAQ,KAAK,EAE/B,OAAOA,EAAQ,SACjB,CAEA,MAAM,cACJE,EACAC,EACAC,EAC2B,CAC3B,GAAI,CACF,IAAMP,EAAgB,MAAMC,EAAgB,EACtC,CAAE,SAAAO,EAAU,aAAAC,EAAc,qBAAAC,CAAqB,EAAIL,EACnDM,EAAYF,GAAgBC,EAElC,GAAIC,GAAa,CAACF,EAChB,MAAM,IAAI,MAAM,sBAAsB,EAExC,GAAIE,GAAa,CAACD,EAChB,MAAM,IAAI,MAAM,8BAA8B,EAEhD,GAAI,CAACC,GAAa,CAACH,EACjB,MAAM,IAAI,MAAM,kBAAkB,EAEpC,IAAMI,EAAW,IAAIC,EAAgBC,CAAwB,EACvDC,EAAmB,MAAMH,EAAS,oBAAoBN,CAAW,EACjEU,EAAmBL,EACrB,CACE,aAAcM,EAAcR,GAAgB,GAAG,EAC/C,qBAAsBQ,EAAcP,GAAwB,GAAG,CACjE,EACA,CACE,SAAUO,EAAcT,GAAY,GAAG,CACzC,EAEEU,EAAc,CAClB,GAAIb,EAAG,GACP,KAAMA,EAAG,MAAQ,KACjB,MAAOY,EAAcZ,EAAG,OAAO,SAAS,GAAK,GAAG,EAChD,SAAUY,EAAcZ,EAAG,UAAU,SAAS,GAAK,GAAG,EACtD,QAAS,OAAO,SAASE,CAAO,EAChC,MAAOU,EAAcF,EAAiB,SAAS,CAAC,EAChD,GAAGC,CACL,EAEM,CAAE,QAAAd,EAAS,QAAAC,CAAQ,EAAI,MAAMH,EAAc,wBAAwB,CACvE,KAAMI,EAAkB,EACxB,YAAAc,CACF,CAAC,EAED,GAAI,CAAChB,EAAS,CACZ,IAAMiB,EACJC,EAAoBjB,GAAS,MAAQ,EAAE,GAAKA,EAAQ,MACtD,MAAM,IAAI,MAAMgB,CAAY,CAC9B,CACA,GAAM,CAAE,EAAAE,EAAG,EAAAC,EAAG,CAAE,EAAInB,EAEdoB,EAAeC,EAAY,KAAK,CACpC,GAAGN,EACH,MAAO,OAAO,SAASA,EAAY,KAAK,EAMxC,KAAMP,EAAY,EAAI,EACtB,UAAW,CAAE,EAAAU,EAAG,EAAAC,EAAG,EAAG,SAAS,CAAC,CAAE,CACpC,CAAC,EAAE,WAGH,MAAO,CAAE,MAFe,MAAMV,EAAS,qBAAqBW,CAAY,GAEzC,IAAK,CACtC,OAAS5B,EAAO,CACd,MAAMD,EAAsBC,CAAK,CACnC,CACF,CACF",
-  "names": ["cleanEvmError", "toHexQuantity", "DEFAULT_ETHEREUM_RPC_URL", "JsonRpcProvider", "Transaction", "getTrezorErrorMessage", "error", "cleanEvmError", "__name", "EthereumSigner", "msg", "TrezorConnect", "getTrezorModule", "success", "payload", "getDerivationPath", "tx", "fromAddress", "chainId", "gasPrice", "maxFeePerGas", "maxPriorityFeePerGas", "isEIP1559", "provider", "JsonRpcProvider", "DEFAULT_ETHEREUM_RPC_URL", "transactionCount", "additionalFields", "toHexQuantity", "transaction", "errorMessage", "trezorErrorMessages", "r", "s", "serializedTx", "Transaction"]
-}

package/dist/legacy/index.d.ts

@@ -1,18 +0,0 @@
-import type { Environments } from '../types.js';
-import type { LegacyProviderInterface } from '@rango-dev/wallets-core/legacy';
-import type { Connect, WalletInfo } from '@rango-dev/wallets-shared';
-import { WalletTypes } from '@rango-dev/wallets-shared';
-import { type BlockchainMeta, type SignerFactory } from 'rango-types';
-import { getTrezorInstance } from './helpers.js';
-export declare const config: {
-    type: WalletTypes;
-};
-export type { Environments };
-type Provider = any;
-export declare const init: (environments: Environments) => void;
-export declare const getInstance: typeof getTrezorInstance;
-export declare const connect: Connect;
-export declare const getSigners: (provider: Provider) => Promise<SignerFactory>;
-export declare const getWalletInfo: (allBlockChains: BlockchainMeta[]) => WalletInfo;
-declare const buildLegacyProvider: () => LegacyProviderInterface;
-export { buildLegacyProvider };