@alephium/ledger-app 0.2.1 → 0.4.0

package/dist/test/wallet.test.js

@@ -0,0 +1,383 @@
+"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 });
+const src_1 = __importStar(require("../src"));
+const web3_1 = require("@alephium/web3");
+const web3_test_1 = require("@alephium/web3-test");
+const web3_wallet_1 = require("@alephium/web3-wallet");
+const blakejs_1 = __importDefault(require("blakejs"));
+const utils_1 = require("./utils");
+describe('ledger wallet', () => {
+    const nodeProvider = new web3_1.NodeProvider("http://127.0.0.1:22973");
+    web3_1.web3.setCurrentNodeProvider(nodeProvider);
+    let pathIndex;
+    let path;
+    beforeEach(() => {
+        pathIndex = (0, utils_1.getRandomInt)(0, 1000000);
+        path = `m/44'/1234'/0'/0/` + pathIndex;
+    });
+    async function transferToAddress(address, amount = web3_1.ONE_ALPH * 10n) {
+        const balance0 = await getALPHBalance(address);
+        const fromAccount = await (0, web3_test_1.getSigner)();
+        const transferResult = await (0, web3_test_1.transfer)(fromAccount, address, web3_1.ALPH_TOKEN_ID, amount);
+        await (0, web3_1.waitForTxConfirmation)(transferResult.txId, 1, 1000);
+        const balance1 = await getALPHBalance(address);
+        expect(balance1 - balance0).toEqual(amount);
+    }
+    async function getALPHBalance(address) {
+        const balances = await nodeProvider.addresses.getAddressesAddressBalance(address);
+        return BigInt(balances.balance);
+    }
+    it('should get version', async () => {
+        const transport = await (0, utils_1.createTransport)();
+        const app = new src_1.default(transport);
+        const version = await app.getVersion();
+        expect(version).toBe('0.4.0');
+        await app.close();
+    });
+    it('should get public key', async () => {
+        const transport = await (0, utils_1.createTransport)();
+        const app = new src_1.default(transport);
+        const [account, hdIndex] = await app.getAccount(path);
+        expect(hdIndex).toBe(pathIndex);
+        console.log(account);
+        await app.close();
+    });
+    it('should get public key and confirm address', async () => {
+        const transport = await (0, utils_1.createTransport)();
+        const app = new src_1.default(transport);
+        (0, utils_1.approveAddress)();
+        const [account, hdIndex] = await app.getAccount(path, undefined, undefined, true);
+        expect(hdIndex).toBe(pathIndex);
+        console.log(account);
+        await app.close();
+    }, 30000);
+    it('should get public key for group', async () => {
+        const transport = await (0, utils_1.createTransport)();
+        const app = new src_1.default(transport);
+        for (let group = 0; group < src_1.GROUP_NUM; group++) {
+            const [account, hdIndex] = await app.getAccount(path, group);
+            expect(hdIndex >= pathIndex).toBe(true);
+            expect((0, web3_1.groupOfAddress)(account.address)).toBe(group);
+            expect(account.keyType).toBe('default');
+        }
+        await app.close();
+    });
+    it('should get public key for group for Schnorr signature', async () => {
+        const transport = await (0, utils_1.createTransport)();
+        const app = new src_1.default(transport);
+        for (let group = 0; group < src_1.GROUP_NUM; group++) {
+            await expect(app.getAccount(path, group, 'bip340-schnorr')).rejects.toThrow('BIP340-Schnorr is not supported yet');
+        }
+        await app.close();
+    });
+    it('should sign hash', async () => {
+        const transport = await (0, utils_1.createTransport)();
+        const app = new src_1.default(transport);
+        const [account] = await app.getAccount(path);
+        console.log(account);
+        const hash = Buffer.from(blakejs_1.default.blake2b(Buffer.from([0, 1, 2, 3, 4]), undefined, 32));
+        (0, utils_1.approveHash)();
+        const signature = await app.signHash(path, hash);
+        console.log(signature);
+        await app.close();
+        expect((0, web3_1.transactionVerifySignature)(hash.toString('hex'), account.publicKey, signature)).toBe(true);
+    }, 10000);
+    it('shoudl transfer alph to one address', async () => {
+        const transport = await (0, utils_1.createTransport)();
+        const app = new src_1.default(transport);
+        const [testAccount] = await app.getAccount(path);
+        await transferToAddress(testAccount.address);
+        const buildTxResult = await nodeProvider.transactions.postTransactionsBuild({
+            fromPublicKey: testAccount.publicKey,
+            destinations: [
+                {
+                    address: '1BmVCLrjttchZMW7i6df7mTdCKzHpy38bgDbVL1GqV6P7',
+                    attoAlphAmount: (web3_1.ONE_ALPH * 2n).toString(),
+                }
+            ]
+        });
+        (0, utils_1.approveTx)([utils_1.OutputType.Base]);
+        const signature = await app.signUnsignedTx(path, Buffer.from(buildTxResult.unsignedTx, 'hex'));
+        expect((0, web3_1.transactionVerifySignature)(buildTxResult.txId, testAccount.publicKey, signature)).toBe(true);
+        const submitResult = await nodeProvider.transactions.postTransactionsSubmit({
+            unsignedTx: buildTxResult.unsignedTx,
+            signature: signature
+        });
+        await (0, web3_1.waitForTxConfirmation)(submitResult.txId, 1, 1000);
+        const balance = await getALPHBalance(testAccount.address);
+        expect(balance < (web3_1.ONE_ALPH * 8n)).toEqual(true);
+        await app.close();
+    }, 120000);
+    it('should transfer alph to multiple addresses', async () => {
+        const transport = await (0, utils_1.createTransport)();
+        const app = new src_1.default(transport);
+        const [testAccount] = await app.getAccount(path);
+        await transferToAddress(testAccount.address);
+        const buildTxResult = await nodeProvider.transactions.postTransactionsBuild({
+            fromPublicKey: testAccount.publicKey,
+            destinations: [
+                {
+                    address: '1BmVCLrjttchZMW7i6df7mTdCKzHpy38bgDbVL1GqV6P7',
+                    attoAlphAmount: (web3_1.ONE_ALPH * 2n).toString(),
+                },
+                {
+                    address: '1F1fu6GjuN9yUVRFVcgQKWwiTg8RMzKFv1BZFDwFcfWJq',
+                    attoAlphAmount: (web3_1.ONE_ALPH * 3n).toString(),
+                },
+            ]
+        });
+        (0, utils_1.approveTx)(Array(2).fill(utils_1.OutputType.Base));
+        const signature = await app.signUnsignedTx(path, Buffer.from(buildTxResult.unsignedTx, 'hex'));
+        expect((0, web3_1.transactionVerifySignature)(buildTxResult.txId, testAccount.publicKey, signature)).toBe(true);
+        const submitResult = await nodeProvider.transactions.postTransactionsSubmit({
+            unsignedTx: buildTxResult.unsignedTx,
+            signature: signature
+        });
+        await (0, web3_1.waitForTxConfirmation)(submitResult.txId, 1, 1000);
+        const balance1 = await getALPHBalance(testAccount.address);
+        expect(balance1 < (web3_1.ONE_ALPH * 5n)).toEqual(true);
+        await app.close();
+    }, 120000);
+    it('should transfer alph to multisig address', async () => {
+        const transport = await (0, utils_1.createTransport)();
+        const app = new src_1.default(transport);
+        const [testAccount] = await app.getAccount(path);
+        await transferToAddress(testAccount.address);
+        const multiSigAddress = 'X3KYVteDjsKuUP1F68Nv9iEUecnnkMuwjbC985AnA6MvciDFJ5bAUEso2Sd7sGrwZ5rfNLj7Rp4n9XjcyzDiZsrPxfhNkPYcDm3ce8pQ9QasNFByEufMi3QJ3cS9Vk6cTpqNcq';
+        const buildTxResult = await nodeProvider.transactions.postTransactionsBuild({
+            fromPublicKey: testAccount.publicKey,
+            destinations: [
+                {
+                    address: multiSigAddress,
+                    attoAlphAmount: (web3_1.ONE_ALPH * 2n).toString(),
+                }
+            ]
+        });
+        (0, utils_1.approveTx)([utils_1.OutputType.Multisig]);
+        const signature = await app.signUnsignedTx(path, Buffer.from(buildTxResult.unsignedTx, 'hex'));
+        expect((0, web3_1.transactionVerifySignature)(buildTxResult.txId, testAccount.publicKey, signature)).toBe(true);
+        const submitResult = await nodeProvider.transactions.postTransactionsSubmit({
+            unsignedTx: buildTxResult.unsignedTx,
+            signature: signature
+        });
+        await (0, web3_1.waitForTxConfirmation)(submitResult.txId, 1, 1000);
+        const balance1 = await getALPHBalance(testAccount.address);
+        expect(balance1 < (web3_1.ONE_ALPH * 8n)).toEqual(true);
+        await app.close();
+    }, 120000);
+    it('should transfer token to multisig address', async () => {
+        const transport = await (0, utils_1.createTransport)();
+        const app = new src_1.default(transport);
+        const [testAccount] = await app.getAccount(path);
+        await transferToAddress(testAccount.address);
+        const tokenInfo = await (0, web3_test_1.mintToken)(testAccount.address, 2222222222222222222222222n);
+        const multiSigAddress = 'X3KYVteDjsKuUP1F68Nv9iEUecnnkMuwjbC985AnA6MvciDFJ5bAUEso2Sd7sGrwZ5rfNLj7Rp4n9XjcyzDiZsrPxfhNkPYcDm3ce8pQ9QasNFByEufMi3QJ3cS9Vk6cTpqNcq';
+        const buildTxResult = await nodeProvider.transactions.postTransactionsBuild({
+            fromPublicKey: testAccount.publicKey,
+            destinations: [
+                {
+                    address: multiSigAddress,
+                    attoAlphAmount: (web3_1.ONE_ALPH * 5n).toString(),
+                    tokens: [
+                        {
+                            id: tokenInfo.contractId,
+                            amount: "1111111111111111111111111",
+                        }
+                    ]
+                }
+            ]
+        });
+        (0, utils_1.approveTx)([utils_1.OutputType.MultisigAndToken, utils_1.OutputType.Multisig]);
+        const signature = await app.signUnsignedTx(path, Buffer.from(buildTxResult.unsignedTx, 'hex'));
+        expect((0, web3_1.transactionVerifySignature)(buildTxResult.txId, testAccount.publicKey, signature)).toBe(true);
+        const submitResult = await nodeProvider.transactions.postTransactionsSubmit({
+            unsignedTx: buildTxResult.unsignedTx,
+            signature: signature
+        });
+        await (0, web3_1.waitForTxConfirmation)(submitResult.txId, 1, 1000);
+        const balances = await nodeProvider.addresses.getAddressesAddressBalance(testAccount.address);
+        const alphBalance = BigInt(balances.balance);
+        expect(alphBalance < (web3_1.ONE_ALPH * 5n)).toEqual(true);
+        expect(balances.tokenBalances.length).toEqual(1);
+        const token = balances.tokenBalances[0];
+        expect(token.id).toEqual(tokenInfo.contractId);
+        expect(token.amount).toEqual('1111111111111111111111111');
+        await app.close();
+    }, 120000);
+    it('should transfer from multiple inputs', async () => {
+        const transport = await (0, utils_1.createTransport)();
+        const app = new src_1.default(transport);
+        const [testAccount] = await app.getAccount(path);
+        for (let i = 0; i < 20; i += 1) {
+            await transferToAddress(testAccount.address, web3_1.ONE_ALPH);
+        }
+        const buildTxResult = await nodeProvider.transactions.postTransactionsBuild({
+            fromPublicKey: testAccount.publicKey,
+            destinations: [
+                {
+                    address: '1BmVCLrjttchZMW7i6df7mTdCKzHpy38bgDbVL1GqV6P7',
+                    attoAlphAmount: (web3_1.ONE_ALPH * 19n).toString(),
+                }
+            ]
+        });
+        (0, utils_1.approveTx)([utils_1.OutputType.Base]);
+        const signature = await app.signUnsignedTx(path, Buffer.from(buildTxResult.unsignedTx, 'hex'));
+        expect((0, web3_1.transactionVerifySignature)(buildTxResult.txId, testAccount.publicKey, signature)).toBe(true);
+        const submitResult = await nodeProvider.transactions.postTransactionsSubmit({
+            unsignedTx: buildTxResult.unsignedTx,
+            signature: signature
+        });
+        await (0, web3_1.waitForTxConfirmation)(submitResult.txId, 1, 1000);
+        const balance = await getALPHBalance(testAccount.address);
+        expect(balance < (web3_1.ONE_ALPH * 1n)).toEqual(true);
+        await app.close();
+    }, 120000);
+    function getAccount(groupIndex) {
+        const useDefaultKeyType = Math.random() >= 0.5;
+        if (useDefaultKeyType) {
+            const account = web3_wallet_1.PrivateKeyWallet.Random(groupIndex);
+            return { account, unlockScript: '00' + account.publicKey };
+        }
+        const account = web3_wallet_1.PrivateKeyWallet.Random(groupIndex, nodeProvider, 'bip340-schnorr');
+        const unlockScript = '02' + `0101000000000458144020${account.publicKey}8685` + '00';
+        return { account, unlockScript };
+    }
+    it('should test external inputs', async () => {
+        const transport = await (0, utils_1.createTransport)();
+        const app = new src_1.default(transport);
+        const [testAccount] = await app.getAccount(path);
+        const { account: newAccount, unlockScript: unlockScript0 } = getAccount(testAccount.group);
+        for (let i = 0; i < 2; i += 1) {
+            await transferToAddress(testAccount.address, web3_1.ONE_ALPH);
+            await transferToAddress(newAccount.address, web3_1.ONE_ALPH);
+        }
+        const utxos0 = await nodeProvider.addresses.getAddressesAddressUtxos(newAccount.address);
+        expect(utxos0.utxos.length).toEqual(2);
+        const utxos1 = await nodeProvider.addresses.getAddressesAddressUtxos(testAccount.address);
+        expect(utxos1.utxos.length).toEqual(2);
+        const useSameAsPrevious = Math.random() >= 0.5;
+        const inputs0 = utxos0.utxos.map((utxo, index) => {
+            const unlockScript = index > 0 && useSameAsPrevious ? '03' : unlockScript0;
+            return { outputRef: utxo.ref, unlockScript };
+        });
+        const unlockScript1 = '00' + testAccount.publicKey;
+        const inputs1 = utxos1.utxos.map((utxo, index) => {
+            const unlockScript = index > 0 && useSameAsPrevious ? '03' : unlockScript1;
+            return { outputRef: utxo.ref, unlockScript };
+        });
+        const unsignedTx = {
+            txId: '',
+            version: 0,
+            networkId: 4,
+            gasAmount: 100000,
+            gasPrice: (web3_1.ONE_ALPH / 100000n).toString(),
+            inputs: inputs0.concat(inputs1),
+            fixedOutputs: [{
+                    hint: 0,
+                    key: '',
+                    attoAlphAmount: (web3_1.ONE_ALPH * 3n).toString(),
+                    address: newAccount.address,
+                    tokens: [],
+                    lockTime: 0,
+                    message: ''
+                }]
+        };
+        const txBytes = web3_1.codec.unsignedTxCodec.encodeApiUnsignedTx(unsignedTx);
+        const signResult0 = await newAccount.signUnsignedTx({
+            signerAddress: newAccount.address,
+            unsignedTx: (0, web3_1.binToHex)(txBytes)
+        });
+        (0, utils_1.approveTx)([utils_1.OutputType.Base], true);
+        const signature1 = await app.signUnsignedTx(path, Buffer.from(txBytes));
+        expect((0, web3_1.transactionVerifySignature)(signResult0.txId, testAccount.publicKey, signature1)).toBe(true);
+        const submitResult = await nodeProvider.multisig.postMultisigSubmit({
+            unsignedTx: (0, web3_1.binToHex)(txBytes),
+            signatures: [signResult0.signature, signature1]
+        });
+        await (0, web3_1.waitForTxConfirmation)(submitResult.txId, 1, 1000);
+        const balance = await getALPHBalance(newAccount.address);
+        expect(balance).toEqual(web3_1.ONE_ALPH * 3n);
+        await app.close();
+    }, 120000);
+    it('should test self transfer tx', async () => {
+        const transport = await (0, utils_1.createTransport)();
+        const app = new src_1.default(transport);
+        const [testAccount] = await app.getAccount(path);
+        await transferToAddress(testAccount.address);
+        const buildTxResult = await nodeProvider.transactions.postTransactionsBuild({
+            fromPublicKey: testAccount.publicKey,
+            destinations: [
+                {
+                    address: testAccount.address,
+                    attoAlphAmount: (web3_1.ONE_ALPH * 2n).toString(),
+                }
+            ]
+        });
+        (0, utils_1.approveTx)([]);
+        const signature = await app.signUnsignedTx(path, Buffer.from(buildTxResult.unsignedTx, 'hex'));
+        expect((0, web3_1.transactionVerifySignature)(buildTxResult.txId, testAccount.publicKey, signature)).toBe(true);
+        const submitResult = await nodeProvider.transactions.postTransactionsSubmit({
+            unsignedTx: buildTxResult.unsignedTx,
+            signature: signature
+        });
+        await (0, web3_1.waitForTxConfirmation)(submitResult.txId, 1, 1000);
+        const balance = await getALPHBalance(testAccount.address);
+        expect(balance > (web3_1.ONE_ALPH * 9n)).toEqual(true);
+        await app.close();
+    }, 12000);
+    it('should test script execution tx', async () => {
+        const transport = await (0, utils_1.createTransport)();
+        const app = new src_1.default(transport);
+        const [testAccount] = await app.getAccount(path);
+        await transferToAddress(testAccount.address);
+        const buildTxResult = await nodeProvider.contracts.postContractsUnsignedTxDeployContract({
+            fromPublicKey: testAccount.publicKey,
+            bytecode: '00010c010000000002d38d0b3636020000'
+        });
+        setTimeout(() => (0, utils_1.skipBlindSigningWarning)(), 1000);
+        await expect(app.signUnsignedTx(path, Buffer.from(buildTxResult.unsignedTx, 'hex'))).rejects.toThrow();
+        await (0, utils_1.enableBlindSigning)();
+        if ((0, utils_1.needToAutoApprove)()) {
+            (0, utils_1.staxFlexApproveOnce)().then(() => (0, utils_1.approveTx)([]));
+        }
+        else {
+            // waiting for blind signing setting to be enabled
+            await (0, web3_1.sleep)(20000);
+        }
+        const signature = await app.signUnsignedTx(path, Buffer.from(buildTxResult.unsignedTx, 'hex'));
+        const submitResult = await nodeProvider.transactions.postTransactionsSubmit({
+            unsignedTx: buildTxResult.unsignedTx,
+            signature: signature
+        });
+        await (0, web3_1.waitForTxConfirmation)(submitResult.txId, 1, 1000);
+        const details = await nodeProvider.transactions.getTransactionsDetailsTxid(submitResult.txId);
+        expect(details.scriptExecutionOk).toEqual(true);
+        await app.close();
+    }, 120000);
+});

package/docker/devnet.conf

@@ -0,0 +1,55 @@
+# Import this mnemonic to have 4'000'000 token allocated for your addresses
+#
+# vault alarm sad mass witness property virus style good flower rice alpha viable evidence run glare pretty scout evil judge enroll refuse another lava
+
+alephium.genesis.allocations = [
+  {
+    address = "1DrDyTr9RpRsQnDnXo2YRiPzPW4ooHX5LLoqXrqfMrpQH",
+    amount = 1000000000000000000000000,
+    lock-duration = 0 seconds
+  },
+  {
+    address = "14UAjZ3qcmEVKdTo84Kwf4RprTQi86w2TefnnGFjov9xF",
+    amount = 1000000000000000000000000,
+    lock-duration = 0 seconds
+  },
+  {
+    address = "15jjExDyS8q3Wqk9v29PCQ21jDqubDrD8WQdgn6VW2oi4",
+    amount = 1000000000000000000000000,
+    lock-duration = 0 seconds
+  },
+  {
+    address = "17cBiTcWhung3WDLuc9ja5Y7BMus5Q7CD9wYBxS1r1P2R",
+    amount = 1000000000000000000000000,
+    lock-duration = 0 seconds
+  }
+]
+alephium.consensus.num-zeros-at-least-in-hash = 0
+alephium.consensus.mainnet.block-target-time = 10 millis
+alephium.consensus.mainnet.uncle-dependency-gap-time = 0 seconds
+alephium.consensus.rhone.block-target-time = 5 millis
+alephium.consensus.rhone.uncle-dependency-gap-time = 0 seconds
+alephium.network.leman-hard-fork-timestamp = 0
+alephium.network.rhone-hard-fork-timestamp = 0
+
+alephium.network.network-id = 4
+alephium.discovery.bootstrap = []
+alephium.wallet.locking-timeout = 99999 minutes
+alephium.mempool.auto-mine-for-dev = true
+alephium.node.event-log.enabled=true
+alephium.node.event-log.index-by-tx-id = true
+alephium.node.event-log.index-by-block-hash = true
+
+alephium.network.rest-port = 22973
+alephium.network.ws-port = 21973
+alephium.network.miner-api-port = 20973
+alephium.api.network-interface = "0.0.0.0"
+alephium.api.api-key-enabled = false
+
+# arbitrary mining addresses
+alephium.mining.miner-addresses = [
+"1FsroWmeJPBhcPiUr37pWXdojRBe6jdey9uukEXk1TheA",
+"1CQvSXsmM5BMFKguKDPpNUfw1idiut8UifLtT8748JdHc",
+"193maApeJWrz9GFwWCfa982ccLARVE9Y1WgKSJaUs7UAx",
+"16fZKYPCZJv2TP3FArA9FLUQceTS9U8xVnSjxFG9MBKyY"
+]

package/docker/docker-compose.yaml

@@ -0,0 +1,22 @@
+version: "3.3"
+
+services:
+  alephium:
+    image: alephium/alephium:v3.3.0
+    restart: "no"
+    ports:
+      - 19973:19973/tcp
+      - 19973:19973/udp
+      - 127.0.0.1:20973:20973
+      - 127.0.0.1:21973:21973
+      - 127.0.0.1:22973:22973
+    security_opt:
+      - no-new-privileges:true
+    volumes:
+      - ./devnet.conf:/alephium-home/.alephium/user.conf
+      # - ~/.alephium:/alephium-home/.alephium
+    environment:
+      ALEPHIUM_FILE_LOG_LEVEL: "DEBUG"
+    healthcheck:
+      test: ["CMD", "curl", "http://127.0.0.1:22973/infos/self-clique"]
+      timeout: 45s

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/ledger-app",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "license": "GPL",
   "types": "dist/src/index.d.ts",
   "exports": {
@@ -12,7 +12,8 @@
     "clean:windows": "node -e \"if (process.platform === 'win32') process.exit(1)\" || , if exist dist rmdir /Q /S dist",
     "lint": "eslint . --ext ts",
     "lint:fix": "eslint . --fix --ext ts",
-    "test": "jest -i --config ./jest-config.json",
+    "speculos-test": "BACKEND=speculos jest -i --config ./jest-config.json",
+    "device-test": "BACKEND=device jest -i --config ./jest-config.json",
     "pub": "npm run build && npm publish --access public"
   },
   "prettier": {
@@ -25,19 +26,18 @@
     "trailingComma": "none"
   },
   "dependencies": {
-    "@alephium/cli": "^0.14.0",
-    "@alephium/web3": "^0.14.0",
-    "@alephium/web3-test": "^0.14.0",
-    "@alephium/web3-wallet": "^0.14.0",
-    "@ledgerhq/hw-transport": "6.27.10"
+    "@alephium/web3": "^1.2.0",
+    "@ledgerhq/hw-transport": "6.31.0"
   },
   "devDependencies": {
-    "@ledgerhq/hw-transport-node-hid": "^6.27.9",
-    "@ledgerhq/hw-transport-node-speculos": "^6.27.9",
-    "@ledgerhq/logs": "^6.10.1",
+    "@alephium/web3-test": "^1.2.0",
+    "@alephium/web3-wallet": "^1.2.0",
+    "@alephium/cli": "^1.2.0",
+    "@ledgerhq/hw-transport-node-hid": "6.29.1",
+    "@ledgerhq/hw-transport-node-speculos": "6.29.0",
     "@types/elliptic": "^6.4.13",
     "@types/jest": "^27.5.1",
-    "@types/node": "^16.7.8",
+    "@types/node": "^20.8.10",
     "@typescript-eslint/eslint-plugin": "^4.30.0",
     "@typescript-eslint/parser": "^4.30.0",
     "eslint": "^7.32.0",

package/src/index.ts

@@ -9,7 +9,8 @@ export const CLA = 0x80
 export enum INS {
   GET_VERSION = 0x00,
   GET_PUBLIC_KEY = 0x01,
-  SIGN_HASH = 0x02
+  SIGN_HASH = 0x02,
+  SIGN_TX = 0x03
 }
 
 export const GROUP_NUM = 4
@@ -32,8 +33,7 @@ export default class AlephiumApp {
     return `${response[0]}.${response[1]}.${response[2]}`
   }
 
-  // TODO: make address display optional
-  async getAccount(startPath: string, targetGroup?: number, keyType?: KeyType): Promise<readonly [Account, number]> {
+  async getAccount(startPath: string, targetGroup?: number, keyType?: KeyType, display = false): Promise<readonly [Account, number]> {
     if ((targetGroup ?? 0) >= GROUP_NUM) {
       throw Error(`Invalid targetGroup: ${targetGroup}`)
     }
@@ -44,7 +44,8 @@ export default class AlephiumApp {
 
     const p1 = targetGroup === undefined ? 0x00 : GROUP_NUM
     const p2 = targetGroup === undefined ? 0x00 : targetGroup
-    const response = await this.transport.send(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(CLA, INS.GET_PUBLIC_KEY, p1, p2, payload)
     const publicKey = ec.keyFromPublic(response.slice(0, 65)).getPublic(true, 'hex')
     const address = addressFromPublicKey(publicKey)
     const group = groupOfAddress(address)
@@ -63,12 +64,40 @@ export default class AlephiumApp {
     const response = await this.transport.send(CLA, INS.SIGN_HASH, 0x00, 0x00, data, [StatusCodes.OK])
     console.log(`response ${response.length} - ${response.toString('hex')}`)
 
-    // Decode signature: https://bitcoin.stackexchange.com/a/12556
-    const rLen = response.slice(3, 4)[0]
-    const r = response.slice(4, 4 + rLen)
-    const sLen = response.slice(5 + rLen, 6 + rLen)[0]
-    const s = response.slice(6 + rLen, 6 + rLen + sLen)
-    console.log(`${rLen} - ${r.toString('hex')}\n${sLen} - ${s.toString('hex')}`)
-    return encodeHexSignature(r.toString('hex'), s.toString('hex'))
+    return decodeSignature(response)
   }
+
+  async signUnsignedTx(path: string, unsignedTx: Buffer): Promise<string> {
+    console.log(`unsigned tx size: ${unsignedTx.length}`)
+    const encodedPath = serde.serializePath(path)
+    const firstFrameTxLength = 256 - 25;
+    const txData = unsignedTx.slice(0, unsignedTx.length > firstFrameTxLength ? firstFrameTxLength : unsignedTx.length)
+    const data = Buffer.concat([encodedPath, txData])
+    let response = await this.transport.send(CLA, INS.SIGN_TX, 0x00, 0x00, data, [StatusCodes.OK])
+    if (unsignedTx.length <= firstFrameTxLength) {
+      return decodeSignature(response)
+    }
+
+    const frameLength = 256 - 5
+    let fromIndex = firstFrameTxLength
+    while (fromIndex < unsignedTx.length) {
+      const remain = unsignedTx.length - fromIndex
+      const toIndex = remain > frameLength ? (fromIndex + frameLength) : unsignedTx.length
+      const data = unsignedTx.slice(fromIndex, toIndex)
+      response = await this.transport.send(CLA, INS.SIGN_TX, 0x01, 0x00, data, [StatusCodes.OK])
+      fromIndex = toIndex
+    }
+
+    return decodeSignature(response)
+  }
+}
+
+function decodeSignature(response: Buffer): string {
+  // Decode signature: https://bitcoin.stackexchange.com/a/12556
+  const rLen = response.slice(3, 4)[0]
+  const r = response.slice(4, 4 + rLen)
+  const sLen = response.slice(5 + rLen, 6 + rLen)[0]
+  const s = response.slice(6 + rLen, 6 + rLen + sLen)
+  console.log(`${rLen} - ${r.toString('hex')}\n${sLen} - ${s.toString('hex')}`)
+  return encodeHexSignature(r.toString('hex'), s.toString('hex'))
 }