Revamp wallet implementation and add base ledger wallet

Author: Fabrice Bascoulergue

.eslintignore

@@ -3,4 +3,5 @@ docs/
 node_modules/
 proto/
 scripts/
+tests/
 *.d.ts

package.json

@@ -47,6 +47,8 @@
         "@cosmjs/stargate": "^0.24.0-alpha.26",
         "@cosmjs/tendermint-rpc": "^0.24.0-alpha.26",
         "@cosmjs/utils": "^0.24.0-alpha.26",
+        "@ledgerhq/hw-app-cosmos": "^5.46.0",
+        "@ledgerhq/hw-transport": "^5.46.0",
         "@types/uuid": "^8.3.0",
         "crypto-browserify": "^3.12.0",
         "crypto-js": "^4.0.0",
@@ -61,8 +63,11 @@
         "@babel/plugin-transform-runtime": "^7.12.10",
         "@babel/preset-env": "^7.8.3",
         "@babel/preset-typescript": "^7.8.3",
+        "@ledgerhq/hw-transport-node-hid": "^5.46.0",
         "@types/crypto-js": "^4.0.1",
         "@types/jest": "^26.0.20",
+        "@types/ledgerhq__hw-transport": "^4.21.3",
+        "@types/ledgerhq__hw-transport-node-hid": "^4.22.2",
         "cross-env": "^7.0.3",
         "eslint": "^7.19.0",
         "gts": "^3.1.0",

src/client/LumClient.ts

@@ -13,10 +13,7 @@ import {
     DistributionExtension,
 } from '@cosmjs/stargate';
 
-import { LumWallet } from '../wallet';
-import { Message } from '../messages';
-import { sha256, generateAuthInfo, generateSignDoc, generateSignDocBytes, generateTxBytes } from '../utils';
-import { BroadcastTxCommitResponse, TxResponse, TxSearchParams, BlockResponse, Account, Coin, Fee } from '../types';
+import { LumWallet, LumUtils, LumTypes, LumMessages } from '..';
 
 export class LumClient {
     readonly tmClient: Tendermint34Client;
@@ -102,7 +99,7 @@ export class LumClient {
      *
      * @param height block height to get (default to current height)
      */
-    getBlock = async (height?: number): Promise<BlockResponse> => {
+    getBlock = async (height?: number): Promise<LumTypes.BlockResponse> => {
         const response = await this.tmClient.block(height);
         return response;
     };
@@ -112,7 +109,7 @@ export class LumClient {
      *
      * @param address wallet address
      */
-    getAccount = async (address: string): Promise<Account | null> => {
+    getAccount = async (address: string): Promise<LumTypes.Account | null> => {
         const account = await this.queryClient.auth.account(address);
         if (!account) {
             return null;
@@ -129,7 +126,7 @@ export class LumClient {
      *
      * @param address wallet address
      */
-    getAccountUnverified = async (address: string): Promise<Account | null> => {
+    getAccountUnverified = async (address: string): Promise<LumTypes.Account | null> => {
         const account = await this.queryClient.auth.unverified.account(address);
         if (!account) {
             return null;
@@ -147,7 +144,7 @@ export class LumClient {
      * @param address wallet address
      * @param searchDenom Coin denomination (ex: lum)
      */
-    getBalance = async (address: string, searchDenom: string): Promise<Coin | null> => {
+    getBalance = async (address: string, searchDenom: string): Promise<LumTypes.Coin | null> => {
         const balance = await this.queryClient.bank.balance(address, searchDenom);
         return balance ? coinFromProto(balance) : null;
     };
@@ -158,7 +155,7 @@ export class LumClient {
      * @param address wallet address
      * @param searchDenom Coin denomination (ex: lum)
      */
-    getBalanceUnverified = async (address: string, searchDenom: string): Promise<Coin | null> => {
+    getBalanceUnverified = async (address: string, searchDenom: string): Promise<LumTypes.Coin | null> => {
         const balance = await this.queryClient.bank.unverified.balance(address, searchDenom);
         return balance ? coinFromProto(balance) : null;
     };
@@ -168,7 +165,7 @@ export class LumClient {
      *
      * @param address wallet address
      */
-    getAllBalancesUnverified = async (address: string): Promise<Coin[]> => {
+    getAllBalancesUnverified = async (address: string): Promise<LumTypes.Coin[]> => {
         const balances = await this.queryClient.bank.unverified.allBalances(address);
         return balances.map(coinFromProto);
     };
@@ -178,15 +175,15 @@ export class LumClient {
      *
      * @param searchDenom Coin denomination (ex: lum)
      */
-    getSupply = async (searchDenom: string): Promise<Coin | null> => {
+    getSupply = async (searchDenom: string): Promise<LumTypes.Coin | null> => {
         const supply = await this.queryClient.bank.unverified.supplyOf(searchDenom);
         return supply ? coinFromProto(supply) : null;
     };
 
     /**
      * Get all coins supplies
      */
-    getAllSupplies = async (): Promise<Coin[]> => {
+    getAllSupplies = async (): Promise<LumTypes.Coin[]> => {
         const supplies = await this.queryClient.bank.unverified.totalSupply();
         return supplies.map(coinFromProto);
     };
@@ -197,7 +194,7 @@ export class LumClient {
      * @param hash transaction hash to retrieve
      * @param includeProof whether or not to include proof of the transaction inclusion in the block
      */
-    getTx = async (hash: Uint8Array, includeProof?: boolean): Promise<TxResponse | null> => {
+    getTx = async (hash: Uint8Array, includeProof?: boolean): Promise<LumTypes.TxResponse | null> => {
         const result = await this.tmClient.tx({ hash: hash, prove: includeProof });
         return result;
     };
@@ -216,10 +213,10 @@ export class LumClient {
      * @param perPage results per pages (default to 30)
      * @param includeProof whether or not to include proofs of the transactions inclusion in the block
      */
-    searchTx = async (queries: string[], page = 1, perPage = 30, includeProof?: boolean): Promise<TxResponse[]> => {
+    searchTx = async (queries: string[], page = 1, perPage = 30, includeProof?: boolean): Promise<LumTypes.TxResponse[]> => {
         const results = await Promise.all(queries.map((q) => this.txsQuery({ query: q, page: page, per_page: perPage, prove: includeProof })));
         const seenHashes: Uint8Array[] = [];
-        const uniqueResults: TxResponse[] = [];
+        const uniqueResults: LumTypes.TxResponse[] = [];
         for (let r = 0; r < results.length; r++) {
             for (let t = 0; t < results[r].length; t++) {
                 const tx = results[r][t];
@@ -237,9 +234,9 @@ export class LumClient {
      *
      * @param params Search params
      */
-    private txsQuery = async (params: TxSearchParams): Promise<TxResponse[]> => {
+    private txsQuery = async (params: LumTypes.TxSearchParams): Promise<LumTypes.TxResponse[]> => {
         const results = await this.tmClient.txSearch(params);
-        return results.txs as TxResponse[];
+        return results.txs as LumTypes.TxResponse[];
     };
 
     /**
@@ -250,20 +247,18 @@ export class LumClient {
      * @param fee requested fee
      * @param memo optional memo for the transaction
      */
-    signTx = async (wallet: LumWallet, messages: Message[], fee: Fee, memo?: string): Promise<Uint8Array> => {
-        const account = await this.getAccount(wallet.address);
+    signTx = async (wallet: LumWallet, messages: LumMessages.Message[], fee: LumTypes.Fee, memo?: string): Promise<Uint8Array> => {
+        const account = await this.getAccount(wallet.getAddress());
         if (!account) {
             throw new Error('Account not found');
         }
         const { accountNumber, sequence } = account;
         const chainId = await this.getChainId();
 
-        const authInfo = generateAuthInfo(wallet.publicKey, fee, sequence);
-        const signDoc = generateSignDoc(messages, memo, authInfo, chainId, accountNumber);
-        const signBytes = generateSignDocBytes(signDoc);
-        const hashedMessage = sha256(signBytes);
-        const signature = await wallet.signTransaction(hashedMessage);
-        return generateTxBytes(signDoc, signature);
+        const authInfo = LumUtils.generateAuthInfo(wallet.getPublicKey(), fee, sequence);
+        const signDoc = LumUtils.generateSignDoc(messages, memo, authInfo, chainId, accountNumber);
+        const signature = await wallet.signTransaction(signDoc);
+        return LumUtils.generateTxBytes(signDoc, signature);
     };
 
     /**
@@ -272,7 +267,7 @@ export class LumClient {
      *
      * @param tx signed transaction to broadcast
      */
-    broadcastTx = async (tx: Uint8Array): Promise<BroadcastTxCommitResponse> => {
+    broadcastTx = async (tx: Uint8Array): Promise<LumTypes.BroadcastTxCommitResponse> => {
         const response = await this.tmClient.broadcastTxCommit({ tx });
         return response;
     };
@@ -285,7 +280,7 @@ export class LumClient {
      * @param fee requested fee
      * @param memo optional memo for the transaction
      */
-    signAndBroadcastTx = async (wallet: LumWallet, messages: Message[], fee: Fee, memo?: string): Promise<BroadcastTxCommitResponse> => {
+    signAndBroadcastTx = async (wallet: LumWallet, messages: LumMessages.Message[], fee: LumTypes.Fee, memo?: string): Promise<LumTypes.BroadcastTxCommitResponse> => {
         const signedTx = await this.signTx(wallet, messages, fee, memo);
         return this.broadcastTx(signedTx);
     };

src/constants/index.ts

@@ -39,15 +39,15 @@ export const LumBech32PrefixConsPub = 'lumvalconspub';
  * @see https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki
  * @see https://github.com/satoshilabs/slips/blob/master/slip-0044.md
  */
-export const HDPath = "m/44'/837'/0'/0/";
+export const HDPath = "m/44'/837'/0'/";
 
 /**
  * Get a Lum Network HDPath for a specified account index
  *
  * @param accountIndex appended at the end of the default Lum derivation path
  */
-export const getLumHdPath = (accountIndex = 0): string => {
-    return HDPath + accountIndex.toString();
+export const getLumHdPath = (accountIndex = 0, walletIndex = 0): string => {
+    return HDPath + accountIndex.toString() + '/' + walletIndex.toString();
 };
 
 /**

src/declarations.d.ts

@@ -3,3 +3,39 @@
  * Only used by the KeyStore feature therefore not properly declared as it is a minor, almost deprecated feature.
  */
 declare module 'crypto-browserify';
+
+/**
+ * Add ledger missing cosmos app types declarations
+ */
+declare module '@ledgerhq/hw-app-cosmos' {
+    export default class Cosmos {
+        transport: import('@ledgerhq/hw-transport').default<*>;
+
+        constructor(transport: import('@ledgerhq/hw-transport').default<*>, scrambleKey: string);
+        getAppConfiguration(): {
+            test_mode: boolean;
+            version: string;
+            device_locked: boolean;
+            major: string;
+        };
+
+        serializePath(path: Buffer): Buffer;
+
+        serializeHRP(hrp: string): Buffer;
+
+        /**
+         * get Cosmos address for a given BIP 32 path.
+         * @param path a path in BIP 32 format
+         * @param hrp usually cosmos
+         * @option boolDisplay optionally enable or not the display
+         * @return an object with a publicKey, address and (optionally) chainCode
+         * @example
+         * cosmos.getAddress("44'/60'/0'/0/0", "cosmos").then(o => o.address)
+         */
+        getAddress(path: string, hrp: string, boolDisplay?: boolean): Promise<{ publicKey: string; address: string }>;
+
+        foreach<T, A>(arr: T[], callback: (arg0: T, arg1: number) => Promise<A>): Promise<A[]>;
+
+        sign(path: string, message: string): Promise<{ signature: null | Buffer; return_code: number }>;
+    }
+}

src/index.ts

@@ -3,7 +3,7 @@ import * as LumConstants from './constants';
 import * as LumTypes from './types';
 import * as LumMessages from './messages';
 import { LumRegistry } from './registry';
-import { LumWallet } from './wallet';
+import { LumWallet, LumWalletFactory } from './wallet';
 import { LumClient } from './client';
 
-export { LumWallet, LumClient, LumTypes, LumUtils, LumConstants, LumMessages, LumRegistry };
+export { LumWallet, LumWalletFactory, LumClient, LumTypes, LumUtils, LumConstants, LumMessages, LumRegistry };

src/wallet/LumLedgerWallet.ts

@@ -0,0 +1,40 @@
+import Transport from '@ledgerhq/hw-transport';
+import Cosmos from '@ledgerhq/hw-app-cosmos';
+
+import { LumUtils, LumTypes, LumRegistry } from '..';
+import { LumWallet } from '.';
+
+export class LumLedgerWallet extends LumWallet {
+    cosmosApp: Cosmos;
+    private hdPath?: string;
+
+    constructor(transport: Transport) {
+        super();
+        this.cosmosApp = new Cosmos(transport, 'CSM'); // TODO: CSM identifier should either be LUM or dynamic depending on our ledger implementation
+    }
+
+    canChangeAccount = () => {
+        return true;
+    };
+
+    useAccount = async (hdPath: string, addressPrefix: string): Promise<boolean> => {
+        const { address, publicKey } = await this.cosmosApp.getAddress(hdPath, addressPrefix);
+        this.hdPath = hdPath;
+        this.address = address;
+        this.publicKey = LumUtils.fromHex(publicKey);
+        return true;
+    };
+
+    signTransaction = async (doc: LumTypes.SignDoc): Promise<Uint8Array> => {
+        if (!this.hdPath) {
+            throw new Error('No account selected.');
+        }
+        // Implementation is delayed. We are not sure if we will be able to sign transactions using the new protobuf implementation
+        // with the current cosmos ledger application
+        //
+        // Useful doc & code:
+        // sign call: https://github.com/LedgerHQ/ledgerjs/blob/master/packages/hw-app-cosmos/src/Cosmos.js
+        // Expected tx format: https://github.com/cosmos/ledger-cosmos/blob/master/docs/TXSPEC.md
+        throw new Error('Not implemented.');
+    };
+}

src/wallet/LumPaperWallet.ts

@@ -0,0 +1,51 @@
+import { LumUtils, LumConstants, LumMessages, LumTypes } from '..';
+import { LumWallet } from '.';
+
+export class LumPaperWallet extends LumWallet {
+    private readonly mnemonic?: string;
+    private privateKey?: Uint8Array;
+
+    /**
+     * Create a LumPaperWallet instance based on a mnemonic or a private key
+     * This constructor is not intended to be used directly as it does not initialize the underlying key pair
+     * Better use the provided static LumPaperWallet builders
+     *
+     * @param mnemonicOrPrivateKey mnemonic (string) used to derive the private key or private key (Uint8Array)
+     */
+    constructor(mnemonicOrPrivateKey: string | Uint8Array) {
+        super();
+        if (LumUtils.isUint8Array(mnemonicOrPrivateKey)) {
+            this.privateKey = mnemonicOrPrivateKey;
+        } else {
+            this.mnemonic = mnemonicOrPrivateKey;
+        }
+    }
+
+    canChangeAccount = (): boolean => {
+        return !!this.mnemonic;
+    };
+
+    useAccount = async (hdPath = LumConstants.getLumHdPath(0, 0), addressPrefix = LumConstants.LumBech32PrefixAccAddr): Promise<boolean> => {
+        if (this.mnemonic) {
+            this.privateKey = await LumUtils.getPrivateKeyFromMnemonic(this.mnemonic, hdPath);
+            this.publicKey = await LumUtils.getPublicKeyFromPrivateKey(this.privateKey);
+            this.address = LumUtils.getAddressFromPublicKey(this.publicKey, addressPrefix);
+            return true;
+        } else if (this.privateKey) {
+            this.publicKey = await LumUtils.getPublicKeyFromPrivateKey(this.privateKey);
+            this.address = LumUtils.getAddressFromPublicKey(this.publicKey, addressPrefix);
+            return false;
+        }
+        throw new Error('No available mnemonic or private key.');
+    };
+
+    signTransaction = async (doc: LumTypes.SignDoc): Promise<Uint8Array> => {
+        if (!this.privateKey || !this.publicKey) {
+            throw new Error('No account selected.');
+        }
+        const signBytes = LumUtils.generateSignDocBytes(doc);
+        const hashedMessage = LumUtils.sha256(signBytes);
+        const signature = await LumUtils.generateSignature(hashedMessage, this.privateKey);
+        return signature;
+    };
+}