@cityofzion/bs-neo3 1.2.0 → 1.3.0

package/dist/services/swap/handlers/FlamingoSwapRouteHandler.js

@@ -0,0 +1,181 @@
+"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 __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 _a, _FlamingoSwapRouteHandler_invokeReserves, _FlamingoSwapRouteHandler_createSwapRoute, _FlamingoSwapRouteHandler_getShortestRoutePath;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlamingoSwapRouteHandler = void 0;
+const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
+const neon_dappkit_types_1 = require("@cityofzion/neon-dappkit-types");
+const NeonDappKitInvocationBuilderNeo3_1 = require("../../../builder/invocation/NeonDappKitInvocationBuilderNeo3");
+const FlamingoSwapHelper_1 = require("../../../helpers/FlamingoSwapHelper");
+class FlamingoSwapRouteHandler {
+    static calculateBestRouteForSwap({ tokenToUse, tokenToReceive, network, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const routePath = __classPrivateFieldGet(this, _a, "m", _FlamingoSwapRouteHandler_getShortestRoutePath).call(this, {
+                network,
+                startToken: tokenToUse,
+                targetToken: tokenToReceive,
+            });
+            if (routePath.length === 0)
+                return [];
+            const { stack: reservesStack } = yield __classPrivateFieldGet(this, _a, "m", _FlamingoSwapRouteHandler_invokeReserves).call(this, { network, routePath });
+            return __classPrivateFieldGet(this, _a, "m", _FlamingoSwapRouteHandler_createSwapRoute).call(this, { network, routePath, reservesStack });
+        });
+    }
+    static createPoolGraph(network) {
+        const pools = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapPools(network);
+        const tokens = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapTokens(network);
+        const { NEO, bNEO } = tokens;
+        const poolGraph = {};
+        // Initialize poolGraph with empty arrays
+        Object.values(tokens).forEach(token => {
+            poolGraph[token.symbol] = [];
+        });
+        // Add edges to poolGraph
+        Object.values(pools).forEach(pool => {
+            const tokenA = pool.tokens[0].symbol;
+            const tokenB = pool.tokens[1].symbol;
+            poolGraph[tokenA].push(tokenB);
+            poolGraph[tokenB].push(tokenA);
+        });
+        // Remove duplicates from poolGraph
+        Object.keys(poolGraph).forEach(tokenSymbol => {
+            poolGraph[tokenSymbol] = [...new Set(poolGraph[tokenSymbol])];
+        });
+        // Include NEO to the poolGraph
+        poolGraph[NEO.symbol] = Object.keys(tokens).filter(tokenSymbol => tokenSymbol === bNEO.symbol);
+        // Include relationship between NEO and bNEO
+        poolGraph[bNEO.symbol].push(NEO.symbol);
+        return poolGraph;
+    }
+}
+exports.FlamingoSwapRouteHandler = FlamingoSwapRouteHandler;
+_a = FlamingoSwapRouteHandler, _FlamingoSwapRouteHandler_invokeReserves = function _FlamingoSwapRouteHandler_invokeReserves({ network, routePath }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const invoker = yield neon_dappkit_1.NeonInvoker.init({
+            rpcAddress: network.url,
+        });
+        const scriptHashes = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapScriptHashes(network);
+        const routerScriptHash = scriptHashes.flamingoSwapRouter;
+        // Remove NEO token from the routePath because it's not supported by the router
+        const routePathWithoutNeo = routePath.filter(route => !FlamingoSwapHelper_1.FlamingoSwapHelper.isNeoToken(network, route.tokenToUse) &&
+            !FlamingoSwapHelper_1.FlamingoSwapHelper.isNeoToken(network, route.tokenToReceive));
+        const getReservesContractInvocations = routePathWithoutNeo.map(route => NeonDappKitInvocationBuilderNeo3_1.NeonDappKitInvocationBuilderNeo3.getReservesContractInvocation({
+            routerScriptHash,
+            tokenToUseHash: route.tokenToUse.hash,
+            tokenToReceiveHash: route.tokenToReceive.hash,
+        }));
+        const getReservesContractInvocationMulti = {
+            invocations: [...getReservesContractInvocations],
+        };
+        return yield invoker.testInvoke(getReservesContractInvocationMulti);
+    });
+}, _FlamingoSwapRouteHandler_createSwapRoute = function _FlamingoSwapRouteHandler_createSwapRoute({ network, routePath, reservesStack }) {
+    const isNeoTokenToUse = FlamingoSwapHelper_1.FlamingoSwapHelper.isNeoToken(network, routePath[0].tokenToUse);
+    const isNeoTokenToReceive = FlamingoSwapHelper_1.FlamingoSwapHelper.isNeoToken(network, routePath[routePath.length - 1].tokenToReceive);
+    const swapRoute = [];
+    for (let index = 0; index < reservesStack.length; index++) {
+        const item = reservesStack[index];
+        if (!neon_dappkit_types_1.TypeChecker.isStackTypeArray(item) ||
+            !neon_dappkit_types_1.TypeChecker.isStackTypeInteger(item.value[0]) ||
+            !neon_dappkit_types_1.TypeChecker.isStackTypeInteger(item.value[1])) {
+            throw new Error('Invalid reserves response');
+        }
+        // Include NEO token in the swapRoute with 0 reserves because it wasn't supported by the router during the reserves invocation
+        if (isNeoTokenToUse && index === 0) {
+            swapRoute.push({
+                tokenToUse: routePath[index].tokenToUse,
+                reserveTokenToUse: '0',
+                tokenToReceive: routePath[index].tokenToReceive,
+                reserveTokenToReceive: '0',
+            });
+            index++;
+        }
+        swapRoute.push({
+            tokenToUse: routePath[index].tokenToUse,
+            reserveTokenToUse: item.value[1].value,
+            tokenToReceive: routePath[index].tokenToReceive,
+            reserveTokenToReceive: item.value[0].value,
+        });
+    }
+    // Include NEO token in the swapRoute with 0 reserves because it wasn't supported by the router during the reserves invocation
+    if (isNeoTokenToReceive) {
+        swapRoute.push({
+            tokenToUse: routePath[routePath.length - 1].tokenToUse,
+            reserveTokenToUse: '0',
+            tokenToReceive: routePath[routePath.length - 1].tokenToReceive,
+            reserveTokenToReceive: '0',
+        });
+    }
+    return swapRoute;
+}, _FlamingoSwapRouteHandler_getShortestRoutePath = function _FlamingoSwapRouteHandler_getShortestRoutePath({ network, startToken, targetToken }) {
+    // Initialize an empty object to track predecessors of each token
+    const predecessor = {};
+    // Create a graph representation of the token network
+    const poolGraph = this.createPoolGraph(network);
+    // Initialize the queue with the start token's symbol
+    const queue = [startToken.symbol];
+    // Track visited tokens, starting with the start token marked as visited
+    const tokensVisited = {
+        [startToken.symbol]: true,
+    };
+    // Initialize an empty array to store the path of tokens
+    let path = [];
+    while (queue.length) {
+        // Remove and get the first token symbol from the queue
+        const currentTokenSymbol = queue.shift();
+        if (!currentTokenSymbol)
+            break;
+        const currentToken = FlamingoSwapHelper_1.FlamingoSwapHelper.getFlamingoSwapToken(network, currentTokenSymbol);
+        if (!currentToken)
+            continue;
+        // Get the neighbors of the current token from the graph
+        const neighbours = poolGraph[currentToken.symbol];
+        for (const neighbourSymbol of neighbours || []) {
+            if (tokensVisited[neighbourSymbol])
+                continue; // Skip if the neighbor has already been visited
+            // Mark the neighbor token as visited
+            tokensVisited[neighbourSymbol] = true;
+            // Record the current token as the predecessor of the neighbor token
+            predecessor[neighbourSymbol] = currentToken;
+            // Add the neighbor token symbol to the queue
+            queue.push(neighbourSymbol);
+            if (neighbourSymbol === targetToken.symbol) {
+                // Initialize the path with the target token
+                path = [targetToken];
+                // Start reconstructing the path from the target token back to the start token
+                let prevToken = currentToken;
+                while (prevToken && prevToken.symbol !== startToken.symbol) {
+                    path.push(prevToken); // Add the predecessor token to the path
+                    prevToken = predecessor[prevToken.symbol]; // Move to the predecessor token
+                }
+                // If the start token is reached, add it to the path and reverse the path to start-to-end order
+                if (prevToken) {
+                    path.push(prevToken);
+                    path.reverse();
+                }
+                break;
+            }
+        }
+        if (path.length)
+            break;
+    }
+    const routePath = [];
+    // Convert the token path into route paths
+    for (let i = 0; i < path.length - 1; i++) {
+        routePath.push({ tokenToUse: path[i], tokenToReceive: path[i + 1] });
+    }
+    return routePath;
+};

package/dist/services/swap/handlers/FlamingoSwapSocketHandler.d.ts

@@ -0,0 +1,9 @@
+type ListenBlockAddedParams = {
+    callback: () => Promise<void> | void;
+};
+export declare class FlamingoSwapSocketService {
+    #private;
+    onBlockAdded({ callback }: ListenBlockAddedParams): void;
+    closeConnection(): void;
+}
+export {};

package/dist/services/swap/handlers/FlamingoSwapSocketHandler.js

@@ -0,0 +1,57 @@
+"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 _FlamingoSwapSocketService_ws;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlamingoSwapSocketService = void 0;
+const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
+const FlamingoSwapConstants_1 = require("../../../constants/FlamingoSwapConstants");
+class FlamingoSwapSocketService {
+    constructor() {
+        _FlamingoSwapSocketService_ws.set(this, void 0);
+    }
+    onBlockAdded({ callback }) {
+        __classPrivateFieldSet(this, _FlamingoSwapSocketService_ws, new isomorphic_ws_1.default(FlamingoSwapConstants_1.BLOCKCHAIN_WSS_URL), "f");
+        __classPrivateFieldGet(this, _FlamingoSwapSocketService_ws, "f").onopen = () => {
+            const block_added = {
+                jsonrpc: '2.0',
+                method: 'subscribe',
+                params: ['block_added'],
+                id: 1,
+            };
+            __classPrivateFieldGet(this, _FlamingoSwapSocketService_ws, "f").send(JSON.stringify(block_added));
+        };
+        __classPrivateFieldGet(this, _FlamingoSwapSocketService_ws, "f").onmessage = () => __awaiter(this, void 0, void 0, function* () {
+            yield callback();
+        });
+    }
+    closeConnection() {
+        if (!__classPrivateFieldGet(this, _FlamingoSwapSocketService_ws, "f"))
+            return;
+        __classPrivateFieldGet(this, _FlamingoSwapSocketService_ws, "f").close();
+        __classPrivateFieldSet(this, _FlamingoSwapSocketService_ws, null, "f");
+    }
+}
+exports.FlamingoSwapSocketService = FlamingoSwapSocketService;
+_FlamingoSwapSocketService_ws = new WeakMap();

package/dist/services/swap/handlers/index.d.ts

@@ -0,0 +1,3 @@
+export * from './FlamingoSwapDetailsHandler';
+export * from './FlamingoSwapRouteHandler';
+export * from './FlamingoSwapSocketHandler';

package/dist/services/swap/handlers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./FlamingoSwapDetailsHandler"), exports);
+__exportStar(require("./FlamingoSwapRouteHandler"), exports);
+__exportStar(require("./FlamingoSwapSocketHandler"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cityofzion/bs-neo3",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "repository": "https://github.com/CityOfZion/blockchain-services",
@@ -17,14 +17,16 @@
     "query-string": "7.1.3",
     "@ledgerhq/hw-transport": "~6.30.5",
     "@cityofzion/neon-dappkit": "0.4.1",
-    "bignumber.js": "~9.1.2",
-    "isomorphic-ws": "~5.0.0",
-    "@cityofzion/blockchain-service": "1.2.0",
+    "bignumber.js": "^9.1.2",
+    "isomorphic-ws": "^5.0.0",
+    "lodash.clonedeep": "^4.5.0",
+    "@cityofzion/blockchain-service": "1.3.0",
     "@cityofzion/bs-asteroid-sdk": "0.9.0"
   },
   "devDependencies": {
     "@cityofzion/neon-dappkit-types": "~0.3.1",
     "@ledgerhq/hw-transport-node-hid": "~6.28.5",
+    "@types/lodash.clonedeep": "^4.5.9",
     "@types/jest": "29.5.3",
     "@typescript-eslint/eslint-plugin": "^6.5.0",
     "@typescript-eslint/parser": "^6.5.0",
@@ -34,7 +36,7 @@
     "ts-jest": "29.1.1",
     "ts-node": "10.9.1",
     "typescript": "4.9.5",
-    "typed-emitter": "~2.1.0"
+    "typed-emitter": "^2.1.0"
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json",

package/dist/NeonDappKitLedgerServiceNeo3.js

@@ -1,110 +0,0 @@
-"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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NeonDappKitLedgerServiceNeo3 = void 0;
-const neon_js_1 = require("@cityofzion/neon-js");
-const neon_dappkit_1 = require("@cityofzion/neon-dappkit");
-const events_1 = __importDefault(require("events"));
-class NeonDappKitLedgerServiceNeo3 {
-    constructor(getLedgerTransport) {
-        this.getLedgerTransport = getLedgerTransport;
-        this.emitter = new events_1.default();
-    }
-    getAddress(transport) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const publicKey = yield this.getPublicKey(transport);
-            const { address } = new neon_js_1.wallet.Account(publicKey);
-            return address;
-        });
-    }
-    getSigningCallback(transport) {
-        return (transaction, { witnessIndex, network }) => __awaiter(this, void 0, void 0, function* () {
-            const publicKey = yield this.getPublicKey(transport);
-            const account = new neon_js_1.wallet.Account(publicKey);
-            const witnessScriptHash = neon_js_1.wallet.getScriptHashFromVerificationScript(transaction.witnesses[witnessIndex].verificationScript.toString());
-            if (account.scriptHash !== witnessScriptHash) {
-                throw new Error('Invalid witness script hash');
-            }
-            const signature = yield this.getSignature(transport, transaction.serialize(false), network, witnessIndex);
-            return signature;
-        });
-    }
-    getSignature(transport, serializedTransaction, networkMagic, addressIndex = 0) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                this.emitter.emit('getSignatureStart');
-                const bip44Buffer = this.toBip44Buffer(addressIndex);
-                yield transport.send(0x80, 0x02, 0, 0x80, bip44Buffer, [0x9000]);
-                yield transport.send(0x80, 0x02, 1, 0x80, Buffer.from(neon_dappkit_1.NeonParser.numToHex(networkMagic, 4, true), 'hex'), [
-                    0x9000,
-                ]);
-                const chunks = serializedTransaction.match(/.{1,510}/g) || [];
-                for (let i = 0; i < chunks.length - 1; i++) {
-                    yield transport.send(0x80, 0x02, 2 + i, 0x80, Buffer.from(chunks[i], 'hex'), [0x9000]);
-                }
-                const response = yield transport.send(0x80, 0x02, 2 + chunks.length, 0x00, Buffer.from(chunks[chunks.length - 1], 'hex'), [0x9000]);
-                if (response.length <= 2) {
-                    throw new Error(`No more data but Ledger did not return signature!`);
-                }
-                const signature = this.derSignatureToHex(response.toString('hex'));
-                return signature;
-            }
-            finally {
-                this.emitter.emit('getSignatureEnd');
-            }
-        });
-    }
-    getPublicKey(transport, addressIndex = 0) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const bip44Buffer = this.toBip44Buffer(addressIndex);
-            const result = yield transport.send(0x80, 0x04, 0x00, 0x00, bip44Buffer, [0x9000]);
-            const publicKey = result.toString('hex').substring(0, 130);
-            return publicKey;
-        });
-    }
-    toBip44Buffer(addressIndex = 0, changeIndex = 0, accountIndex = 0) {
-        const accountHex = this.to8BitHex(accountIndex + 0x80000000);
-        const changeHex = this.to8BitHex(changeIndex);
-        const addressHex = this.to8BitHex(addressIndex);
-        return Buffer.from('8000002C' + '80000378' + accountHex + changeHex + addressHex, 'hex');
-    }
-    to8BitHex(num) {
-        const hex = num.toString(16);
-        return '0'.repeat(8 - hex.length) + hex;
-    }
-    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('');
-    }
-}
-exports.NeonDappKitLedgerServiceNeo3 = NeonDappKitLedgerServiceNeo3;

package/dist/flamingo-swap/FlamingoSwapControllerService.d.ts

@@ -1,20 +0,0 @@
-import { Account, Network, SwapControllerService, SwapControllerServiceEvents, SwapControllerServiceSwapToReceiveArgs, SwapControllerServiceSwapToUseArgs, Token } from '@cityofzion/blockchain-service';
-import TypedEmitter from 'typed-emitter';
-import { BSNeo3NetworkId } from '../BSNeo3Helper';
-export declare class FlamingoSwapControllerService implements SwapControllerService<BSNeo3NetworkId> {
-    #private;
-    eventEmitter: TypedEmitter<SwapControllerServiceEvents>;
-    constructor(network: Network<BSNeo3NetworkId>);
-    buildSwapArgs(): SwapControllerServiceSwapToReceiveArgs<BSNeo3NetworkId> | SwapControllerServiceSwapToUseArgs<BSNeo3NetworkId>;
-    setAccountToUse(account: Account | null): void;
-    setAmountToUse(val: string | null): void;
-    setAmountToReceive(val: string | null): void;
-    setDeadline(deadline: string): void;
-    setSlippage(slippage: number): void;
-    setTokenToUse(val: Token | null): Promise<void>;
-    setTokenToReceive(val: Token | null): Promise<void>;
-    swap(isLedger?: boolean): Promise<void>;
-    setReserves(): Promise<void>;
-    startListeningBlockGeneration(): void;
-    stopListeningBlockGeneration(): void;
-}