@shapeshiftoss/hdwallet-keepkey 1.62.41 → 1.62.42

package/dist/esm/adapter.js

@@ -0,0 +1,119 @@
+import * as core from '@shapeshiftoss/hdwallet-core';
+import { KeepKeyHDWallet } from './keepkey.js';
+import { Transport } from './transport.js';
+export 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.create(this.keyring, delegate);
+            await transport.connect();
+            if (tryDebugLink)
+                await transport.tryConnectDebugLink();
+            const wallet = await 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));
+    }
+}

package/dist/esm/binance.d.ts

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

package/dist/esm/binance.js

@@ -0,0 +1,112 @@
+import * as Messages from '@keepkey/device-protocol/lib/messages_pb';
+import * as BinanceMessages from '@keepkey/device-protocol/lib/messages-binance_pb';
+import * as core from '@shapeshiftoss/hdwallet-core';
+import BigNumber from 'bignumber.js';
+import CryptoJS from 'crypto-js';
+import { encodeBnbTx } from './bnbencoding.js';
+export function binanceGetAccountPaths(msg) {
+    return [
+        {
+            addressNList: [
+                0x80000000 + 44,
+                0x80000000 + core.slip44ByCoin('Binance'),
+                0x80000000 + msg.accountIdx,
+                0,
+                0,
+            ],
+        },
+    ];
+}
+export 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(message.outputs[0].coins[0].amount);
+        const inputAmount = new BigNumber(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 = 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: CryptoJS.SHA256(CryptoJS.enc.Hex.parse(serialized)).toString(),
+        };
+        return out;
+    });
+}
+export 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());
+}

package/dist/esm/bitcoin.d.ts

@@ -0,0 +1,11 @@
+import * as core from '@shapeshiftoss/hdwallet-core';
+import type { Transport } from './transport.js';
+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>;
+export declare function btcSignTx(wallet: core.BTCWallet, transport: Transport, msgIn: core.BTCSignTxKK): Promise<core.BTCSignedTx>;
+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): core.BTCAccountPath[];