@alephium/ledger-app 0.2.0 → 0.3.0

package/dist/src/index.d.ts

@@ -5,7 +5,7 @@ export declare const CLA = 128;
 export declare enum INS {
     GET_VERSION = 0,
     GET_PUBLIC_KEY = 1,
-    SIGN_HASH = 2
+    SIGN_TX = 2
 }
 export declare const GROUP_NUM = 4;
 export declare const HASH_LEN = 32;
@@ -15,5 +15,5 @@ export default class AlephiumApp {
     close(): Promise<void>;
     getVersion(): Promise<string>;
     getAccount(startPath: string, targetGroup?: number, keyType?: KeyType): 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,7 @@ var INS;
 (function (INS) {
     INS[INS["GET_VERSION"] = 0] = "GET_VERSION";
     INS[INS["GET_PUBLIC_KEY"] = 1] = "GET_PUBLIC_KEY";
-    INS[INS["SIGN_HASH"] = 2] = "SIGN_HASH";
+    INS[INS["SIGN_TX"] = 2] = "SIGN_TX";
 })(INS = exports.INS || (exports.INS = {}));
 exports.GROUP_NUM = 4;
 exports.HASH_LEN = 32;
@@ -67,21 +67,35 @@ class AlephiumApp {
         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');
+    async signUnsignedTx(path, unsignedTx) {
+        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(exports.CLA, INS.SIGN_TX, 0x00, 0x00, data, [hw_transport_1.StatusCodes.OK]);
+        if (unsignedTx.length <= firstFrameTxLength) {
+            return decodeSignature(response);
         }
-        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')}`);
-        // 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 (0, web3_1.encodeHexSignature)(r.toString('hex'), s.toString('hex'));
+        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(exports.CLA, INS.SIGN_TX, 0x01, 0x00, data, [hw_transport_1.StatusCodes.OK]);
+            fromIndex = toIndex;
+        }
+        return decodeSignature(response);
     }
 }
 exports.default = AlephiumApp;
+function decodeSignature(response) {
+    // 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 (0, web3_1.encodeHexSignature)(r.toString('hex'), s.toString('hex'));
+}

package/dist/test/release.test.js

@@ -5,22 +5,128 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const hw_transport_node_hid_1 = __importDefault(require("@ledgerhq/hw-transport-node-hid"));
 const logs_1 = require("@ledgerhq/logs");
-const blakejs_1 = __importDefault(require("blakejs"));
 const web3_1 = require("@alephium/web3");
 const src_1 = __importDefault(require("../src"));
+const web3_test_1 = require("@alephium/web3-test");
+const web3_wallet_1 = require("@alephium/web3-wallet");
 describe.skip('Integration', () => {
     const path = `m/44'/1234'/0'/0/0`;
+    const nodeProvider = new web3_1.NodeProvider("http://127.0.0.1:22973");
+    web3_1.web3.setCurrentNodeProvider(nodeProvider);
+    function randomP2PKHAddress(groupIndex) {
+        return web3_wallet_1.PrivateKeyWallet.Random(groupIndex, nodeProvider).address;
+    }
+    async function getALPHBalance(address) {
+        const balances = await nodeProvider.addresses.getAddressesAddressBalance(address);
+        return BigInt(balances.balance);
+    }
+    async function transferToTestAccount(address) {
+        const fromAccount = await (0, web3_test_1.getSigner)();
+        const transferResult = await (0, web3_test_1.transfer)(fromAccount, address, web3_1.ALPH_TOKEN_ID, web3_1.ONE_ALPH * 10n);
+        await (0, web3_1.waitForTxConfirmation)(transferResult.txId, 1, 1000);
+    }
     // enable this for integration test
-    it('should test node', async () => {
+    it('should transfer ALPH', async () => {
         const transport = await hw_transport_node_hid_1.default.open('');
         (0, logs_1.listen)((log) => console.log(log));
         const app = new src_1.default(transport);
-        const [account] = await app.getAccount(path);
-        console.log(`${JSON.stringify(account)}`);
-        const hash = Buffer.from(blakejs_1.default.blake2b(Buffer.from([0, 1, 2, 3, 4]), undefined, 32));
-        const signature = await app.signHash(path, hash);
-        console.log(signature);
-        expect((0, web3_1.transactionVerifySignature)(hash.toString('hex'), account.publicKey, signature)).toBe(true);
+        const [testAccount] = await app.getAccount(path);
+        await transferToTestAccount(testAccount.address);
+        const balance0 = await getALPHBalance(testAccount.address);
+        const buildTxResult = await nodeProvider.transactions.postTransactionsBuild({
+            fromPublicKey: testAccount.publicKey,
+            destinations: [
+                {
+                    address: randomP2PKHAddress(0),
+                    attoAlphAmount: (web3_1.ONE_ALPH * 2n).toString(),
+                },
+                {
+                    address: randomP2PKHAddress(0),
+                    attoAlphAmount: (web3_1.ONE_ALPH * 3n).toString(),
+                },
+            ]
+        });
+        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);
+        const gasFee = BigInt(buildTxResult.gasAmount) * BigInt(buildTxResult.gasPrice);
+        expect(balance1).toEqual(balance0 - gasFee - web3_1.ONE_ALPH * 5n);
         await app.close();
-    }, 100000);
+    }, 120000);
+    it('should transfer token', async () => {
+        const transport = await hw_transport_node_hid_1.default.open('');
+        (0, logs_1.listen)((log) => console.log(log));
+        const app = new src_1.default(transport);
+        const [testAccount] = await app.getAccount(path);
+        await transferToTestAccount(testAccount.address);
+        const tokenAmount = 2222222222222222222222222n;
+        const tokenInfo = await (0, web3_test_1.mintToken)(testAccount.address, tokenAmount);
+        const balances0 = await nodeProvider.addresses.getAddressesAddressBalance(testAccount.address);
+        const transferAmount = 2222222222222222222222222n / 2n;
+        const buildTxResult = await nodeProvider.transactions.postTransactionsBuild({
+            fromPublicKey: testAccount.publicKey,
+            destinations: [
+                {
+                    address: '1BmVCLrjttchZMW7i6df7mTdCKzHpy38bgDbVL1GqV6P7',
+                    attoAlphAmount: (web3_1.ONE_ALPH * 2n).toString(),
+                    tokens: [{ id: tokenInfo.contractId, amount: transferAmount.toString() }]
+                }
+            ]
+        });
+        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 balances1 = await nodeProvider.addresses.getAddressesAddressBalance(testAccount.address);
+        const gasFee = BigInt(buildTxResult.gasAmount) * BigInt(buildTxResult.gasPrice);
+        const alphBalance = BigInt(balances1.balance);
+        expect(alphBalance).toEqual(BigInt(balances0.balance) - gasFee - web3_1.ONE_ALPH * 2n);
+        const tokenBalance = balances1.tokenBalances.find((t) => t.id === tokenInfo.contractId);
+        expect(tokenBalance.amount).toEqual((tokenAmount - transferAmount).toString());
+        await app.close();
+    }, 120000);
+    it('should transfer to multisig address', async () => {
+        const transport = await hw_transport_node_hid_1.default.open('');
+        (0, logs_1.listen)((log) => console.log(log));
+        const app = new src_1.default(transport);
+        const [testAccount] = await app.getAccount(path);
+        await transferToTestAccount(testAccount.address);
+        const tokenAmount = 2222222222222222222222222n;
+        const tokenInfo = await (0, web3_test_1.mintToken)(testAccount.address, tokenAmount);
+        const balances0 = await nodeProvider.addresses.getAddressesAddressBalance(testAccount.address);
+        const transferAmount = 2222222222222222222222222n / 2n;
+        const multiSigAddress = 'X3KYVteDjsKuUP1F68Nv9iEUecnnkMuwjbC985AnA6MvciDFJ5bAUEso2Sd7sGrwZ5rfNLj7Rp4n9XjcyzDiZsrPxfhNkPYcDm3ce8pQ9QasNFByEufMi3QJ3cS9Vk6cTpqNcq';
+        const buildTxResult = await nodeProvider.transactions.postTransactionsBuild({
+            fromPublicKey: testAccount.publicKey,
+            destinations: [
+                {
+                    address: multiSigAddress,
+                    attoAlphAmount: (web3_1.ONE_ALPH * 2n).toString(),
+                    tokens: [{ id: tokenInfo.contractId, amount: transferAmount.toString() }]
+                }
+            ]
+        });
+        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 balances1 = await nodeProvider.addresses.getAddressesAddressBalance(testAccount.address);
+        const gasFee = BigInt(buildTxResult.gasAmount) * BigInt(buildTxResult.gasPrice);
+        const alphBalance = BigInt(balances1.balance);
+        expect(alphBalance).toEqual(BigInt(balances0.balance) - gasFee - web3_1.ONE_ALPH * 2n);
+        const tokenBalance = balances1.tokenBalances.find((t) => t.id === tokenInfo.contractId);
+        expect(tokenBalance.amount).toEqual((tokenAmount - transferAmount).toString());
+        await app.close();
+    }, 120000);
 });

package/dist/test/speculos.test.js

@@ -28,9 +28,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const hw_transport_node_speculos_1 = __importDefault(require("@ledgerhq/hw-transport-node-speculos"));
 const src_1 = __importStar(require("../src"));
-const blakejs_1 = __importDefault(require("blakejs"));
 const node_fetch_1 = __importDefault(require("node-fetch"));
 const web3_1 = require("@alephium/web3");
+const web3_test_1 = require("@alephium/web3-test");
+const web3_wallet_1 = require("@alephium/web3-wallet");
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -48,6 +49,8 @@ function getRandomInt(min, max) {
 }
 describe('sdk', () => {
     const apduPort = 9999;
+    const nodeProvider = new web3_1.NodeProvider("http://127.0.0.1:22973");
+    web3_1.web3.setCurrentNodeProvider(nodeProvider);
     let pathIndex;
     let path;
     beforeEach(() => {
@@ -58,7 +61,7 @@ describe('sdk', () => {
         const transport = await hw_transport_node_speculos_1.default.open({ apduPort });
         const app = new src_1.default(transport);
         const version = await app.getVersion();
-        expect(version).toBe('0.1.0');
+        expect(version).toBe('0.2.0');
         await app.close();
     });
     it('should get public key', async () => {
@@ -72,52 +75,343 @@ describe('sdk', () => {
     it('should get public key for group', async () => {
         const transport = await hw_transport_node_speculos_1.default.open({ apduPort });
         const app = new src_1.default(transport);
-        Array(src_1.GROUP_NUM).forEach(async (_, group) => {
+        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 hw_transport_node_speculos_1.default.open({ apduPort });
         const app = new src_1.default(transport);
-        Array(src_1.GROUP_NUM).forEach(async (_, group) => {
+        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 () => {
+    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);
+    }
+    async function clickAndApprove(times) {
+        for (let i = 0; i < times; i++) {
+            await pressButton('right');
+        }
+        await pressButton('both');
+    }
+    it('should transfer alph to p2pkh address', async () => {
         const transport = await hw_transport_node_speculos_1.default.open({ apduPort });
         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));
-        setTimeout(async () => {
-            await pressButton('both'); // review message
-            await pressButton('both'); // done review
-            await pressButton('right'); // select signing
-            await pressButton('both'); // done selection
-        }, 1000);
-        const signature = await app.signHash(path, hash);
-        console.log(signature);
+        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: '1BmVCLrjttchZMW7i6df7mTdCKzHpy38bgDbVL1GqV6P7',
+                    attoAlphAmount: (web3_1.ONE_ALPH * 3n).toString(),
+                },
+            ]
+        });
+        function approve(index) {
+            if (index >= 7)
+                return;
+            if (index >= 3) { // outputs and signature
+                setTimeout(async () => {
+                    await clickAndApprove(6);
+                    approve(index + 1);
+                }, 1000);
+            }
+            else {
+                setTimeout(async () => {
+                    await clickAndApprove(3);
+                    approve(index + 1);
+                }, 1000);
+            }
+        }
+        approve(0);
+        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();
-        expect((0, web3_1.transactionVerifySignature)(hash.toString('hex'), account.publicKey, signature)).toBe(true);
-    }, 10000);
-    it('should reject signing', async () => {
+    }, 120000);
+    it('should transfer alph to multisig address', async () => {
         const transport = await hw_transport_node_speculos_1.default.open({ apduPort });
         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));
-        setTimeout(async () => {
-            await pressButton('both'); // review message
-            await pressButton('both'); // done review
-            await pressButton('left'); // select signing
-            await pressButton('both'); // done selection
-        }, 1000);
-        await expect(app.signHash(path, hash)).rejects.toThrow();
+        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(),
+                },
+                {
+                    address: multiSigAddress,
+                    attoAlphAmount: (web3_1.ONE_ALPH * 3n).toString(),
+                },
+            ]
+        });
+        function approve(index) {
+            if (index >= 7)
+                return;
+            if (index == 3 || index == 4) { // multi-sig outputs
+                setTimeout(async () => {
+                    await clickAndApprove(11);
+                    approve(index + 1);
+                }, 1000);
+            }
+            else if (index > 4) { // change output and signature
+                setTimeout(async () => {
+                    await clickAndApprove(6);
+                    approve(index + 1);
+                }, 1000);
+            }
+            else {
+                setTimeout(async () => {
+                    await clickAndApprove(3);
+                    approve(index + 1);
+                }, 1000);
+            }
+        }
+        approve(0);
+        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 token to multisig address', async () => {
+        const transport = await hw_transport_node_speculos_1.default.open({ apduPort });
+        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",
+                        }
+                    ]
+                }
+            ]
+        });
+        function approve(index) {
+            if (index > 7)
+                return;
+            if (index <= 2) {
+                setTimeout(async () => {
+                    await clickAndApprove(3);
+                    approve(index + 1);
+                }, 1000);
+            }
+            else if (index === 3) { // multi-sig token output
+                setTimeout(async () => {
+                    await clickAndApprove(17);
+                    approve(index + 1);
+                }, 1000);
+            }
+            else if (index === 4) { // multi-sig alph output
+                setTimeout(async () => {
+                    await clickAndApprove(11);
+                    approve(index + 1);
+                }, 1000);
+            }
+            else if (index === 5) { // token change output
+                setTimeout(async () => {
+                    await clickAndApprove(12);
+                    approve(index + 1);
+                }, 1000);
+            }
+            else if (index >= 6) { // alph change output and signature
+                setTimeout(async () => {
+                    await clickAndApprove(6);
+                    approve(index + 1);
+                }, 1000);
+            }
+        }
+        approve(0);
+        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 hw_transport_node_speculos_1.default.open({ apduPort });
+        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(),
+                }
+            ]
+        });
+        function approve(index) {
+            if (index >= 6)
+                return;
+            if (index >= 3) { // outputs and signature
+                setTimeout(async () => {
+                    await clickAndApprove(6);
+                    approve(index + 1);
+                }, 1000);
+            }
+            else {
+                setTimeout(async () => {
+                    await clickAndApprove(3);
+                    approve(index + 1);
+                }, 1000);
+            }
+        }
+        approve(0);
+        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 transfer from different input addresses', async () => {
+        const transport = await hw_transport_node_speculos_1.default.open({ apduPort });
+        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: testAccount.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)
+        });
+        function approve(index) {
+            if (index > 6)
+                return;
+            if (index === 3 || index === 4) { // inputs
+                setTimeout(async () => {
+                    await clickAndApprove(5);
+                    approve(index + 1);
+                }, 1000);
+            }
+            else if (index >= 5) { // outputs and tx id
+                setTimeout(async () => {
+                    await clickAndApprove(6);
+                    approve(index + 1);
+                }, 1000);
+            }
+            else {
+                setTimeout(async () => {
+                    await clickAndApprove(3);
+                    approve(index + 1);
+                }, 1000);
+            }
+        }
+        approve(0);
+        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(testAccount.address);
+        expect(balance).toEqual(web3_1.ONE_ALPH * 3n);
         await app.close();
-    }, 10000);
+    }, 120000);
 });