@shapeshiftoss/hdwallet-keepkey 1.62.41 → 1.62.42

package/dist/cjs/adapter.js

@@ -0,0 +1,146 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Adapter = void 0;
+const core = __importStar(require("@shapeshiftoss/hdwallet-core"));
+const keepkey_1 = require("./keepkey");
+const transport_1 = require("./transport");
+class Adapter {
+    keyring;
+    delegate;
+    constructor(keyring, delegate) {
+        this.keyring = keyring;
+        this.delegate = delegate;
+        try {
+            this.delegate.registerCallbacks?.(this.handleConnect.bind(this), this.handleDisconnect.bind(this));
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    static fromDelegate(delegate) {
+        const fn = (keyring) => new Adapter(keyring, delegate);
+        const out = fn;
+        out.useKeyring = fn;
+        return out;
+    }
+    static async inspectDevice(delegate, device) {
+        const props = (await Promise.resolve(delegate.inspectDevice?.(device))) ??
+            (['object', 'function'].includes(typeof device) ? device : {});
+        if (!props.serialNumber && typeof device === 'string')
+            props.serialNumber = device;
+        return {
+            get productName() {
+                const out = props['productName'];
+                return typeof out === 'string' ? out : 'KeepKey';
+            },
+            get serialNumber() {
+                const out = props['serialNumber'];
+                if (typeof out !== 'string')
+                    throw new Error('could not get serialNumber from device');
+                return out;
+            },
+        };
+    }
+    async inspectDevice(device) {
+        return Adapter.inspectDevice(this.delegate, device);
+    }
+    async handleConnect(device) {
+        try {
+            await this.initialize([device]);
+            const { productName, serialNumber } = await this.inspectDevice(device);
+            await this.keyring.emit([productName, serialNumber, core.Events.CONNECT], serialNumber);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    }
+    async handleDisconnect(device) {
+        const { productName, serialNumber } = await this.inspectDevice(device);
+        try {
+            await this.keyring.remove(serialNumber);
+        }
+        catch {
+            // swallow keyring removal errors
+        }
+        await this.keyring.emit([productName, serialNumber, core.Events.DISCONNECT], serialNumber);
+    }
+    async initialize(devices, tryDebugLink, autoConnect) {
+        devices = devices ?? (await this.getDevices());
+        for (const device of devices) {
+            const { serialNumber } = await this.inspectDevice(device);
+            if (this.keyring.wallets[serialNumber])
+                await this.keyring.remove(serialNumber);
+            const delegate = await this.getTransportDelegate(device);
+            if (delegate === null)
+                continue;
+            const transport = await transport_1.Transport.create(this.keyring, delegate);
+            await transport.connect();
+            if (tryDebugLink)
+                await transport.tryConnectDebugLink();
+            const wallet = await keepkey_1.KeepKeyHDWallet.create(transport);
+            if (autoConnect)
+                await wallet.initialize();
+            this.keyring.add(wallet, serialNumber);
+        }
+        return Object.keys(this.keyring.wallets).length;
+    }
+    async getDevice(serialNumber) {
+        if (this.delegate.getDevice)
+            return await this.delegate.getDevice(serialNumber);
+        if (!serialNumber)
+            throw new Error('no default device specified');
+        const devices = await this.getDevices();
+        return (await Promise.all(devices.map(async (x) => (await this.inspectDevice(x)).serialNumber === serialNumber ? x : null))).filter(x => x !== null)[0];
+    }
+    async getDevices() {
+        if (this.delegate.getDevices)
+            return await this.delegate.getDevices();
+        let defaultDevice = undefined;
+        try {
+            defaultDevice = await this.getDevice();
+        }
+        catch {
+            // swallow default device fetch errors
+        }
+        return defaultDevice ? [defaultDevice] : [];
+    }
+    async getTransportDelegate(device) {
+        return await this.delegate.getTransportDelegate(device);
+    }
+    async pairDevice(serialNumber, tryDebugLink) {
+        const device = await this.getDevice(serialNumber);
+        if (!device)
+            throw new Error(serialNumber
+                ? `could not find device matching serial number '${serialNumber}'`
+                : 'could not find default device');
+        return this.pairRawDevice(device, tryDebugLink);
+    }
+    async pairRawDevice(device, tryDebugLink) {
+        await this.initialize([device], tryDebugLink, true);
+        return core.mustBeDefined(this.keyring.get((await this.inspectDevice(device)).serialNumber));
+    }
+}
+exports.Adapter = Adapter;

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

@@ -1,6 +1,5 @@
-import * as core from "@shapeshiftoss/hdwallet-core";
-import { Transport } from "./transport";
-export declare function binanceGetAccountPaths(msg: core.BinanceGetAccountPaths): Array<core.BinanceAccountPath>;
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport';
+export declare function binanceGetAccountPaths(msg: core.BinanceGetAccountPaths): core.BinanceAccountPath[];
 export declare function binanceSignTx(transport: Transport, msg: core.BinanceSignTx): Promise<core.BinanceSignedTx>;
 export declare function binanceGetAddress(transport: Transport, msg: core.BinanceGetAddress): Promise<string>;
-//# sourceMappingURL=binance.d.ts.map

package/dist/cjs/binance.js

@@ -0,0 +1,144 @@
+"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.binanceGetAddress = exports.binanceSignTx = exports.binanceGetAccountPaths = void 0;
+const Messages = __importStar(require("@keepkey/device-protocol/lib/messages_pb"));
+const BinanceMessages = __importStar(require("@keepkey/device-protocol/lib/messages-binance_pb"));
+const core = __importStar(require("@shapeshiftoss/hdwallet-core"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const crypto_js_1 = __importDefault(require("crypto-js"));
+const bnbencoding_1 = require("./bnbencoding");
+function binanceGetAccountPaths(msg) {
+    return [
+        {
+            addressNList: [
+                0x80000000 + 44,
+                0x80000000 + core.slip44ByCoin('Binance'),
+                0x80000000 + msg.accountIdx,
+                0,
+                0,
+            ],
+        },
+    ];
+}
+exports.binanceGetAccountPaths = binanceGetAccountPaths;
+async function binanceSignTx(transport, msg) {
+    return transport.lockDuring(async () => {
+        if (msg.testnet)
+            throw new Error('testnet not supported');
+        const partialTx = Object.assign({}, msg.tx);
+        if (!partialTx.data)
+            partialTx.data = null;
+        if (!partialTx.memo)
+            partialTx.memo = '';
+        if (!partialTx.sequence)
+            partialTx.sequence = '0';
+        if (!partialTx.source)
+            partialTx.source = '0';
+        if (!partialTx.account_number)
+            throw new Error('account_number is required');
+        if (!partialTx.chain_id)
+            throw new Error('chain_id is required');
+        const tx = partialTx;
+        if (tx.data)
+            throw new Error('tx data field not supported');
+        const signTx = new BinanceMessages.BinanceSignTx();
+        signTx.setAddressNList(msg.addressNList);
+        signTx.setAccountNumber(tx.account_number);
+        signTx.setChainId(tx.chain_id);
+        signTx.setSequence(tx.sequence);
+        if (tx.memo)
+            signTx.setMemo(tx.memo);
+        //verify not a batch tx
+        if (msg.tx.msgs.length > 1)
+            throw new Error('Binance batch sending not supported!');
+        const message = msg.tx.msgs[0];
+        //tell device not a batch tx
+        signTx.setMsgCount(1);
+        //tell device im about to send a tx to sign
+        let resp = await transport.call(Messages.MessageType.MESSAGETYPE_BINANCESIGNTX, signTx, {
+            msgTimeout: core.LONG_TIMEOUT,
+            omitLock: true,
+        });
+        const outputAmount = new bignumber_js_1.default(message.outputs[0].coins[0].amount);
+        const inputAmount = new bignumber_js_1.default(message.inputs[0].coins[0].amount);
+        if (!outputAmount.isInteger())
+            throw new Error('Output amount must be an integer');
+        if (!inputAmount.isInteger())
+            throw new Error('Input amount must be an integer');
+        const coinOut = new BinanceMessages.BinanceTransferMsg.BinanceCoin();
+        coinOut.setAmount(outputAmount.toString());
+        coinOut.setDenom(message.outputs[0].coins[0].denom);
+        const outputs = new BinanceMessages.BinanceTransferMsg.BinanceInputOutput();
+        outputs.setAddress(message.outputs[0].address);
+        outputs.setCoinsList([coinOut]);
+        const coinIn = new BinanceMessages.BinanceTransferMsg.BinanceCoin();
+        coinIn.setAmount(inputAmount.toString());
+        coinIn.setDenom(message.inputs[0].coins[0].denom);
+        const inputs = new BinanceMessages.BinanceTransferMsg.BinanceInputOutput();
+        inputs.setAddress(message.inputs[0].address);
+        inputs.setCoinsList([coinIn]);
+        const send = new BinanceMessages.BinanceTransferMsg();
+        send.addInputs(inputs);
+        send.addOutputs(outputs);
+        //sent tx to device
+        resp = await transport.call(Messages.MessageType.MESSAGETYPE_BINANCETRANSFERMSG, send, {
+            msgTimeout: core.LONG_TIMEOUT,
+            omitLock: true,
+        });
+        if (resp.message_enum !== Messages.MessageType.MESSAGETYPE_BINANCESIGNEDTX) {
+            throw new Error(`binance: unexpected response ${resp.message_type}`);
+        }
+        const signedTx = new BinanceMessages.BinanceSignedTx();
+        signedTx.setSignature(resp.message.signature);
+        signedTx.setPublicKey(resp.message.publicKey);
+        const serialized = (0, bnbencoding_1.encodeBnbTx)(tx, Buffer.from(signedTx.getPublicKey_asU8()), Buffer.from(signedTx.getSignature_asU8())).toString('hex');
+        const out = {
+            ...tx,
+            signatures: {
+                pub_key: signedTx.getPublicKey_asB64(),
+                signature: signedTx.getSignature_asB64(),
+            },
+            serialized,
+            txid: crypto_js_1.default.SHA256(crypto_js_1.default.enc.Hex.parse(serialized)).toString(),
+        };
+        return out;
+    });
+}
+exports.binanceSignTx = binanceSignTx;
+async function binanceGetAddress(transport, msg) {
+    const getAddr = new BinanceMessages.BinanceGetAddress();
+    getAddr.setAddressNList(msg.addressNList);
+    getAddr.setShowDisplay(msg.showDisplay !== false);
+    const response = await transport.call(Messages.MessageType.MESSAGETYPE_BINANCEGETADDRESS, getAddr, {
+        msgTimeout: core.LONG_TIMEOUT,
+    });
+    const binanceAddress = response.proto;
+    return core.mustBeDefined(binanceAddress.getAddress());
+}
+exports.binanceGetAddress = binanceGetAddress;

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

@@ -1,5 +1,5 @@
-import * as core from "@shapeshiftoss/hdwallet-core";
-import { Transport } from "./transport";
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport';
 export declare function btcSupportsCoin(coin: core.Coin): Promise<boolean>;
 export declare function btcSupportsScriptType(coin: core.Coin, scriptType?: core.BTCInputScriptType): Promise<boolean>;
 export declare function btcGetAddress(wallet: core.BTCWallet, transport: Transport, msg: core.BTCGetAddress): Promise<string>;
@@ -8,5 +8,4 @@ export declare function btcSupportsSecureTransfer(): Promise<boolean>;
 export declare function btcSupportsNativeShapeShift(): boolean;
 export declare function btcSignMessage(wallet: core.BTCWallet, transport: Transport, msg: core.BTCSignMessage): Promise<core.BTCSignedMessage>;
 export declare function btcVerifyMessage(wallet: core.BTCWallet, transport: Transport, msg: core.BTCVerifyMessage): Promise<boolean>;
-export declare function btcGetAccountPaths(msg: core.BTCGetAccountPaths): Array<core.BTCAccountPath>;
-//# sourceMappingURL=bitcoin.d.ts.map
+export declare function btcGetAccountPaths(msg: core.BTCGetAccountPaths): core.BTCAccountPath[];