@alephium/ledger-app 0.5.1 → 0.6.0

package/dist/src/ledger-app.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="node" />
 import { Account, KeyType } from '@alephium/web3';
 import Transport from '@ledgerhq/hw-transport';
-import { TokenMetadata } from './types';
 export declare const CLA = 128;
 export declare enum INS {
     GET_VERSION = 0,
@@ -11,12 +10,12 @@ export declare enum INS {
 }
 export declare const GROUP_NUM = 4;
 export declare const HASH_LEN = 32;
-export default class AlephiumApp {
+export declare class AlephiumApp {
     readonly transport: Transport;
     constructor(transport: Transport);
     close(): Promise<void>;
     getVersion(): Promise<string>;
     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, tokenMetadata?: TokenMetadata[]): Promise<string>;
+    signUnsignedTx(path: string, unsignedTx: Buffer): Promise<string>;
 }

package/dist/src/ledger-app.js

@@ -23,11 +23,14 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.HASH_LEN = exports.GROUP_NUM = exports.INS = exports.CLA = void 0;
+exports.AlephiumApp = exports.HASH_LEN = exports.GROUP_NUM = exports.INS = exports.CLA = void 0;
 const web3_1 = require("@alephium/web3");
 const hw_transport_1 = require("@ledgerhq/hw-transport");
 const serde = __importStar(require("./serde"));
 const elliptic_1 = require("elliptic");
+const types_1 = require("./types");
+const tx_encoder_1 = require("./tx-encoder");
+const merkle_1 = require("./merkle");
 const ec = new elliptic_1.ec('secp256k1');
 exports.CLA = 0x80;
 var INS;
@@ -39,8 +42,6 @@ var INS;
 })(INS = exports.INS || (exports.INS = {}));
 exports.GROUP_NUM = 4;
 exports.HASH_LEN = 32;
-// The maximum payload size is 255: https://github.com/LedgerHQ/ledger-live/blob/develop/libs/ledgerjs/packages/hw-transport/src/Transport.ts#L261
-const MAX_PAYLOAD_SIZE = 255;
 class AlephiumApp {
     constructor(transport) {
         this.transport = transport;
@@ -80,30 +81,42 @@ class AlephiumApp {
         console.log(`response ${response.length} - ${response.toString('hex')}`);
         return decodeSignature(response);
     }
-    async signUnsignedTx(path, unsignedTx, tokenMetadata = []) {
+    async signUnsignedTx(path, unsignedTx) {
         console.log(`unsigned tx size: ${unsignedTx.length}`);
-        const encodedPath = serde.serializePath(path);
-        const encodedTokenMetadata = serde.serializeTokenMetadata(tokenMetadata);
-        const firstFrameTxLength = MAX_PAYLOAD_SIZE - 20 - encodedTokenMetadata.length;
-        const txData = unsignedTx.slice(0, unsignedTx.length > firstFrameTxLength ? firstFrameTxLength : unsignedTx.length);
-        const data = Buffer.concat([encodedPath, encodedTokenMetadata, 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 frameLength = MAX_PAYLOAD_SIZE;
-        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;
+        const tokenMetadata = getTokenMetadata(unsignedTx);
+        serde.checkTokenMetadata(tokenMetadata);
+        const tokenMetadataFrames = (0, tx_encoder_1.encodeTokenMetadata)(tokenMetadata);
+        const txFrames = (0, tx_encoder_1.encodeUnsignedTx)(path, unsignedTx);
+        const allFrames = [...tokenMetadataFrames, ...txFrames];
+        let response = undefined;
+        for (const frame of allFrames) {
+            response = await this.transport.send(exports.CLA, INS.SIGN_TX, frame.p1, frame.p2, frame.data, [hw_transport_1.StatusCodes.OK]);
         }
         return decodeSignature(response);
     }
 }
-exports.default = AlephiumApp;
+exports.AlephiumApp = AlephiumApp;
+function getTokenMetadata(unsignedTx) {
+    const result = [];
+    const outputs = web3_1.codec.unsignedTxCodec.decode(unsignedTx).fixedOutputs;
+    outputs.forEach((output) => {
+        output.tokens.forEach((t) => {
+            const tokenIdHex = (0, web3_1.binToHex)(t.tokenId);
+            if (result.find((t) => isTokenIdEqual(t.tokenId, tokenIdHex)) !== undefined) {
+                return;
+            }
+            const metadata = merkle_1.merkleTokens.find((t) => isTokenIdEqual(t.tokenId, tokenIdHex));
+            if (metadata !== undefined && metadata.symbol.length <= types_1.MAX_TOKEN_SYMBOL_LENGTH) {
+                result.push(metadata);
+            }
+        });
+    });
+    const size = Math.min(result.length, types_1.MAX_TOKEN_SIZE);
+    return result.slice(0, size);
+}
+function isTokenIdEqual(a, b) {
+    return a.toLowerCase() === b.toLowerCase();
+}
 function decodeSignature(response) {
     // Decode signature: https://bitcoin.stackexchange.com/a/12556
     const rLen = response.slice(3, 4)[0];

package/dist/src/merkle.d.ts

@@ -0,0 +1,9 @@
+import { TokenMetadata } from './types';
+export declare const merkleTokens: TokenMetadata[];
+export declare function hashPair(a: Uint8Array, b: Uint8Array): Uint8Array;
+export declare function generateProofs(): {
+    proofs: Record<string, string>;
+    root: string;
+};
+export declare const tokenMerkleRoot: Uint8Array;
+export declare const tokenMerkleProofs: Record<string, string>;

package/dist/src/merkle.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenMerkleProofs = exports.tokenMerkleRoot = exports.generateProofs = exports.hashPair = exports.merkleTokens = void 0;
+const web3_1 = require("@alephium/web3");
+const token_json_1 = __importDefault(require("../merkle-tree/token.json"));
+const proofs_json_1 = __importDefault(require("../merkle-tree/proofs.json"));
+const serde_1 = require("./serde");
+const blakejs_1 = require("blakejs");
+exports.merkleTokens = token_json_1.default.tokens.map((token) => {
+    return {
+        version: 0,
+        tokenId: token.id,
+        symbol: token.symbol,
+        decimals: token.decimals
+    };
+});
+function hashPair(a, b) {
+    return (0, blakejs_1.blake2b)(Buffer.concat([a, b].sort(Buffer.compare)), undefined, 32);
+}
+exports.hashPair = hashPair;
+function generateMerkleTree(tokens) {
+    let level = tokens.map((token) => (0, blakejs_1.blake2b)((0, serde_1.serializeSingleTokenMetadata)(token), undefined, 32));
+    const tree = [];
+    while (level.length > 1) {
+        tree.push(level);
+        level = level.reduce((acc, _, i, arr) => {
+            if (i % 2 === 0) {
+                acc.push(i + 1 < arr.length ? hashPair(arr[i], arr[i + 1]) : arr[i]);
+            }
+            return acc;
+        }, []);
+    }
+    tree.push(level); // Root
+    return tree;
+}
+function generateProofs() {
+    const tree = generateMerkleTree(exports.merkleTokens);
+    const proofs = exports.merkleTokens.reduce((acc, token, tokenIndex) => {
+        const proof = tree.slice(0, -1).reduce((proofAcc, level, levelIndex) => {
+            const index = Math.floor(tokenIndex / 2 ** levelIndex);
+            const pairIndex = index % 2 === 0 ? index + 1 : index - 1;
+            const siblingOrUncle = level[pairIndex];
+            if (siblingOrUncle) {
+                proofAcc.push(siblingOrUncle);
+            }
+            return proofAcc;
+        }, []);
+        acc[token.tokenId] = proof.map((hash) => (0, web3_1.binToHex)(hash)).join('');
+        return acc;
+    }, {});
+    console.log('root', tree[tree.length - 1].map((hash) => (0, web3_1.binToHex)(hash)).join(''));
+    return { proofs, root: (0, web3_1.binToHex)(tree[tree.length - 1][0]) };
+}
+exports.generateProofs = generateProofs;
+exports.tokenMerkleRoot = (0, web3_1.hexToBinUnsafe)('b3380866c595544781e9da0ccd79399de8878abfb0bf40545b57a287387d419d');
+exports.tokenMerkleProofs = proofs_json_1.default;

package/dist/src/serde.d.ts

@@ -1,7 +1,9 @@
 /// <reference types="node" />
-import { TokenMetadata } from "./types";
+import { TokenMetadata } from './types';
 export declare const TRUE = 16;
 export declare const FALSE = 0;
 export declare function splitPath(path: string): number[];
 export declare function serializePath(path: string): Buffer;
+export declare function checkTokenMetadata(tokens: TokenMetadata[]): void;
+export declare function serializeSingleTokenMetadata(metadata: TokenMetadata): Buffer;
 export declare function serializeTokenMetadata(tokens: TokenMetadata[]): Buffer;

package/dist/src/serde.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.serializeTokenMetadata = exports.serializePath = exports.splitPath = exports.FALSE = exports.TRUE = void 0;
+exports.serializeTokenMetadata = exports.serializeSingleTokenMetadata = exports.checkTokenMetadata = exports.serializePath = exports.splitPath = exports.FALSE = exports.TRUE = void 0;
 const web3_1 = require("@alephium/web3");
 const types_1 = require("./types");
 exports.TRUE = 0x10;
@@ -39,7 +39,7 @@ function symbolToBytes(symbol) {
     }
     return buffer;
 }
-function check(tokens) {
+function checkTokenMetadata(tokens) {
     const hasDuplicate = tokens.some((token, index) => index !== tokens.findIndex((t) => t.tokenId === token.tokenId));
     if (hasDuplicate) {
         throw new Error(`There are duplicate tokens`);
@@ -56,22 +56,24 @@ function check(tokens) {
         throw new Error(`The token size exceeds maximum size`);
     }
 }
+exports.checkTokenMetadata = checkTokenMetadata;
+function serializeSingleTokenMetadata(metadata) {
+    const symbolBytes = symbolToBytes(metadata.symbol);
+    const buffer = Buffer.concat([
+        Buffer.from([metadata.version]),
+        Buffer.from(metadata.tokenId, 'hex'),
+        symbolBytes,
+        Buffer.from([metadata.decimals]),
+    ]);
+    if (buffer.length !== types_1.TOKEN_METADATA_SIZE) {
+        throw new Error(`Invalid token metadata: ${metadata}`);
+    }
+    return buffer;
+}
+exports.serializeSingleTokenMetadata = serializeSingleTokenMetadata;
 function serializeTokenMetadata(tokens) {
-    check(tokens);
-    const array = tokens
-        .map((metadata) => {
-        const symbolBytes = symbolToBytes(metadata.symbol);
-        const buffer = Buffer.concat([
-            Buffer.from([metadata.version]),
-            Buffer.from(metadata.tokenId, 'hex'),
-            symbolBytes,
-            Buffer.from([metadata.decimals])
-        ]);
-        if (buffer.length !== types_1.TOKEN_METADATA_SIZE) {
-            throw new Error(`Invalid token metadata: ${metadata}`);
-        }
-        return buffer;
-    });
+    checkTokenMetadata(tokens);
+    const array = tokens.map((metadata) => serializeSingleTokenMetadata(metadata));
     return Buffer.concat([Buffer.from([array.length]), ...array]);
 }
 exports.serializeTokenMetadata = serializeTokenMetadata;

package/dist/src/tx-encoder.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="node" />
+import { TokenMetadata } from "./types";
+export interface Frame {
+    p1: number;
+    p2: number;
+    data: Buffer;
+}
+export declare function encodeTokenMetadata(tokenMetadata: TokenMetadata[]): Frame[];
+export declare function encodeProofLength(length: number): Uint8Array;
+export declare function encodeUnsignedTx(path: string, unsignedTx: Buffer): Frame[];
+export declare function assert(condition: boolean, msg: string): void;

package/dist/src/tx-encoder.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assert = exports.encodeUnsignedTx = exports.encodeProofLength = exports.encodeTokenMetadata = void 0;
+const merkle_1 = require("./merkle");
+const serde_1 = require("./serde");
+const types_1 = require("./types");
+function encodeTokenMetadata(tokenMetadata) {
+    const frames = tokenMetadata.flatMap((metadata, index) => {
+        const isFirstToken = index === 0;
+        const firstFramePrefix = isFirstToken ? Buffer.from([tokenMetadata.length]) : Buffer.alloc(0);
+        const buffers = encodeTokenAndProof(metadata, firstFramePrefix);
+        if (buffers.length === 0)
+            return [];
+        assert(buffers.every((buffer) => buffer.length <= types_1.MAX_PAYLOAD_SIZE), 'Invalid token frame size');
+        const frames = [];
+        const firstFrameP2 = isFirstToken ? 0 : 1;
+        frames.push({ p1: 0, p2: firstFrameP2, data: buffers[0] });
+        buffers.slice(1).forEach((data) => frames.push({ p1: 0, p2: 2, data }));
+        return frames;
+    });
+    if (frames.length === 0) {
+        return [{ p1: 0, p2: 0, data: Buffer.from([0]) }];
+    }
+    else {
+        return frames;
+    }
+}
+exports.encodeTokenMetadata = encodeTokenMetadata;
+function encodeTokenAndProof(tokenMetadata, firstFramePrefix) {
+    const proof = merkle_1.tokenMerkleProofs[tokenMetadata.tokenId];
+    if (proof === undefined)
+        return [];
+    const proofBytes = Buffer.from(proof, 'hex');
+    const encodedProofLength = encodeProofLength(proofBytes.length);
+    const encodedTokenMetadata = (0, serde_1.serializeSingleTokenMetadata)(tokenMetadata);
+    const firstFrameRemainSize = types_1.MAX_PAYLOAD_SIZE - encodedTokenMetadata.length - encodedProofLength.length - firstFramePrefix.length;
+    const firstFrameProofSize = Math.floor(firstFrameRemainSize / 32) * 32;
+    if (firstFrameProofSize >= proofBytes.length) {
+        return [Buffer.concat([firstFramePrefix, encodedTokenMetadata, encodedProofLength, proofBytes])];
+    }
+    const firstFrameProof = proofBytes.slice(0, firstFrameProofSize);
+    const result = [Buffer.concat([firstFramePrefix, encodedTokenMetadata, encodedProofLength, firstFrameProof])];
+    let from_index = firstFrameProofSize;
+    while (from_index < proofBytes.length) {
+        const remainProofLength = proofBytes.length - from_index;
+        const frameProofSize = Math.min(Math.floor(types_1.MAX_PAYLOAD_SIZE / 32) * 32, remainProofLength);
+        const frameProof = proofBytes.slice(from_index, from_index + frameProofSize);
+        from_index += frameProofSize;
+        result.push(frameProof);
+    }
+    return result;
+}
+function encodeProofLength(length) {
+    assert((length % 32 === 0) && (length > 0 && length < 0xffff), 'Invalid token proof size');
+    const buffer = Buffer.alloc(2);
+    buffer.writeUint16BE(length);
+    return buffer;
+}
+exports.encodeProofLength = encodeProofLength;
+function encodeUnsignedTx(path, unsignedTx) {
+    const encodedPath = (0, serde_1.serializePath)(path);
+    const firstFrameTxLength = types_1.MAX_PAYLOAD_SIZE - 20;
+    if (firstFrameTxLength >= unsignedTx.length) {
+        return [{ p1: 1, p2: 0, data: Buffer.concat([encodedPath, unsignedTx]) }];
+    }
+    const firstFrameTxData = unsignedTx.slice(0, firstFrameTxLength);
+    const frames = [{ p1: 1, p2: 0, data: Buffer.concat([encodedPath, firstFrameTxData]) }];
+    let fromIndex = firstFrameTxLength;
+    while (fromIndex < unsignedTx.length) {
+        const remain = unsignedTx.length - fromIndex;
+        const frameTxLength = Math.min(types_1.MAX_PAYLOAD_SIZE, remain);
+        frames.push({ p1: 1, p2: 1, data: unsignedTx.slice(fromIndex, fromIndex + frameTxLength) });
+        fromIndex += frameTxLength;
+    }
+    return frames;
+}
+exports.encodeUnsignedTx = encodeUnsignedTx;
+function assert(condition, msg) {
+    if (!condition)
+        throw Error(msg);
+}
+exports.assert = assert;

package/dist/src/types.d.ts

@@ -1,6 +1,7 @@
 export declare const MAX_TOKEN_SIZE = 5;
 export declare const MAX_TOKEN_SYMBOL_LENGTH = 12;
 export declare const TOKEN_METADATA_SIZE = 46;
+export declare const MAX_PAYLOAD_SIZE = 255;
 export interface TokenMetadata {
     version: number;
     tokenId: string;

package/dist/src/types.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TOKEN_METADATA_SIZE = exports.MAX_TOKEN_SYMBOL_LENGTH = exports.MAX_TOKEN_SIZE = void 0;
+exports.MAX_PAYLOAD_SIZE = exports.TOKEN_METADATA_SIZE = exports.MAX_TOKEN_SYMBOL_LENGTH = exports.MAX_TOKEN_SIZE = void 0;
 exports.MAX_TOKEN_SIZE = 5;
 exports.MAX_TOKEN_SYMBOL_LENGTH = 12;
 exports.TOKEN_METADATA_SIZE = 46;
+// The maximum payload size is 255: https://github.com/LedgerHQ/ledger-live/blob/develop/libs/ledgerjs/packages/hw-transport/src/Transport.ts#L261
+exports.MAX_PAYLOAD_SIZE = 255;

package/dist/test/merkle.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/merkle.test.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const merkle_1 = require("../src/merkle");
+const serde_1 = require("../src/serde");
+const blakejs_1 = require("blakejs");
+describe('Merkle', () => {
+    it('should verify proofs', () => {
+        for (const token of merkle_1.merkleTokens) {
+            const proof = merkle_1.tokenMerkleProofs[token.tokenId];
+            let currentHash = (0, blakejs_1.blake2b)((0, serde_1.serializeSingleTokenMetadata)(token), undefined, 32);
+            for (let i = 0; i < proof.length; i += 64) {
+                const sibling = proof.slice(i, i + 64);
+                currentHash = (0, merkle_1.hashPair)(currentHash, Buffer.from(sibling, 'hex'));
+            }
+            expect(JSON.stringify(currentHash)).toBe(JSON.stringify(merkle_1.tokenMerkleRoot));
+        }
+    });
+});

package/dist/test/tx-encoder.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/tx-encoder.test.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const merkle_1 = require("../src/merkle");
+const tx_encoder_1 = require("../src/tx-encoder");
+const src_1 = require("../src");
+const serde_1 = require("../src/serde");
+const crypto_1 = require("crypto");
+describe('TxEncoder', () => {
+    function shuffle(array) {
+        for (let i = array.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [array[i], array[j]] = [array[j], array[i]];
+        }
+        return array;
+    }
+    function getFrameSize(proofLength) {
+        if (proofLength <= 192)
+            return 1;
+        if (proofLength <= 416)
+            return 2;
+        if (proofLength <= 640)
+            return 3;
+        throw Error(`Invalid proof length: ${proofLength}`);
+    }
+    it('should encode token metadata and proof', () => {
+        const frames0 = (0, tx_encoder_1.encodeTokenMetadata)([]);
+        expect(frames0).toEqual([{ p1: 0, p2: 0, data: Buffer.from([0]) }]);
+        const tokenSize = Math.floor(Math.random() * src_1.MAX_TOKEN_SIZE) + 1;
+        (0, tx_encoder_1.assert)(tokenSize >= 1 && tokenSize <= 5, 'Invalid token size');
+        const tokens = shuffle(Object.entries(merkle_1.tokenMerkleProofs));
+        const selectedTokens = tokens.slice(0, tokenSize);
+        const tokenMetadatas = selectedTokens.map(([tokenId]) => merkle_1.merkleTokens.find((t) => t.tokenId === tokenId));
+        const frames = (0, tx_encoder_1.encodeTokenMetadata)(tokenMetadatas);
+        const tokenAndProofs = Buffer.concat(frames.map((frame, index) => index === 0 ? frame.data.slice(1) : frame.data));
+        const expected = Buffer.concat(tokenMetadatas.map((metadata, index) => {
+            const proof = Buffer.from(selectedTokens[index][1], 'hex');
+            const encodedProofLength = (0, tx_encoder_1.encodeProofLength)(proof.length);
+            const encodedTokenMetadata = (0, serde_1.serializeSingleTokenMetadata)(metadata);
+            return Buffer.concat([encodedTokenMetadata, encodedProofLength, proof]);
+        }));
+        expect(tokenAndProofs).toEqual(expected);
+        let frameIndex = 0;
+        tokenMetadatas.forEach((_, index) => {
+            const proof = Buffer.from(selectedTokens[index][1], 'hex');
+            const isFirstToken = index === 0;
+            const prefixLength = isFirstToken ? 1 + src_1.TOKEN_METADATA_SIZE + 2 : src_1.TOKEN_METADATA_SIZE + 2;
+            const tokenFrames = frames.slice(frameIndex, frameIndex + getFrameSize(proof.length));
+            const firstFrameP2 = isFirstToken ? 0 : 1;
+            expect(tokenFrames[0].p1).toEqual(0);
+            expect(tokenFrames[0].p2).toEqual(firstFrameP2);
+            tokenFrames.slice(1).forEach((frame) => {
+                expect(frame.p1).toEqual(0);
+                expect(frame.p2).toEqual(2);
+            });
+            const expectedProof = Buffer.concat([tokenFrames[0].data.slice(prefixLength), ...tokenFrames.slice(1).map((f) => f.data)]);
+            expect(proof).toEqual(expectedProof);
+            frameIndex += tokenFrames.length;
+        });
+    });
+    it('should encode tx', () => {
+        const path = `m/44'/1234'/0'/0/0`;
+        const encodedPath = (0, serde_1.serializePath)(path);
+        const unsignedTx0 = (0, crypto_1.randomBytes)(200);
+        const frames0 = (0, tx_encoder_1.encodeUnsignedTx)(path, unsignedTx0);
+        expect(frames0).toEqual([{ p1: 1, p2: 0, data: Buffer.concat([encodedPath, unsignedTx0]) }]);
+        const unsignedTx1 = (0, crypto_1.randomBytes)(250);
+        const frames1 = (0, tx_encoder_1.encodeUnsignedTx)(path, unsignedTx1);
+        expect(frames1).toEqual([
+            { p1: 1, p2: 0, data: Buffer.concat([encodedPath, unsignedTx1.slice(0, src_1.MAX_PAYLOAD_SIZE - 20)]) },
+            { p1: 1, p2: 1, data: unsignedTx1.slice(src_1.MAX_PAYLOAD_SIZE - 20) },
+        ]);
+    });
+});

package/dist/test/utils.d.ts

@@ -2,14 +2,17 @@ import Transport from '@ledgerhq/hw-transport';
 export declare enum OutputType {
     Base = 0,
     Multisig = 1,
-    Token = 2,
-    BaseAndToken = 3,
-    MultisigAndToken = 4
+    Nanos10 = 2,
+    Nanos11 = 3,
+    Token = 4,
+    BaseAndToken = 5,
+    MultisigAndToken = 6
 }
 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 isNanos(): boolean;
 export declare function skipBlindSigningWarning(): void;
 export declare function enableBlindSigning(): Promise<void>;
 export declare function getRandomInt(min: number, max: number): number;

package/dist/test/utils.js

@@ -3,7 +3,7 @@ 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;
+exports.createTransport = exports.needToAutoApprove = exports.getRandomInt = exports.enableBlindSigning = exports.skipBlindSigningWarning = exports.isNanos = 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");
@@ -29,13 +29,17 @@ var OutputType;
 (function (OutputType) {
     OutputType[OutputType["Base"] = 0] = "Base";
     OutputType[OutputType["Multisig"] = 1] = "Multisig";
-    OutputType[OutputType["Token"] = 2] = "Token";
-    OutputType[OutputType["BaseAndToken"] = 3] = "BaseAndToken";
-    OutputType[OutputType["MultisigAndToken"] = 4] = "MultisigAndToken";
+    OutputType[OutputType["Nanos10"] = 2] = "Nanos10";
+    OutputType[OutputType["Nanos11"] = 3] = "Nanos11";
+    OutputType[OutputType["Token"] = 4] = "Token";
+    OutputType[OutputType["BaseAndToken"] = 5] = "BaseAndToken";
+    OutputType[OutputType["MultisigAndToken"] = 6] = "MultisigAndToken";
 })(OutputType = exports.OutputType || (exports.OutputType = {}));
 const NanosClickTable = new Map([
     [OutputType.Base, 5],
     [OutputType.Multisig, 10],
+    [OutputType.Nanos10, 10],
+    [OutputType.Nanos11, 11],
     [OutputType.Token, 11],
     [OutputType.BaseAndToken, 12],
     [OutputType.MultisigAndToken, 16],
@@ -123,6 +127,7 @@ async function touch(outputs, hasExternalInputs) {
 async function approveTx(outputs, hasExternalInputs = false) {
     if (!needToAutoApprove())
         return;
+    await (0, web3_1.sleep)(2000);
     const isSelfTransfer = outputs.length === 0 && !hasExternalInputs;
     if (isSelfTransfer) {
         if (isStaxOrFlex()) {
@@ -172,6 +177,10 @@ exports.approveAddress = approveAddress;
 function isStaxOrFlex() {
     return !getModel().startsWith('nano');
 }
+function isNanos() {
+    return getModel() === 'nanos';
+}
+exports.isNanos = isNanos;
 function skipBlindSigningWarning() {
     if (!needToAutoApprove())
         return;