@shapeshiftoss/hdwallet-keepkey 1.62.41 → 1.62.42

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

@@ -1,7 +1,6 @@
-import * as CosmosMessages from "@keepkey/device-protocol/lib/messages-cosmos_pb";
-import * as core from "@shapeshiftoss/hdwallet-core";
-import { Transport } from "./transport";
-export declare function cosmosGetAccountPaths(msg: core.CosmosGetAccountPaths): Array<core.CosmosAccountPath>;
+import * as CosmosMessages from '@keepkey/device-protocol/lib/messages-cosmos_pb';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport';
+export declare function cosmosGetAccountPaths(msg: core.CosmosGetAccountPaths): core.CosmosAccountPath[];
 export declare function cosmosGetAddress(transport: Transport, msg: CosmosMessages.CosmosGetAddress.AsObject): Promise<string>;
 export declare function cosmosSignTx(transport: Transport, msg: core.CosmosSignTx): Promise<any>;
-//# sourceMappingURL=cosmos.d.ts.map

package/dist/cjs/cosmos.js

@@ -0,0 +1,219 @@
+"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.cosmosSignTx = exports.cosmosGetAddress = exports.cosmosGetAccountPaths = void 0;
+const Messages = __importStar(require("@keepkey/device-protocol/lib/messages_pb"));
+const CosmosMessages = __importStar(require("@keepkey/device-protocol/lib/messages-cosmos_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 cosmosGetAccountPaths(msg) {
+    return [
+        {
+            addressNList: [
+                0x80000000 + 44,
+                0x80000000 + core.slip44ByCoin('Atom'),
+                0x80000000 + msg.accountIdx,
+                0,
+                0,
+            ],
+        },
+    ];
+}
+exports.cosmosGetAccountPaths = cosmosGetAccountPaths;
+async function cosmosGetAddress(transport, msg) {
+    const getAddr = new CosmosMessages.CosmosGetAddress();
+    getAddr.setAddressNList(msg.addressNList);
+    getAddr.setShowDisplay(msg.showDisplay !== false);
+    const response = await transport.call(Messages.MessageType.MESSAGETYPE_COSMOSGETADDRESS, getAddr, {
+        msgTimeout: core.LONG_TIMEOUT,
+    });
+    const cosmosAddress = response.proto;
+    return core.mustBeDefined(cosmosAddress.getAddress());
+}
+exports.cosmosGetAddress = cosmosGetAddress;
+async function cosmosSignTx(transport, msg) {
+    const address = await cosmosGetAddress(transport, { addressNList: msg.addressNList });
+    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 CosmosMessages.CosmosSignTx();
+        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_COSMOSSIGNTX, signTx, {
+            msgTimeout: core.LONG_TIMEOUT,
+            omitLock: true,
+        });
+        for (const m of msg.tx.msg) {
+            if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_COSMOSMSGREQUEST) {
+                throw new Error(`cosmos: unexpected response ${resp.message_type}`);
+            }
+            let ack;
+            if (m.type === 'cosmos-sdk/MsgSend') {
+                if (m.value.amount.length !== 1) {
+                    throw new Error('cosmos: Multiple amounts per msg not supported');
+                }
+                const denom = m.value.amount[0].denom;
+                if (denom !== 'uatom') {
+                    throw new Error('cosmos: Unsupported denomination: ' + denom);
+                }
+                const send = new CosmosMessages.CosmosMsgSend();
+                send.setFromAddress(m.value.from_address);
+                send.setToAddress(m.value.to_address);
+                send.setAmount(m.value.amount[0].amount);
+                ack = new CosmosMessages.CosmosMsgAck();
+                ack.setSend(send);
+            }
+            else if (m.type === 'cosmos-sdk/MsgDelegate') {
+                const denom = m.value.amount.denom;
+                if (denom !== 'uatom') {
+                    throw new Error('cosmos: Unsupported denomination: ' + denom);
+                }
+                const delegate = new CosmosMessages.CosmosMsgDelegate();
+                delegate.setDelegatorAddress(m.value.delegator_address);
+                delegate.setValidatorAddress(m.value.validator_address);
+                delegate.setAmount(m.value.amount.amount);
+                ack = new CosmosMessages.CosmosMsgAck();
+                ack.setDelegate(delegate);
+            }
+            else if (m.type === 'cosmos-sdk/MsgUndelegate') {
+                const denom = m.value.amount.denom;
+                if (denom !== 'uatom') {
+                    throw new Error('cosmos: Unsupported denomination: ' + denom);
+                }
+                const undelegate = new CosmosMessages.CosmosMsgUndelegate();
+                undelegate.setDelegatorAddress(m.value.delegator_address);
+                undelegate.setValidatorAddress(m.value.validator_address);
+                undelegate.setAmount(m.value.amount.amount);
+                ack = new CosmosMessages.CosmosMsgAck();
+                ack.setUndelegate(undelegate);
+            }
+            else if (m.type === 'cosmos-sdk/MsgBeginRedelegate') {
+                const denom = m.value.amount.denom;
+                if (denom !== 'uatom') {
+                    throw new Error('cosmos: Unsupported denomination: ' + denom);
+                }
+                const redelegate = new CosmosMessages.CosmosMsgRedelegate();
+                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);
+                ack = new CosmosMessages.CosmosMsgAck();
+                ack.setRedelegate(redelegate);
+            }
+            else if (m.type === 'cosmos-sdk/MsgWithdrawDelegationReward') {
+                const rewards = new CosmosMessages.CosmosMsgRewards();
+                rewards.setDelegatorAddress(m.value.delegator_address);
+                rewards.setValidatorAddress(m.value.validator_address);
+                if (m.value.amount) {
+                    const denom = m.value.amount.denom;
+                    if (denom !== 'uatom') {
+                        throw new Error('cosmos: Unsupported denomination: ' + denom);
+                    }
+                    rewards.setAmount(m.value.amount.amount);
+                }
+                ack = new CosmosMessages.CosmosMsgAck();
+                ack.setRewards(rewards);
+            }
+            else if (m.type === 'cosmos-sdk/MsgTransfer') {
+                const denom = m.value.token.denom;
+                if (denom !== 'uatom') {
+                    throw new Error('cosmos: Unsupported denomination: ' + denom);
+                }
+                const ibcTransfer = new CosmosMessages.CosmosMsgIBCTransfer();
+                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 CosmosMessages.CosmosMsgAck();
+                ack.setIbcTransfer(ibcTransfer);
+            }
+            else {
+                throw new Error(`cosmos: Message ${m.type} is not yet supported`);
+            }
+            resp = await transport.call(Messages.MessageType.MESSAGETYPE_COSMOSMSGACK, ack, {
+                msgTimeout: core.LONG_TIMEOUT,
+                omitLock: true,
+            });
+        }
+        if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_COSMOSSIGNEDTX) {
+            throw new Error(`cosmos: 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, 'cosmos');
+    });
+}
+exports.cosmosSignTx = cosmosSignTx;

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

@@ -1,6 +1,5 @@
-import * as core from "@shapeshiftoss/hdwallet-core";
-import { Transport } from "./transport";
-export declare function eosGetAccountPaths(msg: core.EosGetAccountPaths): Array<core.EosAccountPath>;
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport';
+export declare function eosGetAccountPaths(msg: core.EosGetAccountPaths): core.EosAccountPath[];
 export declare function eosGetPublicKey(transport: Transport, msg: core.EosGetPublicKey): Promise<string>;
 export declare function eosSignTx(transport: Transport, msg: core.EosToSignTx): Promise<core.EosTxSigned>;
-//# sourceMappingURL=eos.d.ts.map

package/dist/cjs/eos.js

@@ -0,0 +1,244 @@
+"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.eosSignTx = exports.eosGetPublicKey = exports.eosGetAccountPaths = void 0;
+const Messages = __importStar(require("@keepkey/device-protocol/lib/messages_pb"));
+const EosMessages = __importStar(require("@keepkey/device-protocol/lib/messages-eos_pb"));
+const core = __importStar(require("@shapeshiftoss/hdwallet-core"));
+const bs58_1 = __importDefault(require("bs58"));
+const create_hash_1 = __importDefault(require("create-hash"));
+const long_1 = __importDefault(require("long"));
+function eosSigFormatter(r, s, _v) {
+    const recoverId = 0x1f;
+    let signature = 'SIG_K1_';
+    console.debug('formatter logs');
+    const keyBuffer = Buffer.alloc(65);
+    const rbuf = Buffer.from(r);
+    const sbuf = Buffer.from(s);
+    keyBuffer.writeUInt8(recoverId, 0);
+    rbuf.copy(keyBuffer, 1);
+    sbuf.copy(keyBuffer, 33);
+    console.debug(keyBuffer);
+    const check = [keyBuffer];
+    const keyType = 'K1'; // we only sign using K1 curve
+    check.push(Buffer.from(keyType));
+    console.debug(check);
+    console.debug('hash');
+    console.debug((0, create_hash_1.default)('ripemd160').update(core.compatibleBufferConcat(check)).digest());
+    const chksum = (0, create_hash_1.default)('ripemd160')
+        .update(core.compatibleBufferConcat(check))
+        .digest()
+        .slice(0, 4);
+    console.debug(chksum);
+    signature = signature.concat(bs58_1.default.encode(core.compatibleBufferConcat([keyBuffer, chksum])));
+    console.debug(signature);
+    return signature;
+}
+function charToSymbol(c) {
+    if (c.charCodeAt(0) >= 'a'.charCodeAt(0) && c.charCodeAt(0) <= 'z'.charCodeAt(0)) {
+        return c.charCodeAt(0) - 'a'.charCodeAt(0) + 6;
+    }
+    if (c.charCodeAt(0) >= '1'.charCodeAt(0) && c.charCodeAt(0) <= '5'.charCodeAt(0)) {
+        return c.charCodeAt(0) - '1'.charCodeAt(0) + 1;
+    }
+    return 0;
+}
+function nameToNumber(name) {
+    let value = new long_1.default(0, 0, true);
+    let c = new long_1.default(0, 0, true);
+    for (let i = 0; i < 13; i++) {
+        if (i < name.length && i < 13) {
+            c = long_1.default.fromNumber(charToSymbol(name[i]), true);
+        }
+        if (i < 12) {
+            c = c.and(long_1.default.fromString('1f', true, 16));
+            c = c.shl(64 - 5 * (i + 1));
+        }
+        else {
+            // last iteration
+            c = c.and(long_1.default.fromString('0f', true, 16));
+        }
+        value = value.or(c);
+    }
+    return value.toString();
+}
+function symbolFromString(p, name) {
+    let result = 0;
+    for (let i = 0; i < name.length; i++) {
+        result |= name.charCodeAt(i) << (8 * (i + 1));
+    }
+    result |= p;
+    return result;
+}
+function assetToNumber(asset) {
+    const assetSplit = asset.split(' '); // amount, symbol
+    const amountStr = assetSplit[0] ?? '';
+    const symbolStr = assetSplit[1] ?? '';
+    const dot_pos = amountStr.indexOf('.');
+    let fract_part = 0;
+    let int_part = 0;
+    let precision_digit = 0;
+    // parse symbol
+    if (dot_pos != -1) {
+        precision_digit = amountStr.length - dot_pos - 1;
+    }
+    else {
+        precision_digit = 0;
+    }
+    const sym = symbolFromString(precision_digit, symbolStr);
+    //parse amount
+    if (dot_pos != -1) {
+        int_part = parseInt(amountStr.slice(0, dot_pos));
+        fract_part = parseInt(amountStr.slice(dot_pos + 1));
+        if (int_part < 0) {
+            fract_part *= -1;
+        }
+    }
+    else {
+        int_part = parseInt(amountStr);
+    }
+    let amount = int_part;
+    amount *= Math.pow(10, sym & 0xff);
+    amount += fract_part;
+    return [amount, sym];
+}
+function eosGetAccountPaths(msg) {
+    return [
+        {
+            addressNList: [
+                0x80000000 + 44,
+                0x80000000 + core.slip44ByCoin('Eos'),
+                0x80000000 + msg.accountIdx,
+                0,
+                0,
+            ],
+        },
+    ];
+}
+exports.eosGetAccountPaths = eosGetAccountPaths;
+async function eosGetPublicKey(transport, msg) {
+    const getPubkey = new EosMessages.EosGetPublicKey();
+    getPubkey.setAddressNList(msg.addressNList);
+    getPubkey.setShowDisplay(msg.showDisplay !== false);
+    getPubkey.setKind(msg.kind);
+    const response = await transport.call(Messages.MessageType.MESSAGETYPE_EOSGETPUBLICKEY, getPubkey, {
+        msgTimeout: core.LONG_TIMEOUT,
+    });
+    const eosPubkey = response.proto;
+    return core.mustBeDefined(eosPubkey.getWifPublicKey());
+}
+exports.eosGetPublicKey = eosGetPublicKey;
+async function eosSignTx(transport, msg) {
+    return transport.lockDuring(async () => {
+        let resp;
+        // check some params
+        if (msg.tx.actions.length > 1) {
+            throw new Error(`Too many actions in Eos transaction: Keepkey only supports one!`);
+        }
+        const signTx = new EosMessages.EosSignTx();
+        signTx.setAddressNList(msg.addressNList);
+        signTx.setChainId(core.fromHexString(msg.chain_id));
+        const txHeader = new EosMessages.EosTxHeader();
+        txHeader.setExpiration((Date.parse(msg.tx.expiration) -
+            Date.parse('01 Jan 1970 00:00:00Z') -
+            new Date().getTimezoneOffset() * 60 * 1000) /
+            1000);
+        txHeader.setRefBlockNum(msg.tx.ref_block_num);
+        txHeader.setRefBlockPrefix(msg.tx.ref_block_prefix);
+        txHeader.setMaxNetUsageWords(msg.tx.max_net_usage_words);
+        txHeader.setMaxCpuUsageMs(msg.tx.max_cpu_usage_ms);
+        txHeader.setDelaySec(msg.tx.delay_sec);
+        signTx.setHeader(txHeader);
+        signTx.setNumActions(msg.tx.actions.length);
+        console.debug('tx header');
+        console.debug(txHeader);
+        resp = await transport.call(Messages.MessageType.MESSAGETYPE_EOSSIGNTX, signTx, {
+            msgTimeout: core.LONG_TIMEOUT,
+            omitLock: true,
+        });
+        if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_EOSTXACTIONREQUEST) {
+            throw new Error(`eos: unexpected response ${resp.message_type}`);
+        }
+        // parse the common block of the action
+        const actCommon = new EosMessages.EosActionCommon();
+        actCommon.setAccount(nameToNumber(msg.tx.actions[0].account).toString());
+        actCommon.setName(nameToNumber(msg.tx.actions[0].name).toString());
+        // interate through authorizations and add them
+        for (let n = 0; n < msg.tx.actions[0].authorization.length; n++) {
+            const actPerm = new EosMessages.EosPermissionLevel();
+            actPerm.setActor(nameToNumber(msg.tx.actions[0].authorization[n].actor).toString());
+            actPerm.setPermission(nameToNumber(msg.tx.actions[0].authorization[n].permission).toString());
+            actCommon.addAuthorization(actPerm);
+        }
+        const actAck = new EosMessages.EosTxActionAck();
+        actAck.setCommon(actCommon);
+        // parse the various action types here.
+        switch (msg.tx.actions[0].name) {
+            case 'transfer': {
+                // build the transfer action
+                const actType = new EosMessages.EosActionTransfer();
+                actType.setSender(nameToNumber(msg.tx.actions[0].data.from).toString());
+                actType.setReceiver(nameToNumber(msg.tx.actions[0].data.to).toString());
+                const actAsset = new EosMessages.EosAsset();
+                const assetParse = assetToNumber(msg.tx.actions[0].data.quantity);
+                actAsset.setAmount(assetParse[0].toString());
+                actAsset.setSymbol(assetParse[1].toString());
+                actType.setQuantity(actAsset);
+                actType.setMemo(msg.tx.actions[0].data.memo);
+                actAck.setTransfer(actType);
+                break;
+            }
+        }
+        console.debug('action data');
+        console.debug(actAck);
+        resp = await transport.call(Messages.MessageType.MESSAGETYPE_EOSTXACTIONACK, actAck, {
+            msgTimeout: core.LONG_TIMEOUT,
+            omitLock: true,
+        });
+        if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_EOSSIGNEDTX) {
+            throw new Error(`eos: unexpected response ${resp.message_type}`);
+        }
+        const signedTx = resp.proto;
+        // format signature for use in the eos system
+        //    const EosFormatSig = eosSigFormatter(signedTx.getSignatureR() as Uint8Array, signedTx.getSignatureS() as Uint8Array, signedTx.getSignatureV())
+        const signatureR = signedTx.getSignatureR_asU8();
+        const signatureS = signedTx.getSignatureS_asU8();
+        const signatureV = signedTx.getSignatureV();
+        if (signatureV === undefined)
+            throw new Error('missing signatureV');
+        const sig = {
+            signatureV,
+            signatureR,
+            signatureS,
+            hash: signedTx.getHash(),
+            eosFormSig: eosSigFormatter(signatureR, signatureS, signatureV),
+        };
+        return sig;
+    });
+}
+exports.eosSignTx = eosSignTx;

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

@@ -1,9 +1,9 @@
-import * as core from "@shapeshiftoss/hdwallet-core";
-import { Transport } from "./transport";
-export declare function ethSupportsNetwork(chainId: number): Promise<boolean>;
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport';
+export declare function ethSupportsNetwork(_chainId: number): Promise<boolean>;
 export declare function ethSupportsSecureTransfer(): Promise<boolean>;
 export declare function ethSupportsNativeShapeShift(): boolean;
-export declare function ethGetAccountPaths(msg: core.ETHGetAccountPath): Array<core.ETHAccountPath>;
+export declare function ethGetAccountPaths(msg: core.ETHGetAccountPath): core.ETHAccountPath[];
 export declare function ethSignTx(transport: Transport, msg: core.ETHSignTx): Promise<core.ETHSignedTx>;
 export declare function ethGetAddress(transport: Transport, msg: core.ETHGetAddress): Promise<core.Address>;
 export declare function ethSignMessage(transport: Transport, msg: core.ETHSignMessage): Promise<core.ETHSignedMessage>;
@@ -15,4 +15,3 @@ export declare function ethSignMessage(transport: Transport, msg: core.ETHSignMe
  */
 export declare function ethSignTypedData(transport: Transport, msg: core.ETHSignTypedData): Promise<core.ETHSignedTypedData>;
 export declare function ethVerifyMessage(transport: Transport, msg: core.ETHVerifyMessage): Promise<boolean>;
-//# sourceMappingURL=ethereum.d.ts.map