@ton-community/ton-ledger 4.0.0

package/CHANGELOG.md

@@ -0,0 +1,31 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [4.0.0] - 2023-06-09
+
+### Added
+
+- Added payload types for NFT and Jetton transfers
+- Added TON Connect 2.0 address proof request
+
+### Removed
+
+- Removed old payload types except for comment and unsafe
+
+### Changed
+
+- Updated dependencies
+- Changed APDU format to be the same as the latest embedded app version (breaking change)
+
+## [3.0.0] - 2023-01-08
+
+### Changed
+
+- Migration to `ton-core`
+
+## [2.3.2]
+
+- Update documentation

package/README.md

@@ -0,0 +1,148 @@
+# TON Ledger Library
+
+This library allows you to connect to a ledger device and with with TON from browser (only Chrome), NodeJS and React Native.
+
+## How to install
+
+To add library to your project execute: 
+
+```bash
+yarn add ton-ledger
+```
+
+## Connecting to a Device
+
+First you need to select transport library for you environment.
+
+Browser:
+* [@ledgerhq/hw-transport-webhid](https://www.npmjs.com/package/@ledgerhq/hw-transport-webhid)
+* [@ledgerhq/hw-transport-webusb](https://www.npmjs.com/package/@ledgerhq/hw-transport-webusb)
+
+Node:
+* [@ledgerhq/hw-transport-node-ble](https://www.npmjs.com/package/@ledgerhq/hw-transport-node-ble)
+* [@ledgerhq/hw-transport-node-hid](https://www.npmjs.com/package/@ledgerhq/hw-transport-node-hid)
+* [@ledgerhq/hw-transport-node-hid-noevents](https://www.npmjs.com/package/@ledgerhq/hw-transport-node-hid-noevents)
+* [@ledgerhq/hw-transport-node-hid-singleton](https://www.npmjs.com/package/@ledgerhq/hw-transport-node-hid-singleton)
+
+React Native:
+* [@ledgerhq/hw-transport-web-ble](https://www.npmjs.com/package/@ledgerhq/hw-transport-web-ble)
+
+After connecting to a device create a TonTransport instance:
+```typescript
+import { TonTransport } from 'ton-ledger';
+let transport = new TonTransport(device);
+```
+
+## Deriviation Path
+
+For hardware wallets you need to specify deriviation path of your account for TON it is specified as:
+
+```typescript
+function pathForAccount(testnet: boolean, workchain: number, account: number) {
+    let network = testnet ? 1 : 0;
+    let chain = workchain === -1 ? 255 : 0;
+    return [44, 607, network, chain, account, 0]; // Last zero is reserved for alternative wallet contracts
+}
+```
+
+You can specify any path that starts with `[44, 607]`, but it could be incompatible with other apps.
+
+## Get an Address and Public Key
+
+To get an address without confimration on device you can perform next things:
+
+```typescript
+let testnet = true;
+let workchain = 0;
+let accountIndex = 0;
+let bounceable = false;
+let path = pathForAccount(testnet, workchain, accountIndex);
+let response = await transport.getAddress(path, { chain, bounceable, testOnly: testnet });
+let publiKey: Buffer = response.publicKey;
+let address: string = response.address;
+```
+
+## Validate Address
+
+The same as getting address, but returns address and key only when user confirms that address on the screen is correct. This method usually used after the non-confirming one and displaying address in dApp ad then requesting address validation.
+
+```typescript
+let testnet = true;
+let workchain = 0;
+let accountIndex = 0;
+let bounceable = false;
+let path = pathForAccount(testnet, workchain, accountIndex);
+let response = await transport.validateAddress(path, { chain, bounceable, testOnly: testnet });
+let publiKey: Buffer = response.publicKey;
+let address: string = response.address;
+```
+
+## Sign simple transaction
+
+Ledger Nanoapp works with Wallet v4 for now, we recommend you to continue to use it:
+
+```typescript
+import { WalletV4Contract, WalletV4Source } from 'ton';
+import { TonPayloadFormat } from 'ton-ledger';
+import { TonClient, Address, SendMode, toNano } from 'ton-core';
+
+let client = new TonClient({ endpoint: 'https://toncenter.com/api/v2/jsonRPC' });
+let source = WalletV4Source.create({ workchain: 0, publicKey: deviceAddress.publicKey });
+let contract = new WalletV4Contract(address, source);
+let seqno = await contract.getSeqNo();
+
+// Parameters
+let path: number[]; // Account path from above
+let to: Address = Address.parse('...'); // Destination
+let amount: bigint = toNano('100'); // Send 100 TON
+let sendMode = SendMode.IGNORE_ERRORS | SendMode.PAY_GAS_SEPARATLY;
+let timeout = Math.floor((Date.now() / 1000) + 60);
+let bounce = false;
+let payload: TonPayloadFormat | null = null; // See below
+
+// Signing on device
+let signed = await transport.signTransaction(path, {
+    to,
+    sendMode,
+    amount,
+    seqno,
+    timeout: Math.floor((Date.now() / 1000) + 60),
+    bounce,
+    payload: payload ? payload : undefined
+});
+
+// Send transaction to the network
+await c.sendExternalMessage(contract, signed);
+
+```
+
+## Payload formats
+
+Usually you want to perform transactions with some payload. Ledger's NanoApp currently supports 2 stable commands, all other are outdated or unstable:
+
+### Transaction with a comment
+Comments are limited to ASCII-only symbols and 127 letters. Anything above would be automatically downgraded to Blind Signing Mode that you want to avoid at all cost.
+
+```typescript
+let payload: TonPayloadFormat = {
+    type: 'comment',
+    text: 'Deposit'
+};
+```
+
+### Unsafe with custom payload
+
+This payload allows you to send arbitrary message, this is considered as Blind Signing Mode and only hash of your transaction would be shown to a user.
+
+```typescript
+let cell: Cell = ...
+let message = new CellMessage(cell);
+let payload: TonPayloadFormat = {
+    type: 'unsafe',
+    message
+};
+```
+
+# License
+
+MIT

package/dist/TonTransport.d.ts

@@ -0,0 +1,74 @@
+/// <reference types="node" />
+import Transport from "@ledgerhq/hw-transport";
+import { Address, Cell, SendMode, StateInit } from "ton-core";
+export type TonPayloadFormat = {
+    type: 'unsafe';
+    message: Cell;
+} | {
+    type: 'comment';
+    text: string;
+} | {
+    type: 'jetton-transfer';
+    queryId: bigint | null;
+    amount: bigint;
+    decimals: number;
+    ticker: string;
+    destination: Address;
+    responseDestination: Address;
+    customPayload: Cell | null;
+    forwardAmount: bigint;
+    forwardPayload: Cell | null;
+} | {
+    type: 'nft-transfer';
+    queryId: bigint | null;
+    newOwner: Address;
+    responseDestination: Address;
+    customPayload: Cell | null;
+    forwardAmount: bigint;
+    forwardPayload: Cell | null;
+};
+export declare class TonTransport {
+    #private;
+    readonly transport: Transport;
+    constructor(transport: Transport);
+    isAppOpen(): Promise<boolean>;
+    getVersion(): Promise<string>;
+    getAddress(path: number[], opts?: {
+        testOnly?: boolean;
+        bounceable?: boolean;
+        chain?: number;
+    }): Promise<{
+        address: string;
+        publicKey: Buffer;
+    }>;
+    validateAddress(path: number[], opts?: {
+        testOnly?: boolean;
+        bounceable?: boolean;
+        chain?: number;
+    }): Promise<{
+        address: string;
+        publicKey: Buffer;
+    }>;
+    getAddressProof(path: number[], params: {
+        domain: string;
+        timestamp: number;
+        payload: Buffer;
+    }, opts?: {
+        testOnly?: boolean;
+        bounceable?: boolean;
+        chain?: number;
+    }): Promise<{
+        signature: Buffer;
+        hash: Buffer;
+    }>;
+    signTransaction: (path: number[], transaction: {
+        to: Address;
+        sendMode: SendMode;
+        seqno: number;
+        timeout: number;
+        bounce: boolean;
+        amount: bigint;
+        stateInit?: StateInit;
+        payload?: TonPayloadFormat;
+    }) => Promise<Cell>;
+}

package/dist/TonTransport.js

@@ -0,0 +1,408 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonTransport = void 0;
+const ton_core_1 = require("ton-core");
+const ton_crypto_1 = require("ton-crypto");
+const teslabot_1 = require("teslabot");
+const ledgerWriter_1 = require("./utils/ledgerWriter");
+const getInit_1 = require("./utils/getInit");
+const LEDGER_SYSTEM = 0xB0;
+const LEDGER_CLA = 0xe0;
+const INS_VERSION = 0x03;
+const INS_ADDRESS = 0x05;
+const INS_PROOF = 0x08;
+function chunks(buf, n) {
+    const nc = Math.ceil(buf.length / n);
+    const cs = [];
+    for (let i = 0; i < nc; i++) {
+        cs.push(buf.subarray(i * n, (i + 1) * n));
+    }
+    return cs;
+}
+class TonTransport {
+    transport;
+    #lock = new teslabot_1.AsyncLock();
+    constructor(transport) {
+        this.transport = transport;
+    }
+    //
+    // Apps
+    //
+    async #getCurrentApp() {
+        return this.#lock.inLock(async () => {
+            let r = await this.transport.send(LEDGER_SYSTEM, 0x01, 0x00, 0x00, undefined, [0x9000]);
+            let data = r.slice(0, r.length - 2);
+            if (data[0] !== 0x01) {
+                throw Error('Invalid response');
+            }
+            let nameLength = data[1];
+            let name = data.slice(2, 2 + nameLength).toString();
+            let versionLength = data[2 + nameLength];
+            let version = data.slice(3 + nameLength, 3 + nameLength + versionLength).toString();
+            return { name, version };
+        });
+    }
+    async isAppOpen() {
+        return (await this.#getCurrentApp()).name === 'TON';
+    }
+    async getVersion() {
+        let loaded = await this.#doRequest(INS_VERSION, 0x00, 0x00, Buffer.alloc(0));
+        const [major, minor, patch] = loaded;
+        return `${major}.${minor}.${patch}`;
+    }
+    //
+    // Operations
+    //
+    async getAddress(path, opts) {
+        // Check path
+        validatePath(path);
+        // Resolve flags
+        let bounceable = true;
+        let chain = 0;
+        let test = false;
+        let flags = 0x00;
+        if (opts && opts.bounceable !== undefined && !opts.bounceable) {
+            flags |= 0x01;
+            bounceable = false;
+        }
+        if (opts && opts.testOnly) {
+            flags |= 0x02;
+            test = true;
+        }
+        if (opts && opts.chain !== undefined) {
+            if (opts.chain !== 0 && opts.chain !== -1) {
+                throw Error('Invalid chain');
+            }
+            chain = opts.chain;
+            if (opts.chain === -1) {
+                flags |= 0x04;
+            }
+        }
+        // Get public key
+        let response = await this.#doRequest(INS_ADDRESS, 0x00, 0x00, pathElementsToBuffer(path.map((v) => v + 0x80000000)));
+        if (response.length !== 32) {
+            throw Error('Invalid response');
+        }
+        // Contract
+        const contract = (0, getInit_1.getInit)(chain, response);
+        const address = (0, ton_core_1.contractAddress)(chain, contract);
+        return { address: address.toString({ bounceable: bounceable, testOnly: test }), publicKey: response };
+    }
+    async validateAddress(path, opts) {
+        // Check path
+        validatePath(path);
+        // Resolve flags
+        let bounceable = true;
+        let chain = 0;
+        let test = false;
+        let flags = 0x00;
+        if (opts && opts.bounceable !== undefined && !opts.bounceable) {
+            flags |= 0x01;
+            bounceable = false;
+        }
+        if (opts && opts.testOnly) {
+            flags |= 0x02;
+            test = true;
+        }
+        if (opts && opts.chain !== undefined) {
+            if (opts.chain !== 0 && opts.chain !== -1) {
+                throw Error('Invalid chain');
+            }
+            chain = opts.chain;
+            if (opts.chain === -1) {
+                flags |= 0x04;
+            }
+        }
+        // Get public key
+        let response = await this.#doRequest(INS_ADDRESS, 0x01, flags, pathElementsToBuffer(path.map((v) => v + 0x80000000)));
+        if (response.length !== 32) {
+            throw Error('Invalid response');
+        }
+        // Contract
+        const contract = (0, getInit_1.getInit)(chain, response);
+        const address = (0, ton_core_1.contractAddress)(chain, contract);
+        return { address: address.toString({ bounceable: bounceable, testOnly: test }), publicKey: response };
+    }
+    async getAddressProof(path, params, opts) {
+        // Check path
+        validatePath(path);
+        let publicKey = (await this.getAddress(path)).publicKey;
+        // Resolve flags
+        let bounceable = true;
+        let chain = 0;
+        let test = false;
+        let flags = 0x00;
+        if (opts && opts.bounceable !== undefined && !opts.bounceable) {
+            flags |= 0x01;
+            bounceable = false;
+        }
+        if (opts && opts.testOnly) {
+            flags |= 0x02;
+            test = true;
+        }
+        if (opts && opts.chain !== undefined) {
+            if (opts.chain !== 0 && opts.chain !== -1) {
+                throw Error('Invalid chain');
+            }
+            chain = opts.chain;
+            if (opts.chain === -1) {
+                flags |= 0x04;
+            }
+        }
+        const domainBuf = Buffer.from(params.domain, 'utf-8');
+        const reqBuf = Buffer.concat([
+            pathElementsToBuffer(path.map((v) => v + 0x80000000)),
+            (0, ledgerWriter_1.writeUint8)(domainBuf.length),
+            domainBuf,
+            (0, ledgerWriter_1.writeUint64)(BigInt(params.timestamp)),
+            params.payload,
+        ]);
+        // Get public key
+        let res = await this.#doRequest(INS_PROOF, 0x01, flags, reqBuf);
+        let signature = res.slice(1, 1 + 64);
+        let hash = res.slice(2 + 64, 2 + 64 + 32);
+        if (!(0, ton_crypto_1.signVerify)(hash, signature, publicKey)) {
+            throw Error('Received signature is invalid');
+        }
+        return { signature, hash };
+    }
+    signTransaction = async (path, transaction) => {
+        // Check path
+        validatePath(path);
+        //
+        // Fetch key
+        //
+        let publicKey = (await this.getAddress(path)).publicKey;
+        //
+        // Create package
+        //
+        let pkg = Buffer.concat([
+            (0, ledgerWriter_1.writeUint8)(0),
+            (0, ledgerWriter_1.writeUint32)(transaction.seqno),
+            (0, ledgerWriter_1.writeUint32)(transaction.timeout),
+            (0, ledgerWriter_1.writeVarUInt)(transaction.amount),
+            (0, ledgerWriter_1.writeAddress)(transaction.to),
+            (0, ledgerWriter_1.writeUint8)(transaction.bounce ? 1 : 0),
+            (0, ledgerWriter_1.writeUint8)(transaction.sendMode),
+        ]);
+        //
+        // State init
+        //
+        let stateInit = null;
+        if (transaction.stateInit) {
+            stateInit = (0, ton_core_1.beginCell)()
+                .store((0, ton_core_1.storeStateInit)(transaction.stateInit))
+                .endCell();
+            pkg = Buffer.concat([
+                pkg,
+                (0, ledgerWriter_1.writeUint8)(1),
+                (0, ledgerWriter_1.writeUint16)(stateInit.depth()),
+                stateInit.hash()
+            ]);
+        }
+        else {
+            pkg = Buffer.concat([
+                pkg,
+                (0, ledgerWriter_1.writeUint8)(0)
+            ]);
+        }
+        //
+        // Payload
+        //
+        let payload = null;
+        let hints = Buffer.concat([(0, ledgerWriter_1.writeUint8)(0)]);
+        if (transaction.payload) {
+            if (transaction.payload.type === 'comment') {
+                hints = Buffer.concat([
+                    (0, ledgerWriter_1.writeUint8)(1),
+                    (0, ledgerWriter_1.writeUint32)(0x00),
+                    (0, ledgerWriter_1.writeUint16)(Buffer.from(transaction.payload.text).length),
+                    Buffer.from(transaction.payload.text)
+                ]);
+                payload = (0, ton_core_1.beginCell)()
+                    .storeUint(0, 32)
+                    .storeBuffer(Buffer.from(transaction.payload.text))
+                    .endCell();
+            }
+            else if (transaction.payload.type === 'unsafe') {
+                payload = transaction.payload.message;
+            }
+            else if (transaction.payload.type === 'jetton-transfer' || transaction.payload.type === 'nft-transfer') {
+                hints = Buffer.concat([
+                    (0, ledgerWriter_1.writeUint8)(1),
+                    (0, ledgerWriter_1.writeUint32)(transaction.payload.type === 'jetton-transfer' ? 0x01 : 0x02)
+                ]);
+                let b = (0, ton_core_1.beginCell)()
+                    .storeUint(transaction.payload.type === 'jetton-transfer' ? 0x0f8a7ea5 : 0x5fcc3d14, 32);
+                let d = Buffer.alloc(0);
+                if (transaction.payload.queryId !== null) {
+                    d = Buffer.concat([d, (0, ledgerWriter_1.writeUint8)(1), (0, ledgerWriter_1.writeUint64)(transaction.payload.queryId)]);
+                    b = b.storeUint(transaction.payload.queryId, 64);
+                }
+                else {
+                    d = Buffer.concat([d, (0, ledgerWriter_1.writeUint8)(0)]);
+                    b = b.storeUint(0, 64);
+                }
+                if (transaction.payload.type === 'jetton-transfer') {
+                    d = Buffer.concat([d, (0, ledgerWriter_1.writeVarUInt)(transaction.payload.amount)]);
+                    b = b.storeCoins(transaction.payload.amount);
+                    d = Buffer.concat([d, (0, ledgerWriter_1.writeUint8)(transaction.payload.decimals), (0, ledgerWriter_1.writeUint8)(transaction.payload.ticker.length), Buffer.from(transaction.payload.ticker, 'ascii')]);
+                    d = Buffer.concat([d, (0, ledgerWriter_1.writeAddress)(transaction.payload.destination)]);
+                    b = b.storeAddress(transaction.payload.destination);
+                }
+                else {
+                    d = Buffer.concat([d, (0, ledgerWriter_1.writeAddress)(transaction.payload.newOwner)]);
+                    b = b.storeAddress(transaction.payload.newOwner);
+                }
+                d = Buffer.concat([d, (0, ledgerWriter_1.writeAddress)(transaction.payload.responseDestination)]);
+                b = b.storeAddress(transaction.payload.responseDestination);
+                if (transaction.payload.customPayload !== null) {
+                    d = Buffer.concat([d, (0, ledgerWriter_1.writeUint8)(1), (0, ledgerWriter_1.writeCellRef)(transaction.payload.customPayload)]);
+                    b = b.storeMaybeRef(transaction.payload.customPayload);
+                }
+                else {
+                    d = Buffer.concat([d, (0, ledgerWriter_1.writeUint8)(0)]);
+                    b = b.storeMaybeRef(transaction.payload.customPayload);
+                }
+                d = Buffer.concat([d, (0, ledgerWriter_1.writeVarUInt)(transaction.payload.forwardAmount)]);
+                b = b.storeCoins(transaction.payload.forwardAmount);
+                if (transaction.payload.forwardPayload !== null) {
+                    d = Buffer.concat([d, (0, ledgerWriter_1.writeUint8)(1), (0, ledgerWriter_1.writeCellRef)(transaction.payload.forwardPayload)]);
+                    b = b.storeMaybeRef(transaction.payload.forwardPayload);
+                }
+                else {
+                    d = Buffer.concat([d, (0, ledgerWriter_1.writeUint8)(0)]);
+                    b = b.storeMaybeRef(transaction.payload.forwardPayload);
+                }
+                payload = b.endCell();
+                hints = Buffer.concat([
+                    hints,
+                    (0, ledgerWriter_1.writeUint16)(d.length),
+                    d
+                ]);
+            }
+        }
+        //
+        // Serialize payload
+        //
+        if (payload) {
+            pkg = Buffer.concat([
+                pkg,
+                (0, ledgerWriter_1.writeUint8)(1),
+                (0, ledgerWriter_1.writeUint16)(payload.depth()),
+                payload.hash(),
+                hints
+            ]);
+        }
+        else {
+            pkg = Buffer.concat([
+                pkg,
+                (0, ledgerWriter_1.writeUint8)(0),
+                (0, ledgerWriter_1.writeUint8)(0)
+            ]);
+        }
+        //
+        // Send package
+        //
+        await this.#doRequest(0x06, 0x00, 0x03, pathElementsToBuffer(path.map((v) => v + 0x80000000)));
+        const pkgCs = chunks(pkg, 255);
+        for (let i = 0; i < pkgCs.length - 1; i++) {
+            await this.#doRequest(0x06, 0x00, 0x02, pkgCs[i]);
+        }
+        let res = await this.#doRequest(0x06, 0x00, 0x00, pkgCs[pkgCs.length - 1]);
+        //
+        // Parse response
+        //
+        let orderBuilder = (0, ton_core_1.beginCell)()
+            .storeBit(0)
+            .storeBit(true)
+            .storeBit(transaction.bounce)
+            .storeBit(false)
+            .storeAddress(null)
+            .storeAddress(transaction.to)
+            .storeCoins(transaction.amount)
+            .storeBit(false)
+            .storeCoins(0)
+            .storeCoins(0)
+            .storeUint(0, 64)
+            .storeUint(0, 32);
+        // State Init
+        if (stateInit) {
+            orderBuilder = orderBuilder
+                .storeBit(true)
+                .storeBit(true) // Always in reference
+                .storeRef(stateInit);
+        }
+        else {
+            orderBuilder = orderBuilder
+                .storeBit(false);
+        }
+        // Payload
+        if (payload) {
+            orderBuilder = orderBuilder
+                .storeBit(true) // Always in reference
+                .storeRef(payload);
+        }
+        else {
+            orderBuilder = orderBuilder
+                .storeBit(false);
+        }
+        // Transfer message
+        let transfer = (0, ton_core_1.beginCell)()
+            .storeUint(698983191, 32)
+            .storeUint(transaction.timeout, 32)
+            .storeUint(transaction.seqno, 32)
+            .storeUint(0, 8)
+            .storeUint(transaction.sendMode, 8)
+            .storeRef(orderBuilder.endCell())
+            .endCell();
+        // Parse result
+        let signature = res.slice(1, 1 + 64);
+        let hash = res.slice(2 + 64, 2 + 64 + 32);
+        if (!hash.equals(transfer.hash())) {
+            throw Error('Hash mismatch. Expected: ' + transfer.hash().toString('hex') + ', got: ' + hash.toString('hex'));
+        }
+        if (!(0, ton_crypto_1.signVerify)(hash, signature, publicKey)) {
+            throw Error('Received signature is invalid');
+        }
+        // Build a message
+        return (0, ton_core_1.beginCell)()
+            .storeBuffer(signature)
+            .storeSlice(transfer.beginParse())
+            .endCell();
+    };
+    #doRequest = async (ins, p1, p2, data) => {
+        return this.#lock.inLock(async () => {
+            let r = await this.transport.send(LEDGER_CLA, ins, p1, p2, data);
+            return r.slice(0, r.length - 2);
+        });
+    };
+}
+exports.TonTransport = TonTransport;
+//
+// Utils
+//
+function validatePath(path) {
+    if (path.length < 6) {
+        throw Error('Path is too short');
+    }
+    if (path[0] !== 44) {
+        throw Error('First element of a path must be 44');
+    }
+    if (path[1] !== 607) {
+        throw Error('Second element of a path must be 607');
+    }
+    for (let p of path) {
+        if (p >= 0x80000000) {
+            throw Error('All path elements must be under 0x80000000');
+        }
+    }
+}
+function pathElementsToBuffer(paths) {
+    const buffer = Buffer.alloc(1 + paths.length * 4);
+    buffer[0] = paths.length;
+    paths.forEach((element, index) => {
+        buffer.writeUInt32BE(element, 1 + 4 * index);
+    });
+    return buffer;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { TonPayloadFormat, TonTransport } from './TonTransport';

package/dist/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TonTransport = void 0;
+var TonTransport_1 = require("./TonTransport");
+Object.defineProperty(exports, "TonTransport", { enumerable: true, get: function () { return TonTransport_1.TonTransport; } });

package/dist/utils/getInit.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="node" />
+import { Cell } from 'ton-core';
+export declare function getInit(workchain: number, publicKey: Buffer): {
+    code: Cell;
+    data: Cell;
+};

package/dist/utils/getInit.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInit = void 0;
+const ton_core_1 = require("ton-core");
+function getInit(workchain, publicKey) {
+    let code = ton_core_1.Cell.fromBoc(Buffer.from('te6ccgECFAEAAtQAART/APSkE/S88sgLAQIBIAIDAgFIBAUE+PKDCNcYINMf0x/THwL4I7vyZO1E0NMf0x/T//QE0VFDuvKhUVG68qIF+QFUEGT5EPKj+AAkpMjLH1JAyx9SMMv/UhD0AMntVPgPAdMHIcAAn2xRkyDXSpbTB9QC+wDoMOAhwAHjACHAAuMAAcADkTDjDQOkyMsfEssfy/8QERITAubQAdDTAyFxsJJfBOAi10nBIJJfBOAC0x8hghBwbHVnvSKCEGRzdHK9sJJfBeAD+kAwIPpEAcjKB8v/ydDtRNCBAUDXIfQEMFyBAQj0Cm+hMbOSXwfgBdM/yCWCEHBsdWe6kjgw4w0DghBkc3RyupJfBuMNBgcCASAICQB4AfoA9AQw+CdvIjBQCqEhvvLgUIIQcGx1Z4MesXCAGFAEywUmzxZY+gIZ9ADLaRfLH1Jgyz8gyYBA+wAGAIpQBIEBCPRZMO1E0IEBQNcgyAHPFvQAye1UAXKwjiOCEGRzdHKDHrFwgBhQBcsFUAPPFiP6AhPLassfyz/JgED7AJJfA+ICASAKCwBZvSQrb2omhAgKBrkPoCGEcNQICEekk30pkQzmkD6f+YN4EoAbeBAUiYcVnzGEAgFYDA0AEbjJftRNDXCx+AA9sp37UTQgQFA1yH0BDACyMoHy//J0AGBAQj0Cm+hMYAIBIA4PABmtznaiaEAga5Drhf/AABmvHfaiaEAQa5DrhY/AAG7SB/oA1NQi+QAFyMoHFcv/ydB3dIAYyMsFywIizxZQBfoCFMtrEszMyXP7AMhAFIEBCPRR8qcCAHCBAQjXGPoA0z/IVCBHgQEI9FHyp4IQbm90ZXB0gBjIywXLAlAGzxZQBPoCFMtqEssfyz/Jc/sAAgBsgQEI1xj6ANM/MFIkgQEI9Fnyp4IQZHN0cnB0gBjIywXLAlAFzxZQA/oCE8tqyx8Syz/Jc/sAAAr0AMntVA==', 'base64'))[0];
+    let data = (0, ton_core_1.beginCell)()
+        .storeUint(0, 32) // Seqno
+        .storeUint(698983191 + workchain, 32)
+        .storeBuffer(publicKey)
+        .storeBit(0) // Empty plugins dict
+        .endCell();
+    return { code, data };
+}
+exports.getInit = getInit;

package/dist/utils/ledgerWriter.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="node" />
+import { Address, Cell } from 'ton-core';
+export declare function writeUint32(value: number): Buffer;
+export declare function writeUint16(value: number): Buffer;
+export declare function writeUint64(value: bigint): Buffer;
+export declare function writeVarUInt(value: bigint): Buffer;
+export declare function writeUint8(value: number): Buffer;
+export declare function writeAddress(address: Address): Buffer;
+export declare function writeCellRef(ref: Cell): Buffer;

package/dist/utils/ledgerWriter.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeCellRef = exports.writeAddress = exports.writeUint8 = exports.writeVarUInt = exports.writeUint64 = exports.writeUint16 = exports.writeUint32 = void 0;
+const ton_core_1 = require("ton-core");
+function writeUint32(value) {
+    let b = Buffer.alloc(4);
+    b.writeUint32BE(value, 0);
+    return b;
+}
+exports.writeUint32 = writeUint32;
+function writeUint16(value) {
+    let b = Buffer.alloc(2);
+    b.writeUint16BE(value, 0);
+    return b;
+}
+exports.writeUint16 = writeUint16;
+function writeUint64(value) {
+    return (0, ton_core_1.beginCell)().storeUint(value, 64).endCell().beginParse().loadBuffer(8);
+}
+exports.writeUint64 = writeUint64;
+function writeVarUInt(value) {
+    const sizeBytes = Math.ceil((value.toString(2).length) / 8);
+    return (0, ton_core_1.beginCell)().storeUint(sizeBytes, 8).storeUint(value, sizeBytes * 8).endCell().beginParse().loadBuffer(1 + sizeBytes);
+}
+exports.writeVarUInt = writeVarUInt;
+function writeUint8(value) {
+    let b = Buffer.alloc(1);
+    b[0] = value;
+    return b;
+}
+exports.writeUint8 = writeUint8;
+function writeAddress(address) {
+    return Buffer.concat([
+        writeUint8(address.workChain === -1 ? 0xff : address.workChain),
+        address.hash
+    ]);
+}
+exports.writeAddress = writeAddress;
+function writeCellRef(ref) {
+    return Buffer.concat([
+        writeUint16(ref.depth()),
+        ref.hash()
+    ]);
+}
+exports.writeCellRef = writeCellRef;

package/dist/utils/ledgerWriter.spec.d.ts

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

package/dist/utils/ledgerWriter.spec.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ton_core_1 = require("ton-core");
+const ledgerWriter_1 = require("./ledgerWriter");
+describe('ledgerWriter', () => {
+    it('should write ints', () => {
+        expect((0, ledgerWriter_1.writeUint8)(0).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint8)(10).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint8)(255).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint16)(0).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint16)(255).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint16)(12312).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint16)(65535).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint32)(0).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint32)(255).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint32)(12312).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint32)(65535).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint32)(123123123).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint32)(4294967295).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint64)(0n).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint64)(255n).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint64)(12312n).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint64)(65535n).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint64)(123123123n).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint64)(4294967295n).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint64)(12312312312312n).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeUint64)(18446744073709551615n).toString('hex')).toMatchSnapshot();
+    });
+    it('should write addresses', () => {
+        expect((0, ledgerWriter_1.writeAddress)(new ton_core_1.Address(0, Buffer.alloc(32))).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeAddress)(new ton_core_1.Address(-1, Buffer.alloc(32))).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeAddress)(ton_core_1.Address.parse('EQBNVUFfKt2QgqKL5vZvnyP50wmniCFP2ASOKAE-g2noRDlR')).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeAddress)(ton_core_1.Address.parse('Ef87m7_QrVM4uXAPCDM4DuF9Rj5Rwa5nHubwiQG96JmyAjQY')).toString('hex')).toMatchSnapshot();
+    });
+    it('should write cell refs', () => {
+        expect((0, ledgerWriter_1.writeCellRef)((0, ton_core_1.beginCell)().endCell()).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeCellRef)((0, ton_core_1.beginCell)().storeUint(0, 32).endCell()).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeCellRef)((0, ton_core_1.beginCell)().storeUint(0, 32).storeRef((0, ton_core_1.beginCell)().endCell()).endCell()).toString('hex')).toMatchSnapshot();
+        expect((0, ledgerWriter_1.writeCellRef)((0, ton_core_1.beginCell)().storeUint(0, 32).storeRef((0, ton_core_1.beginCell)().storeRef((0, ton_core_1.beginCell)().endCell()).endCell()).endCell()).toString('hex')).toMatchSnapshot();
+    });
+});

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@ton-community/ton-ledger",
+  "version": "4.0.0",
+  "repository": "https://github.com/ton-community/ton-ledger-ts",
+  "author": "Steve Korshakov <steve@korshakov.com>",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -fr dist && tsc --declaration",
+    "test": "jest",
+    "release": "yarn test && yarn build && yarn release-it --npm.yarn1",
+    "dev": "ts-node ./test/index.ts"
+  },
+  "peerDependencies": {
+    "ton-core": ">=0.49.1"
+  },
+  "devDependencies": {
+    "@release-it/keep-a-changelog": "^3.1.0",
+    "@ledgerhq/hw-transport-node-hid": "^6.27.15",
+    "@types/jest": "^29.5.2",
+    "@types/node": "^20.2.5",
+    "jest": "^29.5.0",
+    "release-it": "^15.11.0",
+    "ton-core": "^0.49.1",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^4.9.5"
+  },
+  "dependencies": {
+    "@ledgerhq/hw-transport": "^6.28.4",
+    "teslabot": "^1.5.0",
+    "ton-crypto": "^3.2.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "release-it": {
+    "github": {
+      "release": true
+    },
+    "plugins": {
+      "@release-it/keep-a-changelog": {
+        "filename": "CHANGELOG.md"
+      }
+    }
+  }
+}