@shapeshiftoss/hdwallet-keepkey 1.62.41 → 1.62.42

package/dist/{mayachain.d.ts → cjs/mayachain.d.ts}

@@ -1,7 +1,6 @@
-import * as MayachainMessages from "@keepkey/device-protocol/lib/messages-mayachain_pb";
-import * as core from "@shapeshiftoss/hdwallet-core";
-import { Transport } from "./transport";
-export declare function mayachainGetAccountPaths(msg: core.MayachainGetAccountPaths): Array<core.MayachainAccountPath>;
+import * as MayachainMessages from '@keepkey/device-protocol/lib/messages-mayachain_pb';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport';
+export declare function mayachainGetAccountPaths(msg: core.MayachainGetAccountPaths): core.MayachainAccountPath[];
 export declare function mayachainGetAddress(transport: Transport, msg: MayachainMessages.MayachainGetAddress.AsObject): Promise<string>;
 export declare function mayachainSignTx(transport: Transport, msg: core.MayachainSignTx): Promise<core.MayachainSignedTx>;
-//# sourceMappingURL=mayachain.d.ts.map

package/dist/cjs/mayachain.js

@@ -0,0 +1,169 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mayachainSignTx = exports.mayachainGetAddress = exports.mayachainGetAccountPaths = void 0;
+const Messages = __importStar(require("@keepkey/device-protocol/lib/messages_pb"));
+const MayachainMessages = __importStar(require("@keepkey/device-protocol/lib/messages-mayachain_pb"));
+const core = __importStar(require("@shapeshiftoss/hdwallet-core"));
+const bs58check_1 = __importDefault(require("bs58check"));
+const p_lazy_1 = __importDefault(require("p-lazy"));
+const protoTxBuilder = p_lazy_1.default.from(() => Promise.resolve().then(() => __importStar(require('@shapeshiftoss/proto-tx-builder'))));
+function mayachainGetAccountPaths(msg) {
+    return [
+        {
+            addressNList: [
+                0x80000000 + 44,
+                0x80000000 + core.slip44ByCoin('Mayachain'),
+                0x80000000 + msg.accountIdx,
+                0,
+                0,
+            ],
+        },
+    ];
+}
+exports.mayachainGetAccountPaths = mayachainGetAccountPaths;
+async function mayachainGetAddress(transport, msg) {
+    const getAddr = new MayachainMessages.MayachainGetAddress();
+    getAddr.setAddressNList(msg.addressNList);
+    getAddr.setShowDisplay(msg.showDisplay !== false);
+    if (msg.testnet !== undefined)
+        getAddr.setTestnet(msg.testnet);
+    const response = await transport.call(Messages.MessageType.MESSAGETYPE_MAYACHAINGETADDRESS, getAddr, {
+        msgTimeout: core.LONG_TIMEOUT,
+    });
+    const mayachainAddress = response.proto;
+    return core.mustBeDefined(mayachainAddress.getAddress());
+}
+exports.mayachainGetAddress = mayachainGetAddress;
+async function mayachainSignTx(transport, msg) {
+    const address = await mayachainGetAddress(transport, { addressNList: msg.addressNList });
+    const getPublicKeyMsg = new Messages.GetPublicKey();
+    getPublicKeyMsg.setAddressNList(msg.addressNList);
+    getPublicKeyMsg.setEcdsaCurveName('secp256k1');
+    const response = await transport.call(Messages.MessageType.MESSAGETYPE_GETPUBLICKEY, getPublicKeyMsg, {
+        msgTimeout: core.DEFAULT_TIMEOUT,
+    });
+    const pubkeyMsg = response.proto;
+    const pubkey = bs58check_1.default.decode(core.mustBeDefined(pubkeyMsg.getXpub())).subarray(45);
+    return transport.lockDuring(async () => {
+        const signTx = new MayachainMessages.MayachainSignTx();
+        signTx.setAddressNList(msg.addressNList);
+        signTx.setAccountNumber(msg.account_number);
+        signTx.setChainId(msg.chain_id);
+        signTx.setFeeAmount(parseInt(msg.tx.fee.amount[0].amount));
+        signTx.setGas(parseInt(msg.tx.fee.gas));
+        signTx.setSequence(msg.sequence);
+        if (msg.tx.memo !== undefined)
+            signTx.setMemo(msg.tx.memo);
+        signTx.setMsgCount(1);
+        let resp = await transport.call(Messages.MessageType.MESSAGETYPE_MAYACHAINSIGNTX, signTx, {
+            msgTimeout: core.LONG_TIMEOUT,
+            omitLock: true,
+        });
+        for (const m of msg.tx.msg) {
+            if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_MAYACHAINMSGREQUEST) {
+                throw new Error(`Unexpected response: ${resp.message_type}`);
+            }
+            const msgAck = new MayachainMessages.MayachainMsgAck();
+            switch (m.type) {
+                case 'mayachain/MsgSend': {
+                    if (m.value.amount.length !== 1) {
+                        throw new Error('Multiple amounts per MsgSend not supported');
+                    }
+                    const denom = m.value.amount[0].denom;
+                    if (denom !== 'cacao')
+                        throw new Error(`Unsupported denomination: ${denom}`);
+                    const send = new MayachainMessages.MayachainMsgSend();
+                    send.setFromAddress(m.value.from_address);
+                    send.setToAddress(m.value.to_address);
+                    send.setAmount(m.value.amount[0].amount);
+                    send.setDenom(denom);
+                    msgAck.setSend(send);
+                    break;
+                }
+                case 'mayachain/MsgDeposit': {
+                    if (m.value.coins.length !== 1) {
+                        throw new Error('Multiple amounts per MsgDeposit not supported');
+                    }
+                    const coinAsset = m.value.coins[0].asset;
+                    if (coinAsset !== 'MAYA.CACAO')
+                        throw new Error(`Unsupported coin asset: ${coinAsset}`);
+                    const deposit = new MayachainMessages.MayachainMsgDeposit();
+                    deposit.setAsset(m.value.coins[0].asset);
+                    deposit.setAmount(m.value.coins[0].amount);
+                    deposit.setMemo(m.value.memo);
+                    deposit.setSigner(m.value.signer);
+                    msgAck.setDeposit(deposit);
+                    break;
+                }
+                default:
+                    throw new Error(`Message ${m.type} is not yet supported`);
+            }
+            resp = await transport.call(Messages.MessageType.MESSAGETYPE_MAYACHAINMSGACK, msgAck, {
+                msgTimeout: core.LONG_TIMEOUT,
+                omitLock: true,
+            });
+        }
+        if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_MAYACHAINSIGNEDTX) {
+            throw new Error(`Unexpected response: ${resp.message_type}`);
+        }
+        const signedTx = resp.proto;
+        const offlineSigner = {
+            async getAccounts() {
+                return [
+                    {
+                        address,
+                        algo: 'secp256k1',
+                        pubkey,
+                    },
+                ];
+            },
+            async signAmino(signerAddress, signDoc) {
+                if (signerAddress !== address)
+                    throw new Error('expected signerAddress to match address');
+                return {
+                    signed: signDoc,
+                    signature: {
+                        pub_key: {
+                            type: 'tendermint/PubKeySecp256k1',
+                            value: signedTx.getPublicKey_asB64(),
+                        },
+                        signature: signedTx.getSignature_asB64(),
+                    },
+                };
+            },
+        };
+        const signerData = {
+            sequence: Number(msg.sequence),
+            accountNumber: Number(msg.account_number),
+            chainId: msg.chain_id,
+        };
+        return (await protoTxBuilder).sign(address, msg.tx, offlineSigner, signerData, 'maya');
+    });
+}
+exports.mayachainSignTx = mayachainSignTx;

package/dist/{osmosis.d.ts → cjs/osmosis.d.ts}

@@ -1,7 +1,6 @@
-import * as OsmosisMessages from "@keepkey/device-protocol/lib/messages-osmosis_pb";
-import * as core from "@shapeshiftoss/hdwallet-core";
-import { Transport } from "./transport";
-export declare function osmosisGetAccountPaths(msg: core.OsmosisGetAccountPaths): Array<core.OsmosisAccountPath>;
+import * as OsmosisMessages from '@keepkey/device-protocol/lib/messages-osmosis_pb';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport';
+export declare function osmosisGetAccountPaths(msg: core.OsmosisGetAccountPaths): core.OsmosisAccountPath[];
 export declare function osmosisGetAddress(transport: Transport, msg: OsmosisMessages.OsmosisGetAddress.AsObject): Promise<string>;
 export declare function osmosisSignTx(transport: Transport, msg: core.OsmosisSignTx): Promise<any>;
-//# sourceMappingURL=osmosis.d.ts.map

package/dist/cjs/osmosis.js

@@ -0,0 +1,270 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.osmosisSignTx = exports.osmosisGetAddress = exports.osmosisGetAccountPaths = void 0;
+const Messages = __importStar(require("@keepkey/device-protocol/lib/messages_pb"));
+const OsmosisMessages = __importStar(require("@keepkey/device-protocol/lib/messages-osmosis_pb"));
+const core = __importStar(require("@shapeshiftoss/hdwallet-core"));
+const hdwallet_core_1 = require("@shapeshiftoss/hdwallet-core");
+const bs58check_1 = __importDefault(require("bs58check"));
+const p_lazy_1 = __importDefault(require("p-lazy"));
+const protoTxBuilder = p_lazy_1.default.from(() => Promise.resolve().then(() => __importStar(require('@shapeshiftoss/proto-tx-builder'))));
+function osmosisGetAccountPaths(msg) {
+    return [
+        {
+            addressNList: [
+                0x80000000 + 44,
+                0x80000000 + core.slip44ByCoin('Osmo'),
+                0x80000000 + msg.accountIdx,
+                0,
+                0,
+            ],
+        },
+    ];
+}
+exports.osmosisGetAccountPaths = osmosisGetAccountPaths;
+async function osmosisGetAddress(transport, msg) {
+    const getAddr = new OsmosisMessages.OsmosisGetAddress();
+    getAddr.setAddressNList(msg.addressNList);
+    getAddr.setShowDisplay(msg.showDisplay !== false);
+    const response = await transport.call(Messages.MessageType.MESSAGETYPE_OSMOSISGETADDRESS, getAddr, {
+        msgTimeout: core.LONG_TIMEOUT,
+    });
+    const osmosisAddress = response.proto;
+    return core.mustBeDefined(osmosisAddress.getAddress());
+}
+exports.osmosisGetAddress = osmosisGetAddress;
+async function osmosisSignTx(transport, msg) {
+    const address = await osmosisGetAddress(transport, {
+        addressNList: msg.addressNList,
+        showDisplay: false,
+    });
+    const getPublicKeyMsg = new Messages.GetPublicKey();
+    getPublicKeyMsg.setAddressNList(msg.addressNList);
+    getPublicKeyMsg.setEcdsaCurveName('secp256k1');
+    const pubkeyMsg = (await transport.call(Messages.MessageType.MESSAGETYPE_GETPUBLICKEY, getPublicKeyMsg, {
+        msgTimeout: core.DEFAULT_TIMEOUT,
+    })).proto;
+    const pubkey = bs58check_1.default.decode(core.mustBeDefined(pubkeyMsg.getXpub())).slice(45);
+    return transport.lockDuring(async () => {
+        const signTx = new OsmosisMessages.OsmosisSignTx();
+        signTx.setAddressNList(msg.addressNList);
+        signTx.setAccountNumber(msg.account_number);
+        signTx.setChainId(msg.chain_id);
+        signTx.setFeeAmount(parseInt(msg.tx.fee.amount[0].amount));
+        signTx.setGas(parseInt(msg.tx.fee.gas));
+        signTx.setSequence(msg.sequence);
+        if (msg.tx.memo !== undefined) {
+            signTx.setMemo(msg.tx.memo);
+        }
+        signTx.setMsgCount(1);
+        let resp = await transport.call(Messages.MessageType.MESSAGETYPE_OSMOSISSIGNTX, signTx, {
+            msgTimeout: core.LONG_TIMEOUT,
+            omitLock: true,
+        });
+        for (const m of msg.tx.msg) {
+            if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_OSMOSISMSGREQUEST) {
+                throw new Error(`osmosis: unexpected response ${resp.message_type}`);
+            }
+            let ack;
+            switch (m.type) {
+                case 'cosmos-sdk/MsgSend': {
+                    // Transfer
+                    if (m.value.amount.length !== 1) {
+                        throw new Error('osmosis: Multiple amounts per msg not supported');
+                    }
+                    const denom = m.value.amount[0].denom;
+                    if (denom !== 'uosmo') {
+                        throw new Error('osmosis: Unsupported denomination: ' + denom);
+                    }
+                    const send = new OsmosisMessages.OsmosisMsgSend();
+                    send.setFromAddress(m.value.from_address);
+                    send.setToAddress(m.value.to_address);
+                    send.setDenom(m.value.amount[0].denom);
+                    send.setAmount(m.value.amount[0].amount);
+                    ack = new OsmosisMessages.OsmosisMsgAck();
+                    ack.setSend(send);
+                    break;
+                }
+                case 'cosmos-sdk/MsgDelegate': {
+                    // Delegate
+                    const denom = m.value.amount.denom;
+                    if (denom !== 'uosmo') {
+                        throw new Error('osmosis: Unsupported denomination: ' + denom);
+                    }
+                    const delegate = new OsmosisMessages.OsmosisMsgDelegate();
+                    delegate.setDelegatorAddress(m.value.delegator_address);
+                    delegate.setValidatorAddress(m.value.validator_address);
+                    delegate.setDenom(m.value.amount.denom);
+                    delegate.setAmount(m.value.amount.amount);
+                    ack = new OsmosisMessages.OsmosisMsgAck();
+                    ack.setDelegate(delegate);
+                    break;
+                }
+                case 'cosmos-sdk/MsgUndelegate': {
+                    // Undelegate
+                    const denom = m.value.amount.denom;
+                    if (denom !== 'uosmo') {
+                        throw new Error('osmosis: Unsupported denomination: ' + denom);
+                    }
+                    const undelegate = new OsmosisMessages.OsmosisMsgUndelegate();
+                    undelegate.setDelegatorAddress(m.value.delegator_address);
+                    undelegate.setValidatorAddress(m.value.validator_address);
+                    undelegate.setDenom(m.value.amount.denom);
+                    undelegate.setAmount(m.value.amount.amount);
+                    ack = new OsmosisMessages.OsmosisMsgAck();
+                    ack.setUndelegate(undelegate);
+                    break;
+                }
+                case 'cosmos-sdk/MsgBeginRedelegate': {
+                    // Redelegate
+                    const denom = m.value.amount.denom;
+                    if (denom !== 'uosmo') {
+                        throw new Error('osmosis: Unsupported denomination: ' + denom);
+                    }
+                    const redelegate = new OsmosisMessages.OsmosisMsgRedelegate();
+                    redelegate.setDelegatorAddress(m.value.delegator_address);
+                    redelegate.setValidatorSrcAddress(m.value.validator_src_address);
+                    redelegate.setValidatorDstAddress(m.value.validator_dst_address);
+                    redelegate.setAmount(m.value.amount.amount);
+                    redelegate.setDenom(m.value.amount.denom);
+                    ack = new OsmosisMessages.OsmosisMsgAck();
+                    ack.setRedelegate(redelegate);
+                    break;
+                }
+                case 'cosmos-sdk/MsgWithdrawDelegationReward': {
+                    // Rewards
+                    const rewards = new OsmosisMessages.OsmosisMsgRewards();
+                    rewards.setDelegatorAddress(m.value.delegator_address);
+                    rewards.setValidatorAddress(m.value.validator_address);
+                    ack = new OsmosisMessages.OsmosisMsgAck();
+                    ack.setRewards(rewards);
+                    break;
+                }
+                case 'osmosis/gamm/join-pool': {
+                    // LP add
+                    const lpAdd = new OsmosisMessages.OsmosisMsgLPAdd();
+                    lpAdd.setSender(m.value.sender);
+                    lpAdd.setPoolId(m.value.pool_id);
+                    lpAdd.setShareOutAmount(m.value.share_out_amount);
+                    lpAdd.setDenomInMaxA(m.value.token_in_maxs[0].denom);
+                    lpAdd.setAmountInMaxA(m.value.token_in_maxs[0].amount);
+                    lpAdd.setDenomInMaxB(m.value.token_in_maxs[1].denom);
+                    lpAdd.setAmountInMaxB(m.value.token_in_maxs[1].amount);
+                    ack = new OsmosisMessages.OsmosisMsgAck();
+                    ack.setLpAdd(lpAdd);
+                    break;
+                }
+                case 'osmosis/gamm/exit-pool': {
+                    // LP remove
+                    const lpRemove = new OsmosisMessages.OsmosisMsgLPRemove();
+                    lpRemove.setSender(m.value.sender);
+                    lpRemove.setPoolId(m.value.pool_id);
+                    lpRemove.setShareInAmount(m.value.share_in_amount);
+                    lpRemove.setDenomOutMinA(m.value.token_out_mins[0].denom);
+                    lpRemove.setAmountOutMinA(m.value.token_out_mins[0].amount);
+                    lpRemove.setDenomOutMinB(m.value.token_out_mins[1].denom);
+                    lpRemove.setAmountOutMinB(m.value.token_out_mins[1].amount);
+                    ack = new OsmosisMessages.OsmosisMsgAck();
+                    ack.setLpRemove(lpRemove);
+                    break;
+                }
+                case 'cosmos-sdk/MsgTransfer': {
+                    // IBC Transfer
+                    const ibcTransfer = new OsmosisMessages.OsmosisMsgIBCTransfer();
+                    ibcTransfer.setReceiver(m.value.receiver);
+                    ibcTransfer.setSender(m.value.sender);
+                    ibcTransfer.setSourceChannel(m.value.source_channel);
+                    ibcTransfer.setSourcePort(m.value.source_port);
+                    ibcTransfer.setRevisionHeight(m.value.timeout_height.revision_height);
+                    ibcTransfer.setRevisionNumber(m.value.timeout_height.revision_number);
+                    ibcTransfer.setAmount(m.value.token.amount);
+                    ibcTransfer.setDenom(m.value.token.denom);
+                    ack = new OsmosisMessages.OsmosisMsgAck();
+                    ack.setIbcTransfer(ibcTransfer);
+                    break;
+                }
+                case 'osmosis/gamm/swap-exact-amount-in': {
+                    // Swap
+                    const swap = new OsmosisMessages.OsmosisMsgSwap();
+                    swap.setSender(m.value.sender);
+                    swap.setPoolId(m.value.routes[0].pool_id);
+                    swap.setTokenOutDenom(m.value.routes[0].token_out_denom);
+                    swap.setTokenInDenom(m.value.token_in.denom);
+                    swap.setTokenInAmount(m.value.token_in.amount);
+                    swap.setTokenOutMinAmount(m.value.token_out_min_amount);
+                    ack = new OsmosisMessages.OsmosisMsgAck();
+                    ack.setSwap(swap);
+                    break;
+                }
+                default:
+                    throw new Error(`osmosis: Message ${m.type} is not yet supported`);
+            }
+            resp = await transport.call(Messages.MessageType.MESSAGETYPE_OSMOSISMSGACK, ack, {
+                msgTimeout: core.LONG_TIMEOUT,
+                omitLock: true,
+            });
+        }
+        if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_OSMOSISSIGNEDTX) {
+            throw new Error(`osmosis: unexpected response ${resp.message_type}`);
+        }
+        const signedTx = resp.proto;
+        const offlineSigner = {
+            async getAccounts() {
+                return [
+                    {
+                        address,
+                        algo: 'secp256k1',
+                        pubkey,
+                    },
+                ];
+            },
+            async signAmino(signerAddress, signDoc) {
+                if (signerAddress !== address)
+                    throw new Error('expected signerAddress to match address');
+                return {
+                    signed: signDoc,
+                    signature: {
+                        pub_key: {
+                            type: 'tendermint/PubKeySecp256k1',
+                            value: signedTx.getPublicKey_asB64(),
+                        },
+                        signature: signedTx.getSignature_asB64(),
+                    },
+                };
+            },
+        };
+        const signerData = {
+            sequence: Number(msg.sequence),
+            accountNumber: Number(msg.account_number),
+            chainId: msg.chain_id,
+        };
+        return (await protoTxBuilder).sign(address, (0, hdwallet_core_1.sortTxFields)(msg.tx), offlineSigner, signerData, 'osmo');
+    });
+}
+exports.osmosisSignTx = osmosisSignTx;

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/dist/{ripple.d.ts → cjs/ripple.d.ts}

@@ -1,6 +1,5 @@
-import * as core from "@shapeshiftoss/hdwallet-core";
-import { Transport } from "./transport";
-export declare function rippleGetAccountPaths(msg: core.RippleGetAccountPaths): Array<core.RippleAccountPath>;
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport';
+export declare function rippleGetAccountPaths(msg: core.RippleGetAccountPaths): core.RippleAccountPath[];
 export declare function rippleSignTx(transport: Transport, msg: core.RippleSignTx): Promise<core.RippleSignedTx>;
 export declare function rippleGetAddress(transport: Transport, msg: core.RippleGetAddress): Promise<string>;
-//# sourceMappingURL=ripple.d.ts.map

package/dist/cjs/ripple.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rippleGetAddress = exports.rippleSignTx = exports.rippleGetAccountPaths = void 0;
+const Messages = __importStar(require("@keepkey/device-protocol/lib/messages_pb"));
+const RippleMessages = __importStar(require("@keepkey/device-protocol/lib/messages-ripple_pb"));
+const core = __importStar(require("@shapeshiftoss/hdwallet-core"));
+const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
+function rippleGetAccountPaths(msg) {
+    return [
+        {
+            addressNList: [
+                0x80000000 + 44,
+                0x80000000 + core.slip44ByCoin('Ripple'),
+                0x80000000 + msg.accountIdx,
+                0,
+                0,
+            ],
+        },
+    ];
+}
+exports.rippleGetAccountPaths = rippleGetAccountPaths;
+async function rippleSignTx(transport, msg) {
+    return transport.lockDuring(async () => {
+        const signTx = new RippleMessages.RippleSignTx();
+        signTx.setAddressNList(msg.addressNList);
+        signTx.setFee(parseInt(msg.tx.value.fee.amount[0].amount));
+        signTx.setSequence(parseInt(msg.sequence));
+        signTx.setLastLedgerSequence(parseInt(msg.lastLedgerSequence));
+        const payment = new RippleMessages.RipplePayment();
+        payment.setAmount(parseInt(msg.payment.amount));
+        payment.setDestination(msg.payment.destination);
+        if (msg.payment.destinationTag !== undefined)
+            payment.setDestinationTag(parseInt(msg.payment.destinationTag));
+        signTx.setPayment(payment);
+        const resp = await transport.call(Messages.MessageType.MESSAGETYPE_RIPPLESIGNTX, signTx, {
+            msgTimeout: core.LONG_TIMEOUT,
+            omitLock: true,
+        });
+        for (const m of msg.tx.value.msg) {
+            if (m.type === 'ripple-sdk/MsgSend') {
+                if (m.value.amount.length !== 1) {
+                    throw new Error('ripple: Multiple amounts per msg not supported');
+                }
+                const denom = m.value.amount[0].denom;
+                if (denom !== 'drop') {
+                    throw new Error('ripple: Unsupported denomination: ' + denom);
+                }
+            }
+            else {
+                throw new Error(`ripple: Message ${m.type} is not yet supported`);
+            }
+        }
+        if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_RIPPLESIGNEDTX) {
+            throw new Error(`ripple: unexpected response ${resp.message_type}`);
+        }
+        const signedTx = resp.proto;
+        const signed = (0, cloneDeep_1.default)(msg.tx);
+        signed.value.signatures = [
+            {
+                serializedTx: signedTx.getSerializedTx_asB64(),
+                signature: signedTx.getSignature_asB64(),
+            },
+        ];
+        return signed;
+    });
+}
+exports.rippleSignTx = rippleSignTx;
+async function rippleGetAddress(transport, msg) {
+    const getAddr = new RippleMessages.RippleGetAddress();
+    getAddr.setAddressNList(msg.addressNList);
+    getAddr.setShowDisplay(msg.showDisplay !== false);
+    const response = await transport.call(Messages.MessageType.MESSAGETYPE_RIPPLEGETADDRESS, getAddr, {
+        msgTimeout: core.LONG_TIMEOUT,
+    });
+    const rippleAddress = response.proto;
+    return core.mustBeDefined(rippleAddress.getAddress());
+}
+exports.rippleGetAddress = rippleGetAddress;

package/dist/{thorchain.d.ts → cjs/thorchain.d.ts}

@@ -1,7 +1,6 @@
-import * as ThorchainMessages from "@keepkey/device-protocol/lib/messages-thorchain_pb";
-import * as core from "@shapeshiftoss/hdwallet-core";
-import { Transport } from "./transport";
-export declare function thorchainGetAccountPaths(msg: core.ThorchainGetAccountPaths): Array<core.ThorchainAccountPath>;
+import * as ThorchainMessages from '@keepkey/device-protocol/lib/messages-thorchain_pb';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport';
+export declare function thorchainGetAccountPaths(msg: core.ThorchainGetAccountPaths): core.ThorchainAccountPath[];
 export declare function thorchainGetAddress(transport: Transport, msg: ThorchainMessages.ThorchainGetAddress.AsObject): Promise<string>;
 export declare function thorchainSignTx(transport: Transport, msg: core.ThorchainSignTx): Promise<any>;
-//# sourceMappingURL=thorchain.d.ts.map