@alephium/ledger-app 0.3.0 → 0.4.0

package/dist/src/index.d.ts

@@ -5,7 +5,8 @@ export declare const CLA = 128;
 export declare enum INS {
     GET_VERSION = 0,
     GET_PUBLIC_KEY = 1,
-    SIGN_TX = 2
+    SIGN_HASH = 2,
+    SIGN_TX = 3
 }
 export declare const GROUP_NUM = 4;
 export declare const HASH_LEN = 32;
@@ -14,6 +15,7 @@ export default class AlephiumApp {
     constructor(transport: Transport);
     close(): Promise<void>;
     getVersion(): Promise<string>;
-    getAccount(startPath: string, targetGroup?: number, keyType?: KeyType): Promise<readonly [Account, number]>;
+    getAccount(startPath: string, targetGroup?: number, keyType?: KeyType, display?: boolean): Promise<readonly [Account, number]>;
+    signHash(path: string, hash: Buffer): Promise<string>;
     signUnsignedTx(path: string, unsignedTx: Buffer): Promise<string>;
 }

package/dist/src/index.js

@@ -34,7 +34,8 @@ var INS;
 (function (INS) {
     INS[INS["GET_VERSION"] = 0] = "GET_VERSION";
     INS[INS["GET_PUBLIC_KEY"] = 1] = "GET_PUBLIC_KEY";
-    INS[INS["SIGN_TX"] = 2] = "SIGN_TX";
+    INS[INS["SIGN_HASH"] = 2] = "SIGN_HASH";
+    INS[INS["SIGN_TX"] = 3] = "SIGN_TX";
 })(INS = exports.INS || (exports.INS = {}));
 exports.GROUP_NUM = 4;
 exports.HASH_LEN = 32;
@@ -50,8 +51,7 @@ class AlephiumApp {
         console.log(`response ${response.length} - ${response.toString('hex')}`);
         return `${response[0]}.${response[1]}.${response[2]}`;
     }
-    // TODO: make address display optional
-    async getAccount(startPath, targetGroup, keyType) {
+    async getAccount(startPath, targetGroup, keyType, display = false) {
         if ((targetGroup ?? 0) >= exports.GROUP_NUM) {
             throw Error(`Invalid targetGroup: ${targetGroup}`);
         }
@@ -60,13 +60,24 @@ class AlephiumApp {
         }
         const p1 = targetGroup === undefined ? 0x00 : exports.GROUP_NUM;
         const p2 = targetGroup === undefined ? 0x00 : targetGroup;
-        const response = await this.transport.send(exports.CLA, INS.GET_PUBLIC_KEY, p1, p2, serde.serializePath(startPath));
+        const payload = Buffer.concat([serde.serializePath(startPath), Buffer.from([display ? 1 : 0])]);
+        const response = await this.transport.send(exports.CLA, INS.GET_PUBLIC_KEY, p1, p2, payload);
         const publicKey = ec.keyFromPublic(response.slice(0, 65)).getPublic(true, 'hex');
         const address = (0, web3_1.addressFromPublicKey)(publicKey);
         const group = (0, web3_1.groupOfAddress)(address);
         const hdIndex = response.slice(65, 69).readUInt32BE(0);
         return [{ publicKey: publicKey, address: address, group: group, keyType: keyType ?? 'default' }, hdIndex];
     }
+    async signHash(path, hash) {
+        if (hash.length !== exports.HASH_LEN) {
+            throw new Error('Invalid hash length');
+        }
+        const data = Buffer.concat([serde.serializePath(path), hash]);
+        console.log(`data ${data.length}`);
+        const response = await this.transport.send(exports.CLA, INS.SIGN_HASH, 0x00, 0x00, data, [hw_transport_1.StatusCodes.OK]);
+        console.log(`response ${response.length} - ${response.toString('hex')}`);
+        return decodeSignature(response);
+    }
     async signUnsignedTx(path, unsignedTx) {
         console.log(`unsigned tx size: ${unsignedTx.length}`);
         const encodedPath = serde.serializePath(path);

package/dist/test/utils.d.ts

@@ -0,0 +1,16 @@
+import Transport from '@ledgerhq/hw-transport';
+export declare enum OutputType {
+    Base = 0,
+    Multisig = 1,
+    Token = 2,
+    MultisigAndToken = 3
+}
+export declare function staxFlexApproveOnce(): Promise<void>;
+export declare function approveTx(outputs: OutputType[], hasExternalInputs?: boolean): Promise<void>;
+export declare function approveHash(): Promise<void>;
+export declare function approveAddress(): Promise<void>;
+export declare function skipBlindSigningWarning(): void;
+export declare function enableBlindSigning(): Promise<void>;
+export declare function getRandomInt(min: number, max: number): number;
+export declare function needToAutoApprove(): boolean;
+export declare function createTransport(): Promise<Transport>;

package/dist/test/utils.js

@@ -0,0 +1,215 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTransport = exports.needToAutoApprove = exports.getRandomInt = exports.enableBlindSigning = exports.skipBlindSigningWarning = exports.approveAddress = exports.approveHash = exports.approveTx = exports.staxFlexApproveOnce = exports.OutputType = void 0;
+const hw_transport_node_speculos_1 = __importDefault(require("@ledgerhq/hw-transport-node-speculos"));
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const web3_1 = require("@alephium/web3");
+const hw_transport_node_hid_1 = __importDefault(require("@ledgerhq/hw-transport-node-hid"));
+async function pressButton(button) {
+    await (0, web3_1.sleep)(1000);
+    return (0, node_fetch_1.default)(`http://localhost:25000/button/${button}`, {
+        method: 'POST',
+        body: JSON.stringify({ action: 'press-and-release' })
+    });
+}
+async function clickAndApprove(times) {
+    for (let i = 0; i < times; i++) {
+        await pressButton('right');
+    }
+    await pressButton('both');
+}
+var OutputType;
+(function (OutputType) {
+    OutputType[OutputType["Base"] = 0] = "Base";
+    OutputType[OutputType["Multisig"] = 1] = "Multisig";
+    OutputType[OutputType["Token"] = 2] = "Token";
+    OutputType[OutputType["MultisigAndToken"] = 3] = "MultisigAndToken";
+})(OutputType = exports.OutputType || (exports.OutputType = {}));
+const NanosClickTable = new Map([
+    [OutputType.Base, 5],
+    [OutputType.Multisig, 10],
+    [OutputType.Token, 11],
+    [OutputType.MultisigAndToken, 16],
+]);
+const NanospClickTable = new Map([
+    [OutputType.Base, 3],
+    [OutputType.Multisig, 5],
+    [OutputType.Token, 6],
+    [OutputType.MultisigAndToken, 8],
+]);
+const StaxClickTable = new Map([
+    [OutputType.Base, 2],
+    [OutputType.Multisig, 3],
+    [OutputType.Token, 3],
+    [OutputType.MultisigAndToken, 4],
+]);
+function getOutputClickSize(outputType) {
+    const model = process.env.MODEL;
+    switch (model) {
+        case 'nanos': return NanosClickTable.get(outputType);
+        case 'nanosp':
+        case 'nanox': return NanospClickTable.get(outputType);
+        case 'stax':
+        case 'flex': return StaxClickTable.get(outputType);
+        default: throw new Error(`Unknown model ${model}`);
+    }
+}
+async function click(outputs, hasExternalInputs) {
+    await (0, web3_1.sleep)(1000);
+    if (hasExternalInputs) {
+        await clickAndApprove(1);
+    }
+    for (let index = 0; index < outputs.length; index += 1) {
+        await clickAndApprove(getOutputClickSize(outputs[index]));
+    }
+    await clickAndApprove(1); // fees
+}
+const STAX_CONTINUE_POSITION = { x: 342, y: 606 };
+const STAX_APPROVE_POSITION = { x: 200, y: 515 };
+const STAX_REJECT_POSITION = { x: 36, y: 606 };
+const STAX_SETTINGS_POSITION = { x: 342, y: 55 };
+const STAX_BLIND_SETTING_POSITION = { x: 342, y: 90 };
+const FLEX_CONTINUE_POSITION = { x: 430, y: 550 };
+const FLEX_APPROVE_POSITION = { x: 240, y: 435 };
+const FLEX_REJECT_POSITION = { x: 55, y: 530 };
+const FLEX_SETTINGS_POSITION = { x: 405, y: 75 };
+const FLEX_BLIND_SETTING_POSITION = { x: 405, y: 96 };
+async function touchPosition(pos) {
+    await (0, web3_1.sleep)(1000);
+    return (0, node_fetch_1.default)(`http://localhost:25000/finger`, {
+        method: 'POST',
+        body: JSON.stringify({ action: 'press-and-release', x: pos.x, y: pos.y })
+    });
+}
+async function _touch(times) {
+    let continuePos = process.env.MODEL === 'stax' ? STAX_CONTINUE_POSITION : FLEX_CONTINUE_POSITION;
+    for (let i = 0; i < times; i += 1) {
+        await touchPosition(continuePos);
+    }
+    let approvePos = process.env.MODEL === 'stax' ? STAX_APPROVE_POSITION : FLEX_APPROVE_POSITION;
+    await touchPosition(approvePos);
+}
+async function staxFlexApproveOnce() {
+    if (process.env.MODEL === 'stax') {
+        await touchPosition(STAX_APPROVE_POSITION);
+    }
+    else {
+        await touchPosition(FLEX_APPROVE_POSITION);
+    }
+}
+exports.staxFlexApproveOnce = staxFlexApproveOnce;
+async function touch(outputs, hasExternalInputs) {
+    await (0, web3_1.sleep)(1000);
+    if (hasExternalInputs) {
+        await staxFlexApproveOnce();
+    }
+    for (let index = 0; index < outputs.length; index += 1) {
+        await _touch(getOutputClickSize(outputs[index]));
+    }
+    await _touch(2); // fees
+}
+async function approveTx(outputs, hasExternalInputs = false) {
+    if (!needToAutoApprove())
+        return;
+    const isSelfTransfer = outputs.length === 0 && !hasExternalInputs;
+    if (isSelfTransfer) {
+        if (isStaxOrFlex()) {
+            await _touch(2);
+        }
+        else {
+            await clickAndApprove(2);
+        }
+        return;
+    }
+    if (isStaxOrFlex()) {
+        await touch(outputs, hasExternalInputs);
+    }
+    else {
+        await click(outputs, hasExternalInputs);
+    }
+}
+exports.approveTx = approveTx;
+async function approveHash() {
+    if (!needToAutoApprove())
+        return;
+    if (isStaxOrFlex()) {
+        return await _touch(3);
+    }
+    if (process.env.MODEL === 'nanos') {
+        await clickAndApprove(5);
+    }
+    else {
+        await clickAndApprove(3);
+    }
+}
+exports.approveHash = approveHash;
+async function approveAddress() {
+    if (!needToAutoApprove())
+        return;
+    if (isStaxOrFlex()) {
+        return await _touch(2);
+    }
+    if (process.env.MODEL === 'nanos') {
+        await clickAndApprove(4);
+    }
+    else {
+        await clickAndApprove(2);
+    }
+}
+exports.approveAddress = approveAddress;
+function isStaxOrFlex() {
+    return !process.env.MODEL.startsWith('nano');
+}
+function skipBlindSigningWarning() {
+    if (!needToAutoApprove())
+        return;
+    if (isStaxOrFlex()) {
+        const rejectPos = process.env.MODEL === 'stax' ? STAX_REJECT_POSITION : FLEX_REJECT_POSITION;
+        touchPosition(rejectPos);
+    }
+    else {
+        clickAndApprove(3);
+    }
+}
+exports.skipBlindSigningWarning = skipBlindSigningWarning;
+async function enableBlindSigning() {
+    if (!needToAutoApprove())
+        return;
+    if (isStaxOrFlex()) {
+        const settingsPos = process.env.MODEL === 'stax' ? STAX_SETTINGS_POSITION : FLEX_SETTINGS_POSITION;
+        const blindSettingPos = process.env.MODEL === 'stax' ? STAX_BLIND_SETTING_POSITION : FLEX_BLIND_SETTING_POSITION;
+        await touchPosition(settingsPos);
+        await touchPosition(blindSettingPos);
+        await touchPosition(settingsPos);
+    }
+    else {
+        await clickAndApprove(2);
+    }
+}
+exports.enableBlindSigning = enableBlindSigning;
+function getRandomInt(min, max) {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    return Math.floor(Math.random() * (max - min) + min); // The maximum is exclusive and the minimum is inclusive
+}
+exports.getRandomInt = getRandomInt;
+function needToAutoApprove() {
+    switch (process.env.BACKEND) {
+        case "speculos": return true;
+        case "device": return false;
+        default: throw new Error(`Invalid backend: ${process.env.BACKEND}`);
+    }
+}
+exports.needToAutoApprove = needToAutoApprove;
+const ApduPort = 9999;
+async function createTransport() {
+    switch (process.env.BACKEND) {
+        case "speculos": return hw_transport_node_speculos_1.default.open({ apduPort: ApduPort });
+        case "device": return hw_transport_node_hid_1.default.open('');
+        default: throw new Error(`Invalid backend: ${process.env.BACKEND}`);
+    }
+}
+exports.createTransport = createTransport;