@xchainjs/xchain-thorchain 1.0.11 → 1.1.0

package/lib/index.js

@@ -12,10 +12,11 @@ var crypto$3 = require('crypto');
 var buffer = require('buffer');
 var bignumber = require('bignumber.js');
 var bech32$1 = require('bech32');
-var xchainUtil = require('@xchainjs/xchain-util');
 var bip32 = require('bip32');
 var secp256k1 = require('secp256k1');
+var xchainUtil = require('@xchainjs/xchain-util');
 var xchainClient = require('@xchainjs/xchain-client');
+var THORChainApp = require('@xchainjs/ledger-thorchain');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -45,6 +46,7 @@ var axios__namespace = /*#__PURE__*/_interopNamespace(axios);
 var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
 var buffer__namespace = /*#__PURE__*/_interopNamespace(buffer);
 var bignumber__namespace = /*#__PURE__*/_interopNamespace(bignumber);
+var THORChainApp__default = /*#__PURE__*/_interopDefaultLegacy(THORChainApp);
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -127658,6 +127660,58 @@ const getPrefix = (network) => {
             return 'tthor';
     }
 };
+/**
+ * Parse the derivation path from a string to an Array of numbers
+ * @param {string} path - Path to parse
+ * @returns {number[]} - The derivation path as Array of numbers
+ */
+const parseDerivationPath = (path) => {
+    if (!path.startsWith('m'))
+        throw new Error("Path string must start with 'm'");
+    let rest = path.slice(1);
+    const out = new Array();
+    while (rest) {
+        const match = rest.match(/^\/([0-9]+)('?)/);
+        if (!match)
+            throw new Error('Syntax error while reading path component');
+        const [fullMatch, numberString] = match;
+        const value = build$6.Uint53.fromString(numberString).toNumber();
+        if (value >= Math.pow(2, 31))
+            throw new Error('Component value too high. Must not exceed 2**31-1.');
+        out.push(value);
+        rest = rest.slice(fullMatch.length);
+    }
+    return out;
+};
+/**
+ * Sort JSON object
+ * @param {any} obj - JSON object
+ * @returns {any} JSON object sorted
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function sortedObject(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return obj;
+    }
+    if (Array.isArray(obj)) {
+        return obj.map(sortedObject);
+    }
+    const sortedKeys = Object.keys(obj).sort();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const result = {};
+    // NOTE: Use forEach instead of reduce for performance with large objects eg Wasm code
+    sortedKeys.forEach((key) => {
+        result[key] = sortedObject(obj[key]);
+    });
+    return result;
+}
+/**
+ * Returns a JSON string with objects sorted by key
+ * */
+// eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types, @typescript-eslint/no-explicit-any
+function sortAndStringifyJson(obj) {
+    return JSON.stringify(sortedObject(obj));
+}
 
 /**
  * Import necessary modules and types for the Thorchain client configuration.
@@ -127727,7 +127781,7 @@ const defaultClientConfig = {
 };
 
 /**
- * Thorchain client
+ * Thorchain base client
  */
 class Client extends xchainCosmosSdk.Client {
     /**
@@ -127738,53 +127792,6 @@ class Client extends xchainCosmosSdk.Client {
     constructor(config = defaultClientConfig) {
         super(Object.assign(Object.assign({}, defaultClientConfig), config));
     }
-    /**
-     * Asynchronous version of getAddress method.
-     * @param {number} index Derivation path index of the address to be generated.
-     * @returns {string} A promise that resolves to the generated address.
-     */
-    getAddressAsync(index = 0) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.getAddress(index);
-        });
-    }
-    /**
-     * Get the address derived from the provided phrase.
-     * @param {number | undefined} walletIndex The index of the address derivation path. Default is 0.
-     * @returns {string} The user address at the specified walletIndex.
-     */
-    getAddress(walletIndex) {
-        const seed = getSeed(this.phrase);
-        const node = bip32.fromSeed(seed);
-        const child = node.derivePath(this.getFullDerivationPath(walletIndex || 0));
-        if (!child.privateKey)
-            throw new Error('child does not have a privateKey');
-        // TODO: Make this method async and use CosmosJS official address generation strategy
-        const pubKey = secp256k1.publicKeyCreate(child.privateKey);
-        const rawAddress = this.hash160(Uint8Array.from(pubKey));
-        const words = bech32$1.toWords(Buffer.from(rawAddress));
-        const address = bech32$1.encode(this.prefix, words);
-        return address;
-    }
-    transfer(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const sender = yield this.getAddressAsync(params.walletIndex || 0);
-            const { rawUnsignedTx } = yield this.prepareTx({
-                sender,
-                recipient: params.recipient,
-                asset: params.asset,
-                amount: params.amount,
-                memo: params.memo,
-            });
-            const unsignedTx = protoSigning.decodeTxRaw(encoding.fromBase64(rawUnsignedTx));
-            const signer = yield protoSigning.DirectSecp256k1HdWallet.fromMnemonic(this.phrase, {
-                prefix: this.prefix,
-                hdPaths: [xchainCosmosSdk.makeClientPath(this.getFullDerivationPath(params.walletIndex || 0))],
-            });
-            const tx = yield this.roundRobinSignAndBroadcastTx(sender, unsignedTx, signer);
-            return tx.transactionHash;
-        });
-    }
     /**
      * Get address prefix by network
      * @param {Network} network The network of which return the prefix
@@ -127905,60 +127912,70 @@ class Client extends xchainCosmosSdk.Client {
         });
     }
     /**
-     * Make a deposit
+     * Get deposit transaction
      *
-     * @param {number} param.walletIndex Optional - The index to use to generate the address from the transaction will be done.
-     * If it is not set, address associated with index 0 will be used
-     * @param {Asset} param.asset Optional - The asset that will be deposit. If it is not set, Thorchain native asset will be
-     * used
-     * @param {BaseAmount} param.amount The amount that will be deposit
-     * @param {string} param.memo Optional - The memo associated with the deposit
-     * @param {BigNumber} param.gasLimit Optional - The limit amount of gas allowed to spend in the deposit. If not set, default
-     * value of 600000000 will be used
-     * @returns {string} The deposit hash
+     * @deprecated Use getTransactionData instead
+     * @param {string} txId The transaction ID for which to get the deposit transaction
      */
-    deposit({ walletIndex = 0, asset = AssetRuneNative, amount, memo, gasLimit = new bignumber.BigNumber(DEPOSIT_GAS_LIMIT_VALUE), }) {
+    getDepositTransaction(txId) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Get sender address
-            const sender = yield this.getAddressAsync(walletIndex);
-            // Create signer
-            const signer = yield protoSigning.DirectSecp256k1HdWallet.fromMnemonic(this.phrase, {
-                prefix: this.prefix,
-                hdPaths: [xchainCosmosSdk.makeClientPath(this.getFullDerivationPath(walletIndex || 0))],
-            });
-            const tx = yield this.roundRobinSignAndBroadcastDeposit(sender, signer, gasLimit, amount, memo, asset);
-            return tx.transactionHash;
+            return this.getTransactionData(txId);
         });
     }
     /**
-     * Create and sign transaction without broadcasting it
+     * Get the message type url by type used by the cosmos-sdk client to make certain actions
      *
-     * @deprecated Use prepare Tx instead
+     * @param {MsgTypes} msgType The message type of which return the type url
+     * @returns {string} the type url of the message
      */
-    transferOffline({ walletIndex = 0, recipient, asset, amount, memo, gasLimit = new bignumber.BigNumber(DEFAULT_GAS_LIMIT_VALUE), }) {
+    getMsgTypeUrlByType(msgType) {
+        const messageTypeUrls = {
+            [xchainCosmosSdk.MsgTypes.TRANSFER]: MSG_SEND_TYPE_URL,
+        };
+        return messageTypeUrls[msgType];
+    }
+    /**
+     * Returns the standard fee used by the client
+     *
+     * @returns {StdFee} the standard fee
+     */
+    getStandardFee() {
+        return { amount: [], gas: '6000000' };
+    }
+}
+
+/**
+ * Thorchain Keystore client
+ */
+class ClientKeystore extends Client {
+    /**
+     * Asynchronous version of getAddress method.
+     * @param {number} index Derivation path index of the address to be generated.
+     * @returns {string} A promise that resolves to the generated address.
+     */
+    getAddressAsync(index = 0) {
         return __awaiter(this, void 0, void 0, function* () {
-            // Get sender address
-            const sender = yield this.getAddressAsync(walletIndex);
-            // Prepare unsigned transaction
-            const { rawUnsignedTx } = yield this.prepareTx({
-                sender,
-                recipient: recipient,
-                asset: asset,
-                amount: amount,
-                memo: memo,
-            });
-            // Decode unsigned transaction
-            const unsignedTx = protoSigning.decodeTxRaw(encoding.fromBase64(rawUnsignedTx));
-            // Create signer
-            const signer = yield protoSigning.DirectSecp256k1HdWallet.fromMnemonic(this.phrase, {
-                prefix: this.prefix,
-                hdPaths: [xchainCosmosSdk.makeClientPath(this.getFullDerivationPath(walletIndex))],
-            });
-            const rawTx = yield this.roundRobinSign(sender, unsignedTx, signer, gasLimit);
-            // Return encoded signed transaction
-            return encoding.toBase64(tx$1.TxRaw.encode(rawTx).finish());
+            return this.getAddress(index);
         });
     }
+    /**
+     * Get the address derived from the provided phrase.
+     * @param {number | undefined} walletIndex The index of the address derivation path. Default is 0.
+     * @returns {string} The user address at the specified walletIndex.
+     */
+    getAddress(walletIndex) {
+        const seed = getSeed(this.phrase);
+        const node = bip32.fromSeed(seed);
+        const child = node.derivePath(this.getFullDerivationPath(walletIndex || 0));
+        if (!child.privateKey)
+            throw new Error('child does not have a privateKey');
+        // TODO: Make this method async and use CosmosJS official address generation strategy
+        const pubKey = secp256k1.publicKeyCreate(child.privateKey);
+        const rawAddress = this.hash160(Uint8Array.from(pubKey));
+        const words = bech32$1.toWords(Buffer.from(rawAddress));
+        const address = bech32$1.encode(this.prefix, words);
+        return address;
+    }
     /**
      * Returns the private key associated with an index
      *
@@ -127992,36 +128009,79 @@ class Client extends xchainCosmosSdk.Client {
             return crypto$2.Secp256k1.compressPubkey(pubkey);
         });
     }
-    /**
-     * Get deposit transaction
-     *
-     * @deprecated Use getTransactionData instead
-     * @param {string} txId The transaction ID for which to get the deposit transaction
-     */
-    getDepositTransaction(txId) {
+    transfer(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.getTransactionData(txId);
+            const sender = yield this.getAddressAsync(params.walletIndex || 0);
+            const { rawUnsignedTx } = yield this.prepareTx({
+                sender,
+                recipient: params.recipient,
+                asset: params.asset,
+                amount: params.amount,
+                memo: params.memo,
+            });
+            const unsignedTx = protoSigning.decodeTxRaw(encoding.fromBase64(rawUnsignedTx));
+            const signer = yield protoSigning.DirectSecp256k1HdWallet.fromMnemonic(this.phrase, {
+                prefix: this.prefix,
+                hdPaths: [xchainCosmosSdk.makeClientPath(this.getFullDerivationPath(params.walletIndex || 0))],
+            });
+            const tx = yield this.roundRobinSignAndBroadcastTx(sender, unsignedTx, signer);
+            return tx.transactionHash;
         });
     }
     /**
-     * Get the message type url by type used by the cosmos-sdk client to make certain actions
+     * Make a deposit
      *
-     * @param {MsgTypes} msgType The message type of which return the type url
-     * @returns {string} the type url of the message
+     * @param {number} param.walletIndex Optional - The index to use to generate the address from the transaction will be done.
+     * If it is not set, address associated with index 0 will be used
+     * @param {Asset} param.asset Optional - The asset that will be deposit. If it is not set, Thorchain native asset will be
+     * used
+     * @param {BaseAmount} param.amount The amount that will be deposit
+     * @param {string} param.memo Optional - The memo associated with the deposit
+     * @param {BigNumber} param.gasLimit Optional - The limit amount of gas allowed to spend in the deposit. If not set, default
+     * value of 600000000 will be used
+     * @returns {string} The deposit hash
      */
-    getMsgTypeUrlByType(msgType) {
-        const messageTypeUrls = {
-            [xchainCosmosSdk.MsgTypes.TRANSFER]: MSG_SEND_TYPE_URL,
-        };
-        return messageTypeUrls[msgType];
+    deposit({ walletIndex = 0, asset = AssetRuneNative, amount, memo, gasLimit = new bignumber.BigNumber(DEPOSIT_GAS_LIMIT_VALUE), }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get sender address
+            const sender = yield this.getAddressAsync(walletIndex);
+            // Create signer
+            const signer = yield protoSigning.DirectSecp256k1HdWallet.fromMnemonic(this.phrase, {
+                prefix: this.prefix,
+                hdPaths: [xchainCosmosSdk.makeClientPath(this.getFullDerivationPath(walletIndex || 0))],
+            });
+            const tx = yield this.roundRobinSignAndBroadcastDeposit(sender, signer, gasLimit, amount, memo, asset);
+            return tx.transactionHash;
+        });
     }
     /**
-     * Returns the standard fee used by the client
+     * Create and sign transaction without broadcasting it
      *
-     * @returns {StdFee} the standard fee
+     * @deprecated Use prepare Tx instead
      */
-    getStandardFee() {
-        return { amount: [], gas: '6000000' };
+    transferOffline({ walletIndex = 0, recipient, asset, amount, memo, gasLimit = new bignumber.BigNumber(DEFAULT_GAS_LIMIT_VALUE), }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get sender address
+            const sender = yield this.getAddressAsync(walletIndex);
+            // Prepare unsigned transaction
+            const { rawUnsignedTx } = yield this.prepareTx({
+                sender,
+                recipient: recipient,
+                asset: asset,
+                amount: amount,
+                memo: memo,
+            });
+            // Decode unsigned transaction
+            const unsignedTx = protoSigning.decodeTxRaw(encoding.fromBase64(rawUnsignedTx));
+            // Create signer
+            const signer = yield protoSigning.DirectSecp256k1HdWallet.fromMnemonic(this.phrase, {
+                prefix: this.prefix,
+                hdPaths: [xchainCosmosSdk.makeClientPath(this.getFullDerivationPath(walletIndex))],
+            });
+            const rawTx = yield this.roundRobinSign(sender, unsignedTx, signer, gasLimit);
+            // Return encoded signed transaction
+            return encoding.toBase64(tx$1.TxRaw.encode(rawTx).finish());
+        });
     }
     /**
      * Hashes a buffer using SHA256 followed by RIPEMD160 or RMD160.
@@ -128050,18 +128110,21 @@ class Client extends xchainCosmosSdk.Client {
         return __awaiter(this, void 0, void 0, function* () {
             // Connect to signing client
             for (const url of this.clientUrls[this.network]) {
-                const signingClient = yield build$7.SigningStargateClient.connectWithSigner(url, signer, {
-                    registry: this.registry,
-                });
-                // Prepare messages
-                const messages = unsignedTx.body.messages.map((message) => {
-                    return { typeUrl: this.getMsgTypeUrlByType(xchainCosmosSdk.MsgTypes.TRANSFER), value: signingClient.registry.decode(message) };
-                });
-                // Sign transaction
-                return yield signingClient.sign(sender, messages, {
-                    amount: [],
-                    gas: gasLimit.toString(),
-                }, unsignedTx.body.memo);
+                try {
+                    const signingClient = yield build$7.SigningStargateClient.connectWithSigner(url, signer, {
+                        registry: this.registry,
+                    });
+                    // Prepare messages
+                    const messages = unsignedTx.body.messages.map((message) => {
+                        return { typeUrl: this.getMsgTypeUrlByType(xchainCosmosSdk.MsgTypes.TRANSFER), value: signingClient.registry.decode(message) };
+                    });
+                    // Sign transaction
+                    return yield signingClient.sign(sender, messages, {
+                        amount: [],
+                        gas: gasLimit.toString(),
+                    }, unsignedTx.body.memo);
+                }
+                catch (_a) { }
             }
             throw Error('No clients available. Can not sign transaction');
         });
@@ -128133,8 +128196,230 @@ class Client extends xchainCosmosSdk.Client {
     }
 }
 
+/**
+ * Thorchain Ledger client
+ */
+class ClientLedger extends Client {
+    constructor(params) {
+        super(Object.assign(Object.assign({}, defaultClientConfig), params));
+        this.app = new THORChainApp__default["default"](params.transport);
+    }
+    /**
+     * Asynchronous version of getAddress method.
+     * @param {number} index Derivation path index of the address to be generated.
+     * @param {boolean} verify True to check the address against the Ledger device, otherwise false
+     * @returns {string} A promise that resolves to the generated address.
+     */
+    getAddressAsync(index, verify = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const derivationPath = parseDerivationPath(this.getFullDerivationPath(index || 0));
+            const { bech32Address } = verify
+                ? yield this.app.showAddressAndPubKey(derivationPath, this.getPrefix(this.network))
+                : yield this.app.getAddressAndPubKey(derivationPath, this.getPrefix(this.network));
+            return bech32Address;
+        });
+    }
+    /**
+     * @deprecated
+     * Asynchronous version of getAddress method. Not supported for ledger client
+     * @throws {Error} Not supported method
+     */
+    getAddress() {
+        throw Error('Sync method not supported for Ledger');
+    }
+    /**
+     * Transfers RUNE or synth token
+     *
+     * @param {TxParams} params The transfer options.
+     * @param {number} params.walletIndex Optional - The index to use to generate the address from the transaction will be done.
+     * If it is not set, address associated with index 0 will be used
+     * @param {asset} params.asset Optional - The asset that will be deposit. If it is not set, Thorchain native asset will be
+     * used
+     * @param {BaseAmount} params.amount The amount that will be transfer
+     * @param {string} params.recipient Recipient of the transfer
+     * @param {string} params.memo Optional - The memo associated with the transfer
+     * @returns {TxHash} The transaction hash.
+     */
+    transfer(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signedTx = yield this.transferOffline(params);
+            return this.broadcastTx(signedTx);
+        });
+    }
+    /**
+     * Make a deposit
+     *
+     * @param {number} param.walletIndex Optional - The index to use to generate the address from the transaction will be done.
+     * If it is not set, address associated with index 0 will be used
+     * @param {Asset} param.asset Optional - The asset that will be deposit. If it is not set, Thorchain native asset will be
+     * used
+     * @param {BaseAmount} param.amount The amount that will be deposit
+     * @param {string} param.memo Optional - The memo associated with the deposit
+     * @param {BigNumber} param.gasLimit Optional - The limit amount of gas allowed to spend in the deposit. If not set, default
+     * value of 600000000 will be used
+     * @returns {string} The deposit hash
+     */
+    deposit({ walletIndex = 0, asset = AssetRuneNative, amount, memo, gasLimit = new bignumber.BigNumber(DEPOSIT_GAS_LIMIT_VALUE), }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sender = yield this.getAddressAsync(walletIndex || 0);
+            const account = yield this.getAccount(sender);
+            const formattedDP = parseDerivationPath(this.getFullDerivationPath(walletIndex || 0));
+            const { compressedPk } = yield this.app.getAddressAndPubKey(formattedDP, this.getPrefix(this.getNetwork()));
+            const pubkey = protoSigning.encodePubkey({
+                type: 'tendermint/PubKeySecp256k1',
+                value: encoding.toBase64(compressedPk),
+            });
+            const msgs = sortedObject([
+                {
+                    type: 'thorchain/MsgDeposit',
+                    value: {
+                        signer: sender,
+                        memo,
+                        coins: [
+                            {
+                                amount: amount.amount().toString(),
+                                asset: xchainUtil.assetToString(asset),
+                            },
+                        ],
+                    },
+                },
+            ]);
+            const fee = { amount: [], gas: gasLimit.toString() };
+            const { signature, returnCode, errorMessage } = yield this.app.sign(formattedDP, sortAndStringifyJson({
+                account_number: account.accountNumber.toString(),
+                chain_id: yield this.getChainId(),
+                fee,
+                memo,
+                msgs,
+                sequence: account.sequence.toString(),
+            }));
+            if (!signature)
+                throw Error(`Can not sign deposit transaction. Return code ${returnCode}. Error: ${errorMessage}`);
+            const aminoTypes = this.getProtocolAminoMessages();
+            const rawTx = tx$1.TxRaw.fromPartial({
+                bodyBytes: yield this.registry.encodeTxBody({
+                    memo,
+                    messages: msgs.map((msg) => aminoTypes.fromAmino(msg)),
+                }),
+                authInfoBytes: protoSigning.makeAuthInfoBytes([
+                    {
+                        pubkey,
+                        sequence: account.sequence,
+                    },
+                ], fee.amount, Number.parseInt(fee.gas), undefined, undefined, signing.SignMode.SIGN_MODE_LEGACY_AMINO_JSON),
+                signatures: [THORChainApp.extractSignatureFromTLV(signature)],
+            });
+            return this.broadcastTx(encoding.toBase64(tx$1.TxRaw.encode(rawTx).finish()));
+        });
+    }
+    /**
+     * @deprecated
+     * Create a transaction and sign it without broadcasting it
+     *
+     * @param {TxParams} params The transfer options.
+     * @param {number} params.walletIndex Optional - The index to use to generate the address from the transaction will be done.
+     * If it is not set, address associated with index 0 will be used
+     * @param {asset} params.asset Optional - The asset that will be deposit. If it is not set, Thorchain native asset will be
+     * used
+     * @param {BaseAmount} params.amount The amount that will be transfer
+     * @param {string} params.recipient Recipient of the transfer
+     * @param {string} params.memo Optional - The memo associated with the transfer
+     * @returns {TxHash} The transaction hash.
+     */
+    transferOffline(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const sender = yield this.getAddressAsync(params.walletIndex || 0);
+            const account = yield this.getAccount(sender);
+            const formattedDP = parseDerivationPath(this.getFullDerivationPath(params.walletIndex || 0));
+            const { compressedPk } = yield this.app.getAddressAndPubKey(formattedDP, this.getPrefix(this.getNetwork()));
+            const pubkey = protoSigning.encodePubkey({
+                type: 'tendermint/PubKeySecp256k1',
+                value: encoding.toBase64(compressedPk),
+            });
+            const msgs = sortedObject([
+                {
+                    type: 'thorchain/MsgSend',
+                    value: {
+                        from_address: sender,
+                        to_address: params.recipient,
+                        amount: [
+                            {
+                                amount: params.amount.amount().toString(),
+                                denom: this.getDenom(params.asset || AssetRuneNative),
+                            },
+                        ],
+                    },
+                },
+            ]);
+            const fee = this.getStandardFee();
+            const { signature, returnCode, errorMessage } = yield this.app.sign(formattedDP, sortAndStringifyJson({
+                account_number: account.accountNumber.toString(),
+                chain_id: yield this.getChainId(),
+                fee,
+                memo: params.memo || '',
+                msgs,
+                sequence: account.sequence.toString(),
+            }));
+            if (!signature)
+                throw Error(`Can not sign transfer transaction. Return code ${returnCode}. Error: ${errorMessage}`);
+            const aminoTypes = this.getProtocolAminoMessages();
+            const rawTx = tx$1.TxRaw.fromPartial({
+                bodyBytes: yield this.registry.encodeTxBody({
+                    messages: msgs.map((msg) => aminoTypes.fromAmino(msg)),
+                    memo: params.memo,
+                }),
+                authInfoBytes: protoSigning.makeAuthInfoBytes([
+                    {
+                        pubkey,
+                        sequence: account.sequence,
+                    },
+                ], fee.amount, Number.parseInt(fee.gas), undefined, undefined, signing.SignMode.SIGN_MODE_LEGACY_AMINO_JSON),
+                signatures: [THORChainApp.extractSignatureFromTLV(signature)],
+            });
+            return encoding.toBase64(tx$1.TxRaw.encode(rawTx).finish());
+        });
+    }
+    getProtocolAminoMessages() {
+        const prefix = this.getPrefix(this.network);
+        return new build$7.AminoTypes({
+            '/types.MsgSend': {
+                aminoType: `thorchain/MsgSend`,
+                toAmino: (params) => ({
+                    from_address: xchainCosmosSdk.base64ToBech32(params.fromAddress, prefix),
+                    to_address: xchainCosmosSdk.base64ToBech32(params.toAddress, prefix),
+                    amount: [...params.amount],
+                }),
+                fromAmino: (params) => ({
+                    fromAddress: xchainCosmosSdk.bech32ToBase64(params.from_address),
+                    toAddress: xchainCosmosSdk.bech32ToBase64(params.to_address),
+                    amount: [...params.amount],
+                }),
+            },
+            '/types.MsgDeposit': {
+                aminoType: `thorchain/MsgDeposit`,
+                toAmino: (params) => ({
+                    signer: xchainCosmosSdk.base64ToBech32(params.signer, prefix),
+                    memo: params.memo,
+                    coins: params.coins.map((coin) => {
+                        return Object.assign(Object.assign({}, coin), { asset: xchainUtil.assetToString(coin.asset) });
+                    }),
+                }),
+                fromAmino: (params) => ({
+                    signer: xchainCosmosSdk.bech32ToBase64(params.signer),
+                    memo: params.memo,
+                    coins: params.coins.map((coin) => {
+                        return Object.assign(Object.assign({}, coin), { asset: xchainUtil.assetFromStringEx(coin.asset) });
+                    }),
+                }),
+            },
+        });
+    }
+}
+
 exports.AssetRuneNative = AssetRuneNative;
-exports.Client = Client;
+exports.Client = ClientKeystore;
+exports.ClientKeystore = ClientKeystore;
+exports.ClientLedger = ClientLedger;
 exports.DEFAULT_EXPLORER_URL = DEFAULT_EXPLORER_URL;
 exports.DEFAULT_FEE = DEFAULT_FEE;
 exports.DEFAULT_GAS_LIMIT_VALUE = DEFAULT_GAS_LIMIT_VALUE;
@@ -128155,4 +128440,7 @@ exports.getExplorerAddressUrl = getExplorerAddressUrl;
 exports.getExplorerTxUrl = getExplorerTxUrl;
 exports.getPrefix = getPrefix;
 exports.isAssetRuneNative = isAssetRuneNative;
+exports.parseDerivationPath = parseDerivationPath;
+exports.sortAndStringifyJson = sortAndStringifyJson;
+exports.sortedObject = sortedObject;
 //# sourceMappingURL=index.js.map