@trezor/connect 9.0.0-beta.1

package/lib/api/index.js

@@ -0,0 +1,134 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requestLogin = exports.recoveryDevice = exports.rebootToBootloader = exports.pushTransaction = exports.nemSignTransaction = exports.nemGetAddress = exports.getSettings = exports.getPublicKey = exports.getOwnershipProof = exports.getOwnershipId = exports.getFeatures = exports.getDeviceState = exports.getCoinInfo = exports.getAddress = exports.getAccountInfo = exports.firmwareUpdate = exports.ethereumVerifyMessage = exports.ethereumSignTypedData = exports.ethereumSignTransaction = exports.ethereumSignMessage = exports.ethereumGetPublicKey = exports.ethereumGetAddress = exports.eosSignTransaction = exports.eosGetPublicKey = exports.customMessage = exports.composeTransaction = exports.cipherKeyValue = exports.changePin = exports.cardanoSignTransaction = exports.cardanoGetPublicKey = exports.cardanoGetNativeScriptHash = exports.cardanoGetAddress = exports.blockchainUnsubscribeFiatRates = exports.blockchainUnsubscribe = exports.blockchainSubscribeFiatRates = exports.blockchainSubscribe = exports.blockchainSetCustomBackend = exports.blockchainGetTransactions = exports.blockchainGetFiatRatesForTimestamps = exports.blockchainGetCurrentFiatRates = exports.blockchainGetAccountBalanceHistory = exports.blockchainEstimateFee = exports.blockchainDisconnect = exports.binanceSignTransaction = exports.binanceGetPublicKey = exports.binanceGetAddress = exports.backupDevice = exports.authorizeCoinJoin = exports.applySettings = exports.applyFlags = void 0;
+exports.wipeDevice = exports.verifyMessage = exports.tezosSignTransaction = exports.tezosGetPublicKey = exports.tezosGetAddress = exports.stellarSignTransaction = exports.stellarGetAddress = exports.signTransaction = exports.signMessage = exports.setProxy = exports.rippleSignTransaction = exports.rippleGetAddress = exports.resetDevice = void 0;
+var applyFlags_1 = require("./applyFlags");
+Object.defineProperty(exports, "applyFlags", { enumerable: true, get: function () { return __importDefault(applyFlags_1).default; } });
+var applySettings_1 = require("./applySettings");
+Object.defineProperty(exports, "applySettings", { enumerable: true, get: function () { return __importDefault(applySettings_1).default; } });
+var authorizeCoinJoin_1 = require("./authorizeCoinJoin");
+Object.defineProperty(exports, "authorizeCoinJoin", { enumerable: true, get: function () { return __importDefault(authorizeCoinJoin_1).default; } });
+var backupDevice_1 = require("./backupDevice");
+Object.defineProperty(exports, "backupDevice", { enumerable: true, get: function () { return __importDefault(backupDevice_1).default; } });
+var binanceGetAddress_1 = require("./binanceGetAddress");
+Object.defineProperty(exports, "binanceGetAddress", { enumerable: true, get: function () { return __importDefault(binanceGetAddress_1).default; } });
+var binanceGetPublicKey_1 = require("./binanceGetPublicKey");
+Object.defineProperty(exports, "binanceGetPublicKey", { enumerable: true, get: function () { return __importDefault(binanceGetPublicKey_1).default; } });
+var binanceSignTransaction_1 = require("./binanceSignTransaction");
+Object.defineProperty(exports, "binanceSignTransaction", { enumerable: true, get: function () { return __importDefault(binanceSignTransaction_1).default; } });
+var blockchainDisconnect_1 = require("./blockchainDisconnect");
+Object.defineProperty(exports, "blockchainDisconnect", { enumerable: true, get: function () { return __importDefault(blockchainDisconnect_1).default; } });
+var blockchainEstimateFee_1 = require("./blockchainEstimateFee");
+Object.defineProperty(exports, "blockchainEstimateFee", { enumerable: true, get: function () { return __importDefault(blockchainEstimateFee_1).default; } });
+var blockchainGetAccountBalanceHistory_1 = require("./blockchainGetAccountBalanceHistory");
+Object.defineProperty(exports, "blockchainGetAccountBalanceHistory", { enumerable: true, get: function () { return __importDefault(blockchainGetAccountBalanceHistory_1).default; } });
+var blockchainGetCurrentFiatRates_1 = require("./blockchainGetCurrentFiatRates");
+Object.defineProperty(exports, "blockchainGetCurrentFiatRates", { enumerable: true, get: function () { return __importDefault(blockchainGetCurrentFiatRates_1).default; } });
+var blockchainGetFiatRatesForTimestamps_1 = require("./blockchainGetFiatRatesForTimestamps");
+Object.defineProperty(exports, "blockchainGetFiatRatesForTimestamps", { enumerable: true, get: function () { return __importDefault(blockchainGetFiatRatesForTimestamps_1).default; } });
+var blockchainGetTransactions_1 = require("./blockchainGetTransactions");
+Object.defineProperty(exports, "blockchainGetTransactions", { enumerable: true, get: function () { return __importDefault(blockchainGetTransactions_1).default; } });
+var blockchainSetCustomBackend_1 = require("./blockchainSetCustomBackend");
+Object.defineProperty(exports, "blockchainSetCustomBackend", { enumerable: true, get: function () { return __importDefault(blockchainSetCustomBackend_1).default; } });
+var blockchainSubscribe_1 = require("./blockchainSubscribe");
+Object.defineProperty(exports, "blockchainSubscribe", { enumerable: true, get: function () { return __importDefault(blockchainSubscribe_1).default; } });
+var blockchainSubscribeFiatRates_1 = require("./blockchainSubscribeFiatRates");
+Object.defineProperty(exports, "blockchainSubscribeFiatRates", { enumerable: true, get: function () { return __importDefault(blockchainSubscribeFiatRates_1).default; } });
+var blockchainUnsubscribe_1 = require("./blockchainUnsubscribe");
+Object.defineProperty(exports, "blockchainUnsubscribe", { enumerable: true, get: function () { return __importDefault(blockchainUnsubscribe_1).default; } });
+var blockchainUnsubscribeFiatRates_1 = require("./blockchainUnsubscribeFiatRates");
+Object.defineProperty(exports, "blockchainUnsubscribeFiatRates", { enumerable: true, get: function () { return __importDefault(blockchainUnsubscribeFiatRates_1).default; } });
+var cardanoGetAddress_1 = require("./cardanoGetAddress");
+Object.defineProperty(exports, "cardanoGetAddress", { enumerable: true, get: function () { return __importDefault(cardanoGetAddress_1).default; } });
+var cardanoGetNativeScriptHash_1 = require("./cardanoGetNativeScriptHash");
+Object.defineProperty(exports, "cardanoGetNativeScriptHash", { enumerable: true, get: function () { return __importDefault(cardanoGetNativeScriptHash_1).default; } });
+var cardanoGetPublicKey_1 = require("./cardanoGetPublicKey");
+Object.defineProperty(exports, "cardanoGetPublicKey", { enumerable: true, get: function () { return __importDefault(cardanoGetPublicKey_1).default; } });
+var cardanoSignTransaction_1 = require("./cardanoSignTransaction");
+Object.defineProperty(exports, "cardanoSignTransaction", { enumerable: true, get: function () { return __importDefault(cardanoSignTransaction_1).default; } });
+var changePin_1 = require("./changePin");
+Object.defineProperty(exports, "changePin", { enumerable: true, get: function () { return __importDefault(changePin_1).default; } });
+var cipherKeyValue_1 = require("./cipherKeyValue");
+Object.defineProperty(exports, "cipherKeyValue", { enumerable: true, get: function () { return __importDefault(cipherKeyValue_1).default; } });
+var composeTransaction_1 = require("./composeTransaction");
+Object.defineProperty(exports, "composeTransaction", { enumerable: true, get: function () { return __importDefault(composeTransaction_1).default; } });
+var customMessage_1 = require("./customMessage");
+Object.defineProperty(exports, "customMessage", { enumerable: true, get: function () { return __importDefault(customMessage_1).default; } });
+var eosGetPublicKey_1 = require("./eosGetPublicKey");
+Object.defineProperty(exports, "eosGetPublicKey", { enumerable: true, get: function () { return __importDefault(eosGetPublicKey_1).default; } });
+var eosSignTransaction_1 = require("./eosSignTransaction");
+Object.defineProperty(exports, "eosSignTransaction", { enumerable: true, get: function () { return __importDefault(eosSignTransaction_1).default; } });
+var ethereumGetAddress_1 = require("./ethereumGetAddress");
+Object.defineProperty(exports, "ethereumGetAddress", { enumerable: true, get: function () { return __importDefault(ethereumGetAddress_1).default; } });
+var ethereumGetPublicKey_1 = require("./ethereumGetPublicKey");
+Object.defineProperty(exports, "ethereumGetPublicKey", { enumerable: true, get: function () { return __importDefault(ethereumGetPublicKey_1).default; } });
+var ethereumSignMessage_1 = require("./ethereumSignMessage");
+Object.defineProperty(exports, "ethereumSignMessage", { enumerable: true, get: function () { return __importDefault(ethereumSignMessage_1).default; } });
+var ethereumSignTransaction_1 = require("./ethereumSignTransaction");
+Object.defineProperty(exports, "ethereumSignTransaction", { enumerable: true, get: function () { return __importDefault(ethereumSignTransaction_1).default; } });
+var ethereumSignTypedData_1 = require("./ethereumSignTypedData");
+Object.defineProperty(exports, "ethereumSignTypedData", { enumerable: true, get: function () { return __importDefault(ethereumSignTypedData_1).default; } });
+var ethereumVerifyMessage_1 = require("./ethereumVerifyMessage");
+Object.defineProperty(exports, "ethereumVerifyMessage", { enumerable: true, get: function () { return __importDefault(ethereumVerifyMessage_1).default; } });
+var firmwareUpdate_1 = require("./firmwareUpdate");
+Object.defineProperty(exports, "firmwareUpdate", { enumerable: true, get: function () { return __importDefault(firmwareUpdate_1).default; } });
+var getAccountInfo_1 = require("./getAccountInfo");
+Object.defineProperty(exports, "getAccountInfo", { enumerable: true, get: function () { return __importDefault(getAccountInfo_1).default; } });
+var getAddress_1 = require("./getAddress");
+Object.defineProperty(exports, "getAddress", { enumerable: true, get: function () { return __importDefault(getAddress_1).default; } });
+var getCoinInfo_1 = require("./getCoinInfo");
+Object.defineProperty(exports, "getCoinInfo", { enumerable: true, get: function () { return __importDefault(getCoinInfo_1).default; } });
+var getDeviceState_1 = require("./getDeviceState");
+Object.defineProperty(exports, "getDeviceState", { enumerable: true, get: function () { return __importDefault(getDeviceState_1).default; } });
+var getFeatures_1 = require("./getFeatures");
+Object.defineProperty(exports, "getFeatures", { enumerable: true, get: function () { return __importDefault(getFeatures_1).default; } });
+var getOwnershipId_1 = require("./getOwnershipId");
+Object.defineProperty(exports, "getOwnershipId", { enumerable: true, get: function () { return __importDefault(getOwnershipId_1).default; } });
+var getOwnershipProof_1 = require("./getOwnershipProof");
+Object.defineProperty(exports, "getOwnershipProof", { enumerable: true, get: function () { return __importDefault(getOwnershipProof_1).default; } });
+var getPublicKey_1 = require("./getPublicKey");
+Object.defineProperty(exports, "getPublicKey", { enumerable: true, get: function () { return __importDefault(getPublicKey_1).default; } });
+var getSettings_1 = require("./getSettings");
+Object.defineProperty(exports, "getSettings", { enumerable: true, get: function () { return __importDefault(getSettings_1).default; } });
+var nemGetAddress_1 = require("./nemGetAddress");
+Object.defineProperty(exports, "nemGetAddress", { enumerable: true, get: function () { return __importDefault(nemGetAddress_1).default; } });
+var nemSignTransaction_1 = require("./nemSignTransaction");
+Object.defineProperty(exports, "nemSignTransaction", { enumerable: true, get: function () { return __importDefault(nemSignTransaction_1).default; } });
+var pushTransaction_1 = require("./pushTransaction");
+Object.defineProperty(exports, "pushTransaction", { enumerable: true, get: function () { return __importDefault(pushTransaction_1).default; } });
+var rebootToBootloader_1 = require("./rebootToBootloader");
+Object.defineProperty(exports, "rebootToBootloader", { enumerable: true, get: function () { return __importDefault(rebootToBootloader_1).default; } });
+var recoveryDevice_1 = require("./recoveryDevice");
+Object.defineProperty(exports, "recoveryDevice", { enumerable: true, get: function () { return __importDefault(recoveryDevice_1).default; } });
+var requestLogin_1 = require("./requestLogin");
+Object.defineProperty(exports, "requestLogin", { enumerable: true, get: function () { return __importDefault(requestLogin_1).default; } });
+var resetDevice_1 = require("./resetDevice");
+Object.defineProperty(exports, "resetDevice", { enumerable: true, get: function () { return __importDefault(resetDevice_1).default; } });
+var rippleGetAddress_1 = require("./rippleGetAddress");
+Object.defineProperty(exports, "rippleGetAddress", { enumerable: true, get: function () { return __importDefault(rippleGetAddress_1).default; } });
+var rippleSignTransaction_1 = require("./rippleSignTransaction");
+Object.defineProperty(exports, "rippleSignTransaction", { enumerable: true, get: function () { return __importDefault(rippleSignTransaction_1).default; } });
+var setProxy_1 = require("./setProxy");
+Object.defineProperty(exports, "setProxy", { enumerable: true, get: function () { return __importDefault(setProxy_1).default; } });
+var signMessage_1 = require("./signMessage");
+Object.defineProperty(exports, "signMessage", { enumerable: true, get: function () { return __importDefault(signMessage_1).default; } });
+var signTransaction_1 = require("./signTransaction");
+Object.defineProperty(exports, "signTransaction", { enumerable: true, get: function () { return __importDefault(signTransaction_1).default; } });
+var stellarGetAddress_1 = require("./stellarGetAddress");
+Object.defineProperty(exports, "stellarGetAddress", { enumerable: true, get: function () { return __importDefault(stellarGetAddress_1).default; } });
+var stellarSignTransaction_1 = require("./stellarSignTransaction");
+Object.defineProperty(exports, "stellarSignTransaction", { enumerable: true, get: function () { return __importDefault(stellarSignTransaction_1).default; } });
+var tezosGetAddress_1 = require("./tezosGetAddress");
+Object.defineProperty(exports, "tezosGetAddress", { enumerable: true, get: function () { return __importDefault(tezosGetAddress_1).default; } });
+var tezosGetPublicKey_1 = require("./tezosGetPublicKey");
+Object.defineProperty(exports, "tezosGetPublicKey", { enumerable: true, get: function () { return __importDefault(tezosGetPublicKey_1).default; } });
+var tezosSignTransaction_1 = require("./tezosSignTransaction");
+Object.defineProperty(exports, "tezosSignTransaction", { enumerable: true, get: function () { return __importDefault(tezosSignTransaction_1).default; } });
+var verifyMessage_1 = require("./verifyMessage");
+Object.defineProperty(exports, "verifyMessage", { enumerable: true, get: function () { return __importDefault(verifyMessage_1).default; } });
+var wipeDevice_1 = require("./wipeDevice");
+Object.defineProperty(exports, "wipeDevice", { enumerable: true, get: function () { return __importDefault(wipeDevice_1).default; } });
+//# sourceMappingURL=index.js.map

package/lib/api/management/uploadFirmware.d.ts

@@ -0,0 +1,6 @@
+import { CoreMessage } from '../../events';
+import { PROTO } from '../../constants';
+import type { Device } from '../../device/Device';
+import type { TypedCall } from '../../device/DeviceCommands';
+export declare const uploadFirmware: (typedCall: TypedCall, postMessage: (message: CoreMessage) => void, device: Device, { payload }: PROTO.FirmwareUpload) => Promise<PROTO.Success>;
+//# sourceMappingURL=uploadFirmware.d.ts.map

package/lib/api/management/uploadFirmware.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadFirmware = void 0;
+const events_1 = require("../../events");
+const constants_1 = require("../../constants");
+const postConfirmationMessage = (device) => {
+    if (device.features.firmware_present) {
+        device.emit(events_1.DEVICE.BUTTON, device, { code: 'ButtonRequest_FirmwareUpdate' });
+    }
+};
+const postProgressMessage = (device, progress, postMessage) => {
+    postMessage((0, events_1.createUiMessage)(events_1.UI.FIRMWARE_PROGRESS, {
+        device: device.toMessageObject(),
+        progress,
+    }));
+};
+const uploadFirmware = async (typedCall, postMessage, device, { payload }) => {
+    if (device.features.major_version === 1) {
+        postConfirmationMessage(device);
+        await typedCall('FirmwareErase', 'Success', {});
+        postProgressMessage(device, 0, postMessage);
+        const { message } = await typedCall('FirmwareUpload', 'Success', {
+            payload,
+        });
+        postProgressMessage(device, 100, postMessage);
+        return message;
+    }
+    if (device.features.major_version === 2) {
+        postConfirmationMessage(device);
+        const length = payload.byteLength;
+        let response = await typedCall('FirmwareErase', ['FirmwareRequest', 'Success'], { length });
+        while (response.type !== 'Success') {
+            const start = response.message.offset;
+            const end = response.message.offset + response.message.length;
+            const chunk = payload.slice(start, end);
+            if (start > 0) {
+                postProgressMessage(device, Math.round((start / length) * 100), postMessage);
+            }
+            response = await typedCall('FirmwareUpload', ['FirmwareRequest', 'Success'], {
+                payload: chunk,
+            });
+        }
+        postProgressMessage(device, 100, postMessage);
+        return response.message;
+    }
+    throw constants_1.ERRORS.TypedError('Runtime', 'uploadFirmware: unknown major_version');
+};
+exports.uploadFirmware = uploadFirmware;
+//# sourceMappingURL=uploadFirmware.js.map

package/lib/api/nem/nemSignTx.d.ts

@@ -0,0 +1,4 @@
+import { PROTO } from '../../constants';
+import * as $T from '../../types/api/nemSignTransaction';
+export declare const createTx: (tx: $T.NEMTransaction, address_n: number[]) => PROTO.NEMSignTx;
+//# sourceMappingURL=nemSignTx.d.ts.map

package/lib/api/nem/nemSignTx.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTx = void 0;
+const constants_1 = require("../../constants");
+const getCommon = (tx, address_n) => ({
+    address_n,
+    network: (tx.version >> 24) & 0xff,
+    timestamp: tx.timeStamp,
+    fee: tx.fee,
+    deadline: tx.deadline,
+    signer: address_n ? undefined : tx.signer,
+});
+const transferMessage = (tx) => {
+    const mosaics = tx.mosaics
+        ? tx.mosaics.map(mosaic => ({
+            namespace: mosaic.mosaicId.namespaceId,
+            mosaic: mosaic.mosaicId.name,
+            quantity: mosaic.quantity,
+        }))
+        : undefined;
+    return {
+        recipient: tx.recipient,
+        amount: tx.amount,
+        payload: tx.message ? tx.message.payload : undefined,
+        public_key: tx.message && tx.message.type === 0x02 ? tx.message.publicKey : undefined,
+        mosaics,
+    };
+};
+const importanceTransferMessage = (tx) => ({
+    mode: tx.importanceTransfer.mode,
+    public_key: tx.importanceTransfer.publicKey,
+});
+const aggregateModificationMessage = (tx) => {
+    const modifications = tx.modifications
+        ? tx.modifications.map(modification => ({
+            type: modification.modificationType,
+            public_key: modification.cosignatoryAccount,
+        }))
+        : undefined;
+    return {
+        modifications,
+        relative_change: tx.minCosignatories.relativeChange,
+    };
+};
+const provisionNamespaceMessage = (tx) => ({
+    namespace: tx.newPart,
+    parent: tx.parent,
+    sink: tx.rentalFeeSink,
+    fee: tx.rentalFee,
+});
+const mosaicCreationMessage = (tx) => {
+    const { levy } = tx.mosaicDefinition;
+    const definition = {
+        namespace: tx.mosaicDefinition.id.namespaceId,
+        mosaic: tx.mosaicDefinition.id.name,
+        levy: levy && levy.type,
+        fee: levy && levy.fee,
+        levy_address: levy && levy.recipient,
+        levy_namespace: levy && levy.mosaicId && levy.mosaicId.namespaceId,
+        levy_mosaic: levy && levy.mosaicId && levy.mosaicId.name,
+        description: tx.mosaicDefinition.description,
+    };
+    const { properties } = tx.mosaicDefinition;
+    if (Array.isArray(properties)) {
+        properties.forEach(property => {
+            const { name, value } = property;
+            switch (name) {
+                case 'divisibility':
+                    definition.divisibility = parseInt(value, 10);
+                    break;
+                case 'initialSupply':
+                    definition.supply = parseInt(value, 10);
+                    break;
+                case 'supplyMutable':
+                    definition.mutable_supply = value === 'true';
+                    break;
+                case 'transferable':
+                    definition.transferable = value === 'true';
+                    break;
+            }
+        });
+    }
+    return {
+        definition,
+        sink: tx.creationFeeSink,
+        fee: tx.creationFee,
+    };
+};
+const supplyChangeMessage = (tx) => ({
+    namespace: tx.mosaicId.namespaceId,
+    mosaic: tx.mosaicId.name,
+    type: tx.supplyType,
+    delta: tx.delta,
+});
+const createTx = (tx, address_n) => {
+    let transaction = tx;
+    const message = {
+        transaction: getCommon(tx, address_n),
+        transfer: undefined,
+        importance_transfer: undefined,
+        aggregate_modification: undefined,
+        provision_namespace: undefined,
+        mosaic_creation: undefined,
+        supply_change: undefined,
+    };
+    if (tx.type === constants_1.NEM.TxType.COSIGNING ||
+        tx.type === constants_1.NEM.TxType.MULTISIG ||
+        tx.type === constants_1.NEM.TxType.MULTISIG_SIGNATURE) {
+        message.cosigning =
+            tx.type === constants_1.NEM.TxType.COSIGNING || tx.type === constants_1.NEM.TxType.MULTISIG_SIGNATURE;
+        transaction = tx.otherTrans;
+        message.multisig = getCommon(transaction);
+    }
+    switch (transaction.type) {
+        case constants_1.NEM.TxType.TRANSFER:
+            message.transfer = transferMessage(transaction);
+            break;
+        case constants_1.NEM.TxType.IMPORTANCE_TRANSFER:
+            message.importance_transfer = importanceTransferMessage(transaction);
+            break;
+        case constants_1.NEM.TxType.AGGREGATE_MODIFICATION:
+            message.aggregate_modification = aggregateModificationMessage(transaction);
+            break;
+        case constants_1.NEM.TxType.PROVISION_NAMESPACE:
+            message.provision_namespace = provisionNamespaceMessage(transaction);
+            break;
+        case constants_1.NEM.TxType.MOSAIC_CREATION:
+            message.mosaic_creation = mosaicCreationMessage(transaction);
+            break;
+        case constants_1.NEM.TxType.SUPPLY_CHANGE:
+            message.supply_change = supplyChangeMessage(transaction);
+            break;
+        default:
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Unknown transaction type');
+    }
+    return message;
+};
+exports.createTx = createTx;
+//# sourceMappingURL=nemSignTx.js.map

package/lib/api/nemGetAddress.d.ts

@@ -0,0 +1,22 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import { PROTO } from '../constants';
+declare type Params = PROTO.NEMGetAddress & {
+    address?: string;
+};
+export default class NEMGetAddress extends AbstractMethod<'nemGetAddress', Params[]> {
+    hasBundle?: boolean;
+    progress: number;
+    confirmed?: boolean;
+    init(): void;
+    getButtonRequestData(code: string): {
+        type: "address";
+        serializedPath: string;
+        address: string;
+    } | undefined;
+    confirmation(): Promise<boolean>;
+    noBackupConfirmation(): Promise<boolean>;
+    _call({ address_n, network, show_display }: Params): Promise<PROTO.NEMAddress>;
+    run(): Promise<import("..").Address | import("..").Address[]>;
+}
+export {};
+//# sourceMappingURL=nemGetAddress.d.ts.map

package/lib/api/nemGetAddress.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const coinInfo_1 = require("../data/coinInfo");
+const pathUtils_1 = require("../utils/pathUtils");
+const constants_1 = require("../constants");
+const events_1 = require("../events");
+const MAINNET = 0x68;
+const TESTNET = 0x98;
+const MIJIN = 0x60;
+class NEMGetAddress extends AbstractMethod_1.AbstractMethod {
+    constructor() {
+        super(...arguments);
+        this.progress = 0;
+    }
+    init() {
+        this.requiredPermissions = ['read'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('NEM'), this.firmwareRange);
+        this.hasBundle = !!this.payload.bundle;
+        const payload = !this.payload.bundle
+            ? { ...this.payload, bundle: [this.payload] }
+            : this.payload;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'bundle', type: 'array' },
+            { name: 'useEventListener', type: 'boolean' },
+        ]);
+        this.params = payload.bundle.map(batch => {
+            (0, paramsValidator_1.validateParams)(batch, [
+                { name: 'path', required: true },
+                { name: 'address', type: 'string' },
+                { name: 'network', type: 'number' },
+                { name: 'showOnTrezor', type: 'boolean' },
+            ]);
+            const path = (0, pathUtils_1.validatePath)(batch.path, 3);
+            return {
+                address_n: path,
+                network: batch.network || MAINNET,
+                show_display: typeof batch.showOnTrezor === 'boolean' ? batch.showOnTrezor : true,
+                address: batch.address,
+            };
+        });
+        const useEventListener = payload.useEventListener &&
+            this.params.length === 1 &&
+            typeof this.params[0].address === 'string' &&
+            this.params[0].show_display;
+        this.confirmed = useEventListener;
+        this.useUi = !useEventListener;
+        if (this.params.length === 1) {
+            let network = 'Unknown';
+            switch (this.params[0].network) {
+                case MAINNET:
+                    network = 'Mainnet';
+                    break;
+                case TESTNET:
+                    network = 'Testnet';
+                    break;
+                case MIJIN:
+                    network = 'Mijin';
+                    break;
+            }
+            this.info = `Export NEM address for account #${(0, pathUtils_1.fromHardened)(this.params[0].address_n[2]) + 1} on ${network} network`;
+        }
+        else {
+            this.info = 'Export multiple NEM addresses';
+        }
+    }
+    getButtonRequestData(code) {
+        if (code === 'ButtonRequest_Address') {
+            return {
+                type: 'address',
+                serializedPath: (0, pathUtils_1.getSerializedPath)(this.params[this.progress].address_n),
+                address: this.params[this.progress].address || 'not-set',
+            };
+        }
+    }
+    async confirmation() {
+        if (this.confirmed)
+            return true;
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+            view: 'export-address',
+            label: this.info,
+        }));
+        const uiResp = await uiPromise.promise;
+        this.confirmed = uiResp.payload;
+        return this.confirmed;
+    }
+    async noBackupConfirmation() {
+        await this.getPopupPromise().promise;
+        const uiPromise = this.createUiPromise(events_1.UI.RECEIVE_CONFIRMATION);
+        this.postMessage((0, events_1.createUiMessage)(events_1.UI.REQUEST_CONFIRMATION, {
+            view: 'no-backup',
+        }));
+        const uiResp = await uiPromise.promise;
+        return uiResp.payload;
+    }
+    async _call({ address_n, network, show_display }) {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('NEMGetAddress', 'NEMAddress', {
+            address_n,
+            network,
+            show_display,
+        });
+        return response.message;
+    }
+    async run() {
+        const responses = [];
+        for (let i = 0; i < this.params.length; i++) {
+            const batch = this.params[i];
+            if (batch.show_display) {
+                const silent = await this._call({
+                    ...batch,
+                    show_display: false,
+                });
+                if (typeof batch.address === 'string') {
+                    if (batch.address !== silent.address) {
+                        throw constants_1.ERRORS.TypedError('Method_AddressNotMatch');
+                    }
+                }
+                else {
+                    batch.address = silent.address;
+                }
+            }
+            const response = await this._call(batch);
+            responses.push({
+                path: batch.address_n,
+                serializedPath: (0, pathUtils_1.getSerializedPath)(batch.address_n),
+                address: response.address,
+            });
+            if (this.hasBundle) {
+                this.postMessage((0, events_1.createUiMessage)(events_1.UI.BUNDLE_PROGRESS, {
+                    progress: i,
+                    response,
+                }));
+            }
+            this.progress++;
+        }
+        return this.hasBundle ? responses : responses[0];
+    }
+}
+exports.default = NEMGetAddress;
+//# sourceMappingURL=nemGetAddress.js.map

package/lib/api/nemSignTransaction.d.ts

@@ -0,0 +1,7 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { PROTO } from '../constants';
+export default class NEMSignTransaction extends AbstractMethod<'nemSignTransaction', PROTO.NEMSignTx> {
+    init(): void;
+    run(): Promise<PROTO.NEMSignedTx>;
+}
+//# sourceMappingURL=nemSignTransaction.d.ts.map

package/lib/api/nemSignTransaction.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const coinInfo_1 = require("../data/coinInfo");
+const pathUtils_1 = require("../utils/pathUtils");
+const helper = (0, tslib_1.__importStar)(require("./nem/nemSignTx"));
+class NEMSignTransaction extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = ['read', 'write'];
+        this.firmwareRange = (0, paramsValidator_1.getFirmwareRange)(this.name, (0, coinInfo_1.getMiscNetwork)('NEM'), this.firmwareRange);
+        this.info = 'Sign NEM transaction';
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'path', required: true },
+            { name: 'transaction', required: true },
+        ]);
+        const path = (0, pathUtils_1.validatePath)(payload.path, 3);
+        this.params = helper.createTx(payload.transaction, path);
+    }
+    async run() {
+        const cmd = this.device.getCommands();
+        const response = await cmd.typedCall('NEMSignTx', 'NEMSignedTx', this.params);
+        return response.message;
+    }
+}
+exports.default = NEMSignTransaction;
+//# sourceMappingURL=nemSignTransaction.js.map

package/lib/api/pushTransaction.d.ts

@@ -0,0 +1,14 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+import type { CoinInfo } from '../types';
+declare type Params = {
+    tx: string;
+    coinInfo: CoinInfo;
+};
+export default class PushTransaction extends AbstractMethod<'pushTransaction', Params> {
+    init(): void;
+    run(): Promise<{
+        txid: string;
+    }>;
+}
+export {};
+//# sourceMappingURL=pushTransaction.d.ts.map

package/lib/api/pushTransaction.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const AbstractMethod_1 = require("../core/AbstractMethod");
+const paramsValidator_1 = require("./common/paramsValidator");
+const coinInfo_1 = require("../data/coinInfo");
+const constants_1 = require("../constants");
+const BlockchainLink_1 = require("../backend/BlockchainLink");
+class PushTransaction extends AbstractMethod_1.AbstractMethod {
+    init() {
+        this.requiredPermissions = [];
+        this.useUi = false;
+        this.useDevice = false;
+        const { payload } = this;
+        (0, paramsValidator_1.validateParams)(payload, [
+            { name: 'tx', type: 'string', required: true },
+            { name: 'coin', type: 'string', required: true },
+        ]);
+        const coinInfo = (0, coinInfo_1.getCoinInfo)(payload.coin);
+        if (!coinInfo) {
+            throw constants_1.ERRORS.TypedError('Method_UnknownCoin');
+        }
+        (0, BlockchainLink_1.isBackendSupported)(coinInfo);
+        if (coinInfo.type === 'bitcoin' && !/^[0-9A-Fa-f]*$/.test(payload.tx)) {
+            throw constants_1.ERRORS.TypedError('Method_InvalidParameter', 'Transaction must be hexadecimal');
+        }
+        this.params = {
+            tx: payload.tx,
+            coinInfo,
+        };
+    }
+    async run() {
+        const backend = await (0, BlockchainLink_1.initBlockchain)(this.params.coinInfo, this.postMessage);
+        const txid = await backend.pushTransaction(this.params.tx);
+        return {
+            txid,
+        };
+    }
+}
+exports.default = PushTransaction;
+//# sourceMappingURL=pushTransaction.js.map

package/lib/api/rebootToBootloader.d.ts

@@ -0,0 +1,8 @@
+import { AbstractMethod } from '../core/AbstractMethod';
+export default class RebootToBootloader extends AbstractMethod<'rebootToBootloader'> {
+    confirmed?: boolean;
+    init(): void;
+    confirmation(): Promise<boolean>;
+    run(): Promise<import("packages/transport/lib/types/messages").Success>;
+}
+//# sourceMappingURL=rebootToBootloader.d.ts.map