@cityofzion/bs-neo-legacy 1.6.7 → 1.7.0

package/dist/constants/BSNeoLegacyConstants.js

@@ -17,10 +17,10 @@ BSNeoLegacyConstants.EXTRA_TOKENS_BY_NETWORK_ID = {
 BSNeoLegacyConstants.NATIVE_ASSETS = common_json_1.default;
 BSNeoLegacyConstants.RPC_LIST_BY_NETWORK_ID = {
     mainnet: [
-        'http://seed9.ngd.network:10332',
         'https://mainnet1.neo2.coz.io:443',
         'https://mainnet2.neo2.coz.io:443',
         'https://mainnet3.neo2.coz.io:443',
+        'http://seed9.ngd.network:10332',
         'http://seed1.ngd.network:10332',
         'http://seed2.ngd.network:10332',
         'http://seed3.ngd.network:10332',

package/dist/index.d.ts

@@ -4,3 +4,4 @@ export * from './helpers/BSNeoLegacyHelper';
 export * from './services/blockchain-data/DoraBDSNeoLegacy';
 export * from './services/exchange-data/CryptoCompareEDSNeoLegacy';
 export * from './services/explorer/NeoTubeESNeoLegacy';
+export * from './services/ledger/NeonJsLedgerServiceNeoLegacy';

package/dist/index.js

@@ -20,3 +20,4 @@ __exportStar(require("./helpers/BSNeoLegacyHelper"), exports);
 __exportStar(require("./services/blockchain-data/DoraBDSNeoLegacy"), exports);
 __exportStar(require("./services/exchange-data/CryptoCompareEDSNeoLegacy"), exports);
 __exportStar(require("./services/explorer/NeoTubeESNeoLegacy"), exports);
+__exportStar(require("./services/ledger/NeonJsLedgerServiceNeoLegacy"), exports);

package/dist/services/BSNeoLegacy.d.ts

@@ -1,6 +1,7 @@
-import { Account, BDSClaimable, BlockchainDataService, BlockchainService, BSClaimable, ExchangeDataService, Token, Network, TransferParam, BSWithExplorerService, ExplorerService } from '@cityofzion/blockchain-service';
+import { Account, BDSClaimable, BlockchainDataService, BlockchainService, BSClaimable, ExchangeDataService, Token, Network, TransferParam, BSWithExplorerService, ExplorerService, BSWithLedger, GetLedgerTransport } from '@cityofzion/blockchain-service';
 import { BSNeoLegacyNetworkId } from '../constants/BSNeoLegacyConstants';
-export declare class BSNeoLegacy<BSName extends string = string> implements BlockchainService<BSName, BSNeoLegacyNetworkId>, BSClaimable<BSName>, BSWithExplorerService {
+import { NeonJsLedgerServiceNeoLegacy } from './ledger/NeonJsLedgerServiceNeoLegacy';
+export declare class BSNeoLegacy<BSName extends string = string> implements BlockchainService<BSName, BSNeoLegacyNetworkId>, BSClaimable<BSName>, BSWithExplorerService, BSWithLedger<BSName> {
     #private;
     readonly name: BSName;
     readonly bip44DerivationPath: string;
@@ -9,11 +10,12 @@ export declare class BSNeoLegacy<BSName extends string = string> implements Bloc
     burnToken: Token;
     blockchainDataService: BlockchainDataService & BDSClaimable;
     exchangeDataService: ExchangeDataService;
+    ledgerService: NeonJsLedgerServiceNeoLegacy<BSName>;
     explorerService: ExplorerService;
     tokens: Token[];
     network: Network<BSNeoLegacyNetworkId>;
     legacyNetwork: string;
-    constructor(name: BSName, network?: Network<BSNeoLegacyNetworkId>);
+    constructor(name: BSName, network?: Network<BSNeoLegacyNetworkId>, getLedgerTransport?: GetLedgerTransport<BSName>);
     testNetwork(network: Network<BSNeoLegacyNetworkId>): Promise<void>;
     setNetwork(network: Network<BSNeoLegacyNetworkId>): void;
     validateAddress(address: string): boolean;
@@ -21,8 +23,9 @@ export declare class BSNeoLegacy<BSName extends string = string> implements Bloc
     validateKey(key: string): boolean;
     generateAccountFromMnemonic(mnemonic: string[] | string, index: number): Account<BSName>;
     generateAccountFromKey(key: string): Account<BSName>;
+    generateAccountFromPublicKey(publicKey: string): Account<BSName>;
     decrypt(encryptedKey: string, password: string): Promise<Account<BSName>>;
     encrypt(key: string, password: string): Promise<string>;
-    transfer({ intents, senderAccount, tipIntent, ...params }: TransferParam): Promise<string[]>;
+    transfer({ intents, senderAccount, tipIntent, ...params }: TransferParam<BSName>): Promise<string[]>;
     claim(account: Account): Promise<string>;
 }

package/dist/services/BSNeoLegacy.js

@@ -24,7 +24,7 @@ var __rest = (this && this.__rest) || function (s, e) {
         }
     return t;
 };
-var _BSNeoLegacy_instances, _BSNeoLegacy_setTokens;
+var _BSNeoLegacy_instances, _BSNeoLegacy_generateSigningCallback, _BSNeoLegacy_setTokens;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BSNeoLegacy = void 0;
 const neon_js_1 = require("@cityofzion/neon-js");
@@ -34,12 +34,14 @@ const BSNeoLegacyHelper_1 = require("../helpers/BSNeoLegacyHelper");
 const CryptoCompareEDSNeoLegacy_1 = require("./exchange-data/CryptoCompareEDSNeoLegacy");
 const DoraBDSNeoLegacy_1 = require("./blockchain-data/DoraBDSNeoLegacy");
 const NeoTubeESNeoLegacy_1 = require("./explorer/NeoTubeESNeoLegacy");
+const NeonJsLedgerServiceNeoLegacy_1 = require("./ledger/NeonJsLedgerServiceNeoLegacy");
 class BSNeoLegacy {
-    constructor(name, network) {
+    constructor(name, network, getLedgerTransport) {
         _BSNeoLegacy_instances.add(this);
         network = network !== null && network !== void 0 ? network : BSNeoLegacyConstants_1.BSNeoLegacyConstants.DEFAULT_NETWORK;
         this.name = name;
         this.legacyNetwork = BSNeoLegacyConstants_1.BSNeoLegacyConstants.LEGACY_NETWORK_BY_NETWORK_ID[network.id];
+        this.ledgerService = new NeonJsLedgerServiceNeoLegacy_1.NeonJsLedgerServiceNeoLegacy(this, getLedgerTransport);
         this.bip44DerivationPath = BSNeoLegacyConstants_1.BSNeoLegacyConstants.DEFAULT_BIP44_DERIVATION_PATH;
         this.setNetwork(network);
     }
@@ -82,6 +84,17 @@ class BSNeoLegacy {
         const { address } = new neon_js_1.wallet.Account(key);
         return { address, key, type, blockchain: this.name };
     }
+    generateAccountFromPublicKey(publicKey) {
+        if (!neon_js_1.wallet.isPublicKey(publicKey))
+            throw new Error('Invalid public key');
+        const account = new neon_js_1.wallet.Account(publicKey);
+        return {
+            address: account.address,
+            key: account.publicKey,
+            type: 'publicKey',
+            blockchain: this.name,
+        };
+    }
     decrypt(encryptedKey, password) {
         return __awaiter(this, void 0, void 0, function* () {
             const key = yield neon_js_1.wallet.decrypt(encryptedKey, password);
@@ -95,8 +108,8 @@ class BSNeoLegacy {
         var _b, _c;
         var { intents, senderAccount, tipIntent } = _a, params = __rest(_a, ["intents", "senderAccount", "tipIntent"]);
         return __awaiter(this, void 0, void 0, function* () {
+            const { neonJsAccount, signingCallback } = yield __classPrivateFieldGet(this, _BSNeoLegacy_instances, "m", _BSNeoLegacy_generateSigningCallback).call(this, senderAccount);
             const apiProvider = new neon_js_1.api.neoCli.instance(this.network.url);
-            const account = new neon_js_1.wallet.Account(senderAccount.key);
             const priorityFee = Number((_b = params.priorityFee) !== null && _b !== void 0 ? _b : 0);
             const nativeIntents = [];
             const nep5ScriptBuilder = new neon_js_1.sc.ScriptBuilder();
@@ -109,7 +122,7 @@ class BSNeoLegacy {
                     continue;
                 }
                 nep5ScriptBuilder.emitAppCall(tokenHashFixed, 'transfer', [
-                    neon_js_1.u.reverseHex(neon_js_1.wallet.getScriptHashFromAddress(account.address)),
+                    neon_js_1.u.reverseHex(neon_js_1.wallet.getScriptHashFromAddress(neonJsAccount.address)),
                     neon_js_1.u.reverseHex(neon_js_1.wallet.getScriptHashFromAddress(intent.receiverAddress)),
                     neon_js_1.sc.ContractParam.integer(new neon_js_1.u.Fixed8(intent.amount)
                         .div(Math.pow(10, 8 - ((_c = intent.tokenDecimals) !== null && _c !== void 0 ? _c : 8)))
@@ -120,21 +133,23 @@ class BSNeoLegacy {
             let response;
             if (nep5ScriptBuilder.isEmpty()) {
                 response = yield neon_js_1.api.sendAsset({
-                    account,
+                    account: neonJsAccount,
                     api: apiProvider,
                     url: this.network.url,
                     intents: nativeIntents,
                     fees: priorityFee,
+                    signingFunction: signingCallback,
                 });
             }
             else {
                 response = yield neon_js_1.api.doInvoke({
                     intents: nativeIntents.length > 0 ? nativeIntents : undefined,
-                    account,
+                    account: neonJsAccount,
                     api: apiProvider,
                     script: nep5ScriptBuilder.str,
                     url: this.network.url,
                     fees: priorityFee,
+                    signingFunction: signingCallback,
                 });
             }
             if (!response.tx)
@@ -167,7 +182,25 @@ class BSNeoLegacy {
     }
 }
 exports.BSNeoLegacy = BSNeoLegacy;
-_BSNeoLegacy_instances = new WeakSet(), _BSNeoLegacy_setTokens = function _BSNeoLegacy_setTokens(network) {
+_BSNeoLegacy_instances = new WeakSet(), _BSNeoLegacy_generateSigningCallback = function _BSNeoLegacy_generateSigningCallback(account) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const neonJsAccount = new neon_js_1.wallet.Account(account.key);
+        if (account.isHardware) {
+            if (!this.ledgerService.getLedgerTransport)
+                throw new Error('You must provide a getLedgerTransport function to use Ledger');
+            if (typeof account.bip44Path !== 'string')
+                throw new Error('Your account must have bip44 path to use Ledger');
+            const ledgerTransport = yield this.ledgerService.getLedgerTransport(account);
+            return {
+                neonJsAccount,
+                signingCallback: this.ledgerService.getSigningCallback(ledgerTransport, account),
+            };
+        }
+        return {
+            neonJsAccount,
+        };
+    });
+}, _BSNeoLegacy_setTokens = function _BSNeoLegacy_setTokens(network) {
     const tokens = BSNeoLegacyHelper_1.BSNeoLegacyHelper.getTokens(network);
     this.tokens = tokens;
     this.feeToken = tokens.find(token => token.symbol === 'GAS');

package/dist/services/ledger/NeonJsLedgerServiceNeoLegacy.d.ts

@@ -0,0 +1,12 @@
+import { Account, GetLedgerTransport, LedgerService, LedgerServiceEmitter } from '@cityofzion/blockchain-service';
+import { BSNeoLegacy } from '../BSNeoLegacy';
+import Transport from '@ledgerhq/hw-transport';
+export declare class NeonJsLedgerServiceNeoLegacy<BSName extends string = string> implements LedgerService<BSName> {
+    #private;
+    emitter: LedgerServiceEmitter;
+    getLedgerTransport?: GetLedgerTransport<BSName>;
+    constructor(blockchainService: BSNeoLegacy<BSName>, getLedgerTransport?: GetLedgerTransport<BSName>);
+    getAccount(transport: Transport, index: number): Promise<Account<BSName>>;
+    getAccounts(transport: Transport): Promise<Account<BSName>[]>;
+    getSigningCallback(transport: Transport, account: Account): (transaction: string, publicKey: string) => Promise<string | string[]>;
+}

package/dist/services/ledger/NeonJsLedgerServiceNeoLegacy.js

@@ -0,0 +1,153 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _NeonJsLedgerServiceNeoLegacy_instances, _NeonJsLedgerServiceNeoLegacy_blockchainService, _NeonJsLedgerServiceNeoLegacy_sendChunk, _NeonJsLedgerServiceNeoLegacy_bip44PathToHex, _NeonJsLedgerServiceNeoLegacy_derSignatureToHex;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NeonJsLedgerServiceNeoLegacy = void 0;
+const blockchain_service_1 = require("@cityofzion/blockchain-service");
+const events_1 = __importDefault(require("events"));
+const neon_js_1 = require("@cityofzion/neon-js");
+var LedgerStatus;
+(function (LedgerStatus) {
+    LedgerStatus[LedgerStatus["OK"] = 36864] = "OK";
+})(LedgerStatus || (LedgerStatus = {}));
+var LedgerCommand;
+(function (LedgerCommand) {
+    LedgerCommand[LedgerCommand["GET_PUBLIC_KEY"] = 4] = "GET_PUBLIC_KEY";
+    LedgerCommand[LedgerCommand["SIGN"] = 2] = "SIGN";
+})(LedgerCommand || (LedgerCommand = {}));
+var LedgerParameter;
+(function (LedgerParameter) {
+    LedgerParameter[LedgerParameter["MORE_DATA"] = 0] = "MORE_DATA";
+    LedgerParameter[LedgerParameter["LAST_DATA"] = 128] = "LAST_DATA";
+})(LedgerParameter || (LedgerParameter = {}));
+class NeonJsLedgerServiceNeoLegacy {
+    constructor(blockchainService, getLedgerTransport) {
+        _NeonJsLedgerServiceNeoLegacy_instances.add(this);
+        _NeonJsLedgerServiceNeoLegacy_blockchainService.set(this, void 0);
+        this.emitter = new events_1.default();
+        __classPrivateFieldSet(this, _NeonJsLedgerServiceNeoLegacy_blockchainService, blockchainService, "f");
+        this.getLedgerTransport = getLedgerTransport;
+    }
+    getAccount(transport, index) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bip44Path = __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_blockchainService, "f").bip44DerivationPath.replace('?', index.toString());
+            const bip44PathHex = __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_instances, "m", _NeonJsLedgerServiceNeoLegacy_bip44PathToHex).call(this, bip44Path);
+            const result = yield __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_instances, "m", _NeonJsLedgerServiceNeoLegacy_sendChunk).call(this, transport, LedgerCommand.GET_PUBLIC_KEY, LedgerParameter.LAST_DATA, bip44PathHex);
+            const publicKey = result.toString('hex').substring(0, 130);
+            const { address } = new neon_js_1.wallet.Account(publicKey);
+            return {
+                address,
+                key: publicKey,
+                type: 'publicKey',
+                bip44Path,
+                blockchain: __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_blockchainService, "f").name,
+                isHardware: true,
+            };
+        });
+    }
+    getAccounts(transport) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const accountsByBlockchainService = yield (0, blockchain_service_1.fetchAccountsForBlockchainServices)([__classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_blockchainService, "f")], (_service, index) => __awaiter(this, void 0, void 0, function* () {
+                return this.getAccount(transport, index);
+            }));
+            const accounts = accountsByBlockchainService.get(__classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_blockchainService, "f").name);
+            return accounts !== null && accounts !== void 0 ? accounts : [];
+        });
+    }
+    getSigningCallback(transport, account) {
+        return (transaction, publicKey) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.emitter.emit('getSignatureStart');
+                if (!account.bip44Path) {
+                    throw new Error('Account must have a bip 44 path to sign with Ledger');
+                }
+                const neonJsAccount = new neon_js_1.wallet.Account(account.key);
+                const witnessScriptHash = neon_js_1.wallet.getScriptHashFromPublicKey(publicKey);
+                if (neonJsAccount.scriptHash !== witnessScriptHash) {
+                    throw new Error('Public key does not match the account key');
+                }
+                const bip44PathHex = __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_instances, "m", _NeonJsLedgerServiceNeoLegacy_bip44PathToHex).call(this, account.bip44Path);
+                const payload = transaction + bip44PathHex;
+                // Split the serialized transaction into chunks of 510 bytes
+                const chunks = payload.match(/.{1,510}/g) || [];
+                // Send all chunks except the last one
+                for (let i = 0; i < chunks.length - 1; i++) {
+                    yield __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_instances, "m", _NeonJsLedgerServiceNeoLegacy_sendChunk).call(this, transport, LedgerCommand.SIGN, LedgerParameter.MORE_DATA, chunks[i]);
+                }
+                // Send the last chunk signaling that it is the last one and get the signature
+                const response = yield __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_instances, "m", _NeonJsLedgerServiceNeoLegacy_sendChunk).call(this, transport, LedgerCommand.SIGN, LedgerParameter.LAST_DATA, chunks[chunks.length - 1]);
+                if (response.readUIntBE(0, 2) === LedgerStatus.OK) {
+                    throw new Error('No more data but Ledger did not return signature!');
+                }
+                const signature = __classPrivateFieldGet(this, _NeonJsLedgerServiceNeoLegacy_instances, "m", _NeonJsLedgerServiceNeoLegacy_derSignatureToHex).call(this, response.toString('hex'));
+                const witness = neon_js_1.tx.Witness.fromSignature(signature, publicKey);
+                return witness.serialize();
+            }
+            finally {
+                this.emitter.emit('getSignatureEnd');
+            }
+        });
+    }
+}
+exports.NeonJsLedgerServiceNeoLegacy = NeonJsLedgerServiceNeoLegacy;
+_NeonJsLedgerServiceNeoLegacy_blockchainService = new WeakMap(), _NeonJsLedgerServiceNeoLegacy_instances = new WeakSet(), _NeonJsLedgerServiceNeoLegacy_sendChunk = function _NeonJsLedgerServiceNeoLegacy_sendChunk(transport, command, parameter, chunk) {
+    return transport.send(0x80, command, parameter, 0x00, Buffer.from(chunk, 'hex'), [LedgerStatus.OK]);
+}, _NeonJsLedgerServiceNeoLegacy_bip44PathToHex = function _NeonJsLedgerServiceNeoLegacy_bip44PathToHex(path) {
+    let result = '';
+    const components = path.split('/');
+    components.forEach(element => {
+        let number = parseInt(element, 10);
+        if (isNaN(number)) {
+            return;
+        }
+        if (element.length > 1 && element[element.length - 1] === "'") {
+            number += 0x80000000;
+        }
+        result += number.toString(16).padStart(8, '0');
+    });
+    return result;
+}, _NeonJsLedgerServiceNeoLegacy_derSignatureToHex = function _NeonJsLedgerServiceNeoLegacy_derSignatureToHex(response) {
+    const ss = new neon_js_1.u.StringStream(response);
+    // The first byte is format. It is usually 0x30 (SEQ) or 0x31 (SET)
+    // The second byte represents the total length of the DER module.
+    ss.read(2);
+    // Now we read each field off
+    // Each field is encoded with a type byte, length byte followed by the data itself
+    ss.read(1); // Read and drop the type
+    const r = ss.readVarBytes();
+    ss.read(1);
+    const s = ss.readVarBytes();
+    // We will need to ensure both integers are 32 bytes long
+    const integers = [r, s].map(i => {
+        if (i.length < 64) {
+            i = '0'.repeat(i.length - 64) + i;
+        }
+        if (i.length > 64) {
+            i = i.substr(-64);
+        }
+        return i;
+    });
+    return integers.join('');
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-neo-legacy",
-  "version": "1.6.7",
+  "version": "1.7.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "author": "Coz",
@@ -11,6 +11,7 @@
   "dependencies": {
     "@cityofzion/dora-ts": "0.0.11",
     "@cityofzion/neon-js": "4.8.3",
+    "@ledgerhq/hw-transport": "~6.30.5",
     "@cityofzion/blockchain-service": "1.13.0",
     "@cityofzion/bs-asteroid-sdk": "0.9.0"
   },
@@ -18,6 +19,7 @@
     "@types/jest": "29.5.3",
     "@typescript-eslint/eslint-plugin": "^6.5.0",
     "@typescript-eslint/parser": "^6.5.0",
+    "@ledgerhq/hw-transport-node-hid": "~6.28.5",
     "dotenv": "16.3.1",
     "eslint": "^8.48.0",
     "jest": "29.6.2",