@shapeshiftoss/hdwallet-keepkey 1.62.41 → 1.62.42

package/dist/esm/mayachain.d.ts

@@ -0,0 +1,6 @@
+import * as MayachainMessages from '@keepkey/device-protocol/lib/messages-mayachain_pb';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport.js';
+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>;

package/dist/esm/mayachain.js

@@ -0,0 +1,137 @@
+import * as Messages from '@keepkey/device-protocol/lib/messages_pb';
+import * as MayachainMessages from '@keepkey/device-protocol/lib/messages-mayachain_pb';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import bs58check from 'bs58check';
+import PLazy from 'p-lazy';
+const protoTxBuilder = PLazy.from(() => import('@shapeshiftoss/proto-tx-builder'));
+export function mayachainGetAccountPaths(msg) {
+    return [
+        {
+            addressNList: [
+                0x80000000 + 44,
+                0x80000000 + core.slip44ByCoin('Mayachain'),
+                0x80000000 + msg.accountIdx,
+                0,
+                0,
+            ],
+        },
+    ];
+}
+export 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());
+}
+export 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.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');
+    });
+}

package/dist/esm/osmosis.d.ts

@@ -0,0 +1,6 @@
+import * as OsmosisMessages from '@keepkey/device-protocol/lib/messages-osmosis_pb';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport.js';
+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>;

package/dist/esm/osmosis.js

@@ -0,0 +1,238 @@
+import * as Messages from '@keepkey/device-protocol/lib/messages_pb';
+import * as OsmosisMessages from '@keepkey/device-protocol/lib/messages-osmosis_pb';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import { sortTxFields } from '@shapeshiftoss/hdwallet-core';
+import bs58check from 'bs58check';
+import PLazy from 'p-lazy';
+const protoTxBuilder = PLazy.from(() => import('@shapeshiftoss/proto-tx-builder'));
+export function osmosisGetAccountPaths(msg) {
+    return [
+        {
+            addressNList: [
+                0x80000000 + 44,
+                0x80000000 + core.slip44ByCoin('Osmo'),
+                0x80000000 + msg.accountIdx,
+                0,
+                0,
+            ],
+        },
+    ];
+}
+export 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());
+}
+export 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.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, sortTxFields(msg.tx), offlineSigner, signerData, 'osmo');
+    });
+}

package/dist/esm/ripple.d.ts

@@ -0,0 +1,5 @@
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport.js';
+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>;

package/dist/esm/ripple.js

@@ -0,0 +1,72 @@
+import * as Messages from '@keepkey/device-protocol/lib/messages_pb';
+import * as RippleMessages from '@keepkey/device-protocol/lib/messages-ripple_pb';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import cloneDeep from 'lodash/cloneDeep';
+export function rippleGetAccountPaths(msg) {
+    return [
+        {
+            addressNList: [
+                0x80000000 + 44,
+                0x80000000 + core.slip44ByCoin('Ripple'),
+                0x80000000 + msg.accountIdx,
+                0,
+                0,
+            ],
+        },
+    ];
+}
+export 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 = cloneDeep(msg.tx);
+        signed.value.signatures = [
+            {
+                serializedTx: signedTx.getSerializedTx_asB64(),
+                signature: signedTx.getSignature_asB64(),
+            },
+        ];
+        return signed;
+    });
+}
+export 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());
+}

package/dist/esm/thorchain.d.ts

@@ -0,0 +1,6 @@
+import * as ThorchainMessages from '@keepkey/device-protocol/lib/messages-thorchain_pb';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport.js';
+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>;

package/dist/esm/thorchain.js

@@ -0,0 +1,137 @@
+import * as Messages from '@keepkey/device-protocol/lib/messages_pb';
+import * as ThorchainMessages from '@keepkey/device-protocol/lib/messages-thorchain_pb';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import bs58check from 'bs58check';
+import PLazy from 'p-lazy';
+const protoTxBuilder = PLazy.from(() => import('@shapeshiftoss/proto-tx-builder'));
+export function thorchainGetAccountPaths(msg) {
+    return [
+        {
+            addressNList: [
+                0x80000000 + 44,
+                0x80000000 + core.slip44ByCoin('Thorchain'),
+                0x80000000 + msg.accountIdx,
+                0,
+                0,
+            ],
+        },
+    ];
+}
+export async function thorchainGetAddress(transport, msg) {
+    const getAddr = new ThorchainMessages.ThorchainGetAddress();
+    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_THORCHAINGETADDRESS, getAddr, {
+        msgTimeout: core.LONG_TIMEOUT,
+    });
+    const thorchainAddress = response.proto;
+    return core.mustBeDefined(thorchainAddress.getAddress());
+}
+export async function thorchainSignTx(transport, msg) {
+    const address = await thorchainGetAddress(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.decode(core.mustBeDefined(pubkeyMsg.getXpub())).slice(45);
+    return transport.lockDuring(async () => {
+        const signTx = new ThorchainMessages.ThorchainSignTx();
+        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_THORCHAINSIGNTX, signTx, {
+            msgTimeout: core.LONG_TIMEOUT,
+            omitLock: true,
+        });
+        for (const m of msg.tx.msg) {
+            if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_THORCHAINMSGREQUEST) {
+                throw new Error(`THORChain: unexpected response ${resp.message_type}`);
+            }
+            let ack;
+            if (m.type === 'thorchain/MsgSend') {
+                if (m.value.amount.length !== 1) {
+                    throw new Error('THORChain: Multiple amounts per MsgSend not supported');
+                }
+                const denom = m.value.amount[0].denom;
+                if (denom !== 'rune') {
+                    throw new Error('THORChain: Unsupported denomination: ' + denom);
+                }
+                const send = new ThorchainMessages.ThorchainMsgSend();
+                send.setFromAddress(m.value.from_address);
+                send.setToAddress(m.value.to_address);
+                send.setAmount(m.value.amount[0].amount);
+                ack = new ThorchainMessages.ThorchainMsgAck();
+                ack.setSend(send);
+            }
+            else if (m.type === 'thorchain/MsgDeposit') {
+                if (m.value.coins.length !== 1) {
+                    throw new Error('THORChain: Multiple amounts per MsgDeposit not supported');
+                }
+                const coinAsset = m.value.coins[0].asset;
+                if (!['THOR.RUNE', 'THOR.TCY', 'THOR.RUJI'].includes(coinAsset)) {
+                    throw new Error('THORChain: Unsupported coin asset: ' + coinAsset);
+                }
+                const deposit = new ThorchainMessages.ThorchainMsgDeposit();
+                deposit.setAsset(m.value.coins[0].asset);
+                deposit.setAmount(m.value.coins[0].amount);
+                deposit.setMemo(m.value.memo);
+                deposit.setSigner(m.value.signer);
+                ack = new ThorchainMessages.ThorchainMsgAck();
+                ack.setDeposit(deposit);
+            }
+            else {
+                throw new Error(`THORChain: Message ${m.type} is not yet supported`);
+            }
+            resp = await transport.call(Messages.MessageType.MESSAGETYPE_THORCHAINMSGACK, ack, {
+                msgTimeout: core.LONG_TIMEOUT,
+                omitLock: true,
+            });
+        }
+        if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_THORCHAINSIGNEDTX) {
+            throw new Error(`THORChain: 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, 'thor');
+    });
+}

package/dist/esm/transport.d.ts

@@ -0,0 +1,55 @@
+import * as core from '@shapeshiftoss/hdwallet-core';
+import * as jspb from 'google-protobuf';
+export interface TransportDelegate {
+    isOpened(): Promise<boolean>;
+    getDeviceID(): Promise<string>;
+    connect(): Promise<void>;
+    tryConnectDebugLink?(): Promise<boolean>;
+    disconnect(): Promise<void>;
+    writeChunk(buf: Uint8Array, debugLink?: boolean): Promise<void>;
+    readChunk(debugLink?: boolean): Promise<Uint8Array>;
+}
+export declare class Transport extends core.Transport {
+    debugLink: boolean;
+    userActionRequired: boolean;
+    delegate: TransportDelegate;
+    callInProgress: {
+        main?: Promise<any>;
+        debug?: Promise<any>;
+    };
+    constructor(keyring: core.Keyring, delegate: TransportDelegate);
+    static create(keyring: core.Keyring, delegate: TransportDelegate): Promise<Transport>;
+    isOpened(): Promise<boolean>;
+    getDeviceID(): Promise<string>;
+    connect(): Promise<void>;
+    tryConnectDebugLink(): Promise<boolean>;
+    disconnect(): Promise<void>;
+    private write;
+    private read;
+    getVendor(): string;
+    getEntropy(length: number): Uint8Array;
+    getFirmwareHash(firmware: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Utility function to cancel all pending calls whenver one of them is cancelled.
+     */
+    cancellable(inProgress?: Promise<any>): Promise<void>;
+    lockDuring<T>(action: () => Promise<T>): Promise<T>;
+    handleCancellableResponse(): Promise<core.Event>;
+    readResponse(debugLink: boolean): Promise<core.Event>;
+    call(msgTypeEnum: number, msg: jspb.Message, options?: {
+        msgTimeout?: number;
+        omitLock?: boolean;
+        noWait?: false;
+        debugLink?: boolean;
+    }): Promise<core.Event>;
+    call(msgTypeEnum: number, msg: jspb.Message, options: {
+        msgTimeout?: number;
+        omitLock?: boolean;
+        noWait: true;
+        debugLink?: boolean;
+    }): Promise<undefined>;
+    cancel(): Promise<void>;
+    protected toMessageBuffer(msgTypeEnum: number, msg: jspb.Message): Uint8Array;
+    protected fromMessageBuffer(buf: Uint8Array): [number, jspb.Message];
+    protected static failureMessageFactory(e?: Error | string): Uint8Array;
+}