@exodus/hw-ledger 3.3.0 → 3.4.0

package/CHANGELOG.md

@@ -3,6 +3,19 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.4.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hw-ledger@3.3.1...@exodus/hw-ledger@3.4.0) (2024-10-30)
+
+### Features
+
+- add Tron support to ledger ([#10108](https://github.com/ExodusMovement/exodus-hydra/issues/10108)) ([ce6cace](https://github.com/ExodusMovement/exodus-hydra/commit/ce6cace76803c08841976cfa7fc2f8e2ea346923))
+- drop unused exports from bip322 ([#10142](https://github.com/ExodusMovement/exodus-hydra/issues/10142)) ([6c1a268](https://github.com/ExodusMovement/exodus-hydra/commit/6c1a2687130bdf88ff78c38a599c950c84ae8f60))
+
+## [3.3.1](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hw-ledger@3.3.0...@exodus/hw-ledger@3.3.1) (2024-10-24)
+
+### Bug Fixes
+
+- support legacy transaction signing ([#10154](https://github.com/ExodusMovement/exodus-hydra/issues/10154)) ([55c3d63](https://github.com/ExodusMovement/exodus-hydra/commit/55c3d63e809397b94aa08309b03715fe6d0ed831))
+
 ## [3.3.0](https://github.com/ExodusMovement/exodus-hydra/compare/@exodus/hw-ledger@3.2.0...@exodus/hw-ledger@3.3.0) (2024-10-22)
 
 ### Features

package/lib/module/assets/applications.d.ts

@@ -19,5 +19,10 @@ declare const applications: {
         supportedVersions: string;
         primaryAssetName: string;
     };
+    Tron: {
+        applicationName: string;
+        supportedVersions: string;
+        primaryAssetName: string;
+    };
 };
 export default applications;

package/lib/module/assets/applications.js

@@ -18,10 +18,16 @@ const Polygon = {
     supportedVersions: '^1.10.0',
     primaryAssetName: 'matic',
 };
+const Tron = {
+    applicationName: 'Tron',
+    supportedVersions: '^0.7.0',
+    primaryAssetName: 'tronmainnet',
+};
 const applications = {
     Bitcoin,
     Solana,
     Ethereum,
     Polygon,
+    Tron,
 };
 export default applications;

package/lib/module/assets/index.js

@@ -3,6 +3,7 @@ import basemainnet from './basemainnet';
 import ethereum from './ethereum';
 import matic from './matic';
 import solana from './solana';
+import tronmainnet from './tronmainnet';
 import applications from './applications';
 export const assetApplications = {
     basemainnet,
@@ -13,6 +14,7 @@ export const assetApplications = {
     solana,
     ethereum,
     ethereumsepolia: ethereum,
+    tronmainnet,
 };
 export const supportedBaseAssetNames = Object.keys(assetApplications);
 export const applicationNameToBaseAssetNames = Object.entries(assetApplications).reduce((mapping, [assetName, metadata]) => {

package/lib/module/assets/tronmainnet.d.ts

@@ -0,0 +1,19 @@
+import type Transport from '@ledgerhq/hw-transport';
+import type { Bytes, HardwareWalletAssetHandler } from '@exodus/hw-common';
+export interface TronMessage {
+    rawMessage?: Bytes;
+    TIP712Message?: {
+        address: string;
+        message: Bytes;
+    };
+}
+declare function createHandler(transport: Transport): Promise<HardwareWalletAssetHandler<TronMessage>>;
+declare const metadata: {
+    applications: {
+        applicationName: string;
+        supportedVersions: string;
+        primaryAssetName: string;
+    }[];
+    handler: typeof createHandler;
+};
+export default metadata;

package/lib/module/assets/tronmainnet.js

@@ -0,0 +1,60 @@
+import AppTron from '@ledgerhq/hw-app-trx';
+import assert from 'minimalistic-assert';
+import { XPubUnsupportedError } from '@exodus/hw-common';
+import * as secp256k1 from '@exodus/crypto/secp256k1';
+import applications from './applications';
+async function createHandler(transport) {
+    const app = new AppTron(transport);
+    const getAddress = async (params) => {
+        const { address } = await app.getAddress(params.derivationPath.replace('m/', ''));
+        return address;
+    };
+    const getXPub = async (params) => {
+        throw new XPubUnsupportedError();
+    };
+    const getPublicKey = async (params) => {
+        const { publicKey } = await app.getAddress(params.derivationPath.replace('m/', ''));
+        return secp256k1.publicKeyConvert({
+            publicKey: Buffer.from(publicKey, 'hex'),
+            compressed: true,
+            format: 'buffer',
+        });
+    };
+    const signTransaction = async (params) => {
+        assert(Array.isArray(params.derivationPaths) && params.derivationPaths.length === 1, 'derivationsPath array must be one element long');
+        if (!Buffer.isBuffer(params.signableTransaction)) {
+            throw new TypeError(`signableTransaction must be Buffer or serializable to a Buffer.`);
+        }
+        const signature = await app.signTransaction(params.derivationPaths[0].replace('m/', ''), params.signableTransaction.toString('hex'), []);
+        return [
+            {
+                signature: Buffer.from(signature, 'hex'),
+            },
+        ];
+    };
+    const signMessage = async (params) => {
+        if (params.message.rawMessage) {
+            assert(Buffer.isBuffer(params.message.rawMessage), 'rawMessage must be a buffer');
+            const signature = await app.signPersonalMessage(params.derivationPath.replace('m/', ''), params.message.rawMessage.toString('hex'));
+            return Buffer.from(signature, 'hex');
+        }
+        if (params.message.TIP712Message) {
+            throw new Error('TIP712 messages are not yet supported');
+        }
+        else {
+            assert(false, 'rawMessage or TIP712Message must be specified');
+        }
+    };
+    return {
+        getAddress,
+        getPublicKey,
+        getXPub,
+        signTransaction,
+        signMessage,
+    };
+}
+const metadata = {
+    applications: [applications.Tron],
+    handler: createHandler,
+};
+export default metadata;

package/lib/module/assets/utils/psbt.js

@@ -1,6 +1,6 @@
 import assert from 'minimalistic-assert';
 import { DefaultWalletPolicy, WalletPolicy } from '@exodus/ledger-bitcoin';
-import { payments, address as baddress } from '@exodus/bitcoinjs';
+import { payments, address as baddress, Transaction } from '@exodus/bitcoinjs';
 import { buildBip44PathFromNumber, assertBip44PathNumber, splitBip44PathToNumber, splitBip44DerivationPath, } from './derivation-paths';
 export function assertPsbtOnlyHasAllowedDerivationPaths(psbt, masterFingerprint, derivationPaths) {
     for (let i = 0; i < psbt.getGlobalInputCount(); i++) {
@@ -36,12 +36,23 @@ export function tagPsbtWithDerivationPaths(psbt, masterFingerprint, derivationPa
     const scriptPubKeyToDerivationPathMap = computeScriptPubKeyToDerivationPathMap(derivationPathToPublicKeyMap);
     for (let inputIndex = 0; inputIndex < psbt.getGlobalInputCount(); inputIndex++) {
         const witnessUtxo = psbt.getInputWitnessUtxo(inputIndex);
-        assert(witnessUtxo, `witnessUtxo is currently the only supported type`);
-        const scriptPubKey = witnessUtxo.scriptPubKey.toString('hex');
-        let derivationPath = scriptPubKeyToDerivationPathMap[scriptPubKey];
+        const nonWitnessUtxo = psbt.getInputNonWitnessUtxo(inputIndex);
+        let scriptPubKey;
+        if (witnessUtxo) {
+            scriptPubKey = witnessUtxo.scriptPubKey;
+        }
+        else if (nonWitnessUtxo) {
+            const prevOutputIndex = psbt.getInputOutputIndex(inputIndex);
+            const decodedTransaction = Transaction.fromBuffer(nonWitnessUtxo);
+            scriptPubKey = decodedTransaction.outs[prevOutputIndex].script;
+        }
+        else {
+            throw new Error('missing witnessUtxo or nonWitnessUtxo');
+        }
+        let derivationPath = scriptPubKeyToDerivationPathMap[scriptPubKey.toString('hex')];
         if (addressToDerivationPathMap && !derivationPath) {
             try {
-                const address = baddress.fromOutputScript(witnessUtxo.scriptPubKey);
+                const address = baddress.fromOutputScript(scriptPubKey);
                 derivationPath = addressToDerivationPathMap[address];
             }
             catch { }
@@ -50,7 +61,7 @@ export function tagPsbtWithDerivationPaths(psbt, masterFingerprint, derivationPa
             const publicKey = derivationPathToPublicKeyMap[derivationPath];
             assert(Buffer.isBuffer(publicKey), `no public key found for derivation path`);
             const derivationPathNumerical = splitBip44PathToNumber(derivationPath);
-            if (isTaproot(witnessUtxo.scriptPubKey)) {
+            if (isTaproot(scriptPubKey)) {
                 psbt.setInputTapBip32Derivation(inputIndex, publicKey.slice(1), [], masterFingerprintBuffer, derivationPathNumerical);
             }
             else {
@@ -83,25 +94,41 @@ export function tagPsbtWithDerivationPaths(psbt, masterFingerprint, derivationPa
 }
 function computeScriptPubKeyToDerivationPathMap(derivationPathToPublicKeyMap) {
     return Object.entries(derivationPathToPublicKeyMap).reduce((acc, [derivationPath, publicKey]) => {
-        if (derivationPath.startsWith('m/84')) {
-            const segwitV0 = payments.p2wpkh({
+        if (derivationPath.startsWith('m/44')) {
+            const p2pkh = payments.p2pkh({
                 pubkey: publicKey,
             }).output;
-            if (segwitV0) {
-                Object.assign(acc, {
-                    [segwitV0.toString('hex')]: derivationPath,
-                });
-            }
+            assert(p2pkh, 'failed to compute p2pkh scriptPubKey');
+            Object.assign(acc, {
+                [p2pkh.toString('hex')]: derivationPath,
+            });
+        }
+        else if (derivationPath.startsWith('m/49')) {
+            const nestedSegwit = payments.p2sh({
+                redeem: payments.p2wpkh({ pubkey: publicKey }),
+            }).output;
+            assert(nestedSegwit, 'failed to compute p2pkh scriptPubKey');
+            Object.assign(acc, {
+                [nestedSegwit.toString('hex')]: derivationPath,
+            });
+        }
+        else if (derivationPath.startsWith('m/84')) {
+            const p2wpkh = payments.p2wpkh({
+                pubkey: publicKey,
+            }).output;
+            assert(p2wpkh, 'failed to compute p2wpkh scriptPubKey');
+            Object.assign(acc, {
+                [p2wpkh.toString('hex')]: derivationPath,
+            });
         }
         else if (derivationPath.startsWith('m/86')) {
-            const taproot = payments.p2tr({
+            const p2tr = payments.p2tr({
                 internalPubkey: publicKey.slice(1),
             }).output;
-            if (taproot) {
-                Object.assign(acc, {
-                    [taproot.toString('hex')]: derivationPath,
-                });
-            }
+            assert(p2tr, 'failed to compute p2tr scriptPubKey');
+            Object.assign(acc, {
+                [p2tr.toString('hex')]: derivationPath,
+            });
         }
         return acc;
     }, Object.create(null));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/hw-ledger",
-  "version": "3.3.0",
+  "version": "3.4.0",
   "description": "The ledger module",
   "author": "Exodus Movement, Inc.",
   "repository": {
@@ -41,6 +41,7 @@
     "@exodus/ledgerhq-hw-app-eth": "^6.33.7-exodus.8",
     "@exodus/redux-dependency-injection": "^4.0.0",
     "@ledgerhq/hw-app-solana": "^7.0.10",
+    "@ledgerhq/hw-app-trx": "^6.29.4",
     "@ledgerhq/hw-transport": "^6.28.5",
     "@metamask/eth-sig-util": "^4.0.1",
     "bs58": "^4.0.0",
@@ -64,5 +65,5 @@
     "redux": "^4.2.1",
     "tiny-secp256k1": "^2.2.3"
   },
-  "gitHead": "6a40d50082582568d68206d8926737eea560fa50"
+  "gitHead": "6e5284fe84bcaee8b2640f98ea0bf2f19db5e5ff"
 }