@cityofzion/bs-neox 1.4.7 → 1.5.1

package/dist/BSNeoX.d.ts

@@ -1,5 +1,5 @@
 import { BSEthereum } from '@cityofzion/bs-ethereum';
-import { TGetLedgerTransport, INeo3NeoXBridgeService, TBSNetwork } from '@cityofzion/blockchain-service';
+import { TGetLedgerTransport, INeo3NeoXBridgeService, TBSNetwork, TTransferParam } from '@cityofzion/blockchain-service';
 import { IBSNeoX, TBSNeoXNetworkId } from './types';
 export declare class BSNeoX<N extends string = string> extends BSEthereum<N, TBSNeoXNetworkId> implements IBSNeoX<N> {
     neo3NeoXBridgeService: INeo3NeoXBridgeService<N>;
@@ -7,4 +7,5 @@ export declare class BSNeoX<N extends string = string> extends BSEthereum<N, TBS
     readonly availableNetworks: TBSNetwork<TBSNeoXNetworkId>[];
     constructor(name: N, network?: TBSNetwork<TBSNeoXNetworkId>, getLedgerTransport?: TGetLedgerTransport<N>);
     setNetwork(network: TBSNetwork<TBSNeoXNetworkId>): void;
+    transfer(params: TTransferParam<N>): Promise<string[]>;
 }

package/dist/BSNeoX.js

@@ -1,14 +1,41 @@
 "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.BSNeoX = void 0;
 const bs_ethereum_1 = require("@cityofzion/bs-ethereum");
 const BSNeoXConstants_1 = require("./constants/BSNeoXConstants");
 const blockchain_service_1 = require("@cityofzion/blockchain-service");
 const BlockscoutBDSNeoX_1 = require("./services/blockchain-data/BlockscoutBDSNeoX");
+const WalletConnectServiceNeoX_1 = require("./services/wallet-connect/WalletConnectServiceNeoX");
 const FlamingoForthewinEDSNeoX_1 = require("./services/exchange-data/FlamingoForthewinEDSNeoX");
 const BlockscoutESNeoX_1 = require("./services/explorer/BlockscoutESNeoX");
 const GhostMarketNDSNeoX_1 = require("./services/nft-data/GhostMarketNDSNeoX");
 const Neo3NeoXBridgeService_1 = require("./services/neo3neoXBridge/Neo3NeoXBridgeService");
+const ethers_1 = require("ethers");
+const axios_1 = __importDefault(require("axios"));
+const consensus_1 = require("./assets/abis/consensus");
+const key_management_1 = require("./assets/abis/key-management");
+const neox_tpke_1 = require("neox-tpke");
+const viem_1 = require("viem");
+// Necessary to run on Node.js
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-expect-error
+if (typeof self === 'undefined') {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    global.self = global;
+}
 class BSNeoX extends bs_ethereum_1.BSEthereum {
     constructor(name, network, getLedgerTransport) {
         super(name, undefined, undefined, getLedgerTransport);
@@ -20,20 +47,122 @@ class BSNeoX extends bs_ethereum_1.BSEthereum {
         this.setNetwork(network !== null && network !== void 0 ? network : this.defaultNetwork);
     }
     setNetwork(network) {
-        const availableURLs = BSNeoXConstants_1.BSNeoXConstants.RPC_LIST_BY_NETWORK_ID[network.id] || [];
-        const isValidNetwork = blockchain_service_1.BSUtilsHelper.validateNetwork(network, this.availableNetworks, availableURLs);
+        const rpcNetworkUrls = BSNeoXConstants_1.BSNeoXConstants.RPC_LIST_BY_NETWORK_ID[network.id] || [];
+        const isValidNetwork = blockchain_service_1.BSUtilsHelper.validateNetwork(network, this.availableNetworks, rpcNetworkUrls);
         if (!isValidNetwork) {
             throw new Error(`Network with id ${network.id} is not available for ${this.name}`);
         }
         this.network = network;
-        this.availableNetworkURLs = availableURLs;
+        this.rpcNetworkUrls = rpcNetworkUrls;
         this.nftDataService = new GhostMarketNDSNeoX_1.GhostMarketNDSNeoX(this);
         this.explorerService = new BlockscoutESNeoX_1.BlockscoutESNeoX(this);
         this.exchangeDataService = new FlamingoForthewinEDSNeoX_1.FlamingoForthewinEDSNeoX(this);
         this.neo3NeoXBridgeService = new Neo3NeoXBridgeService_1.Neo3NeoXBridgeService(this);
         this.blockchainDataService = new BlockscoutBDSNeoX_1.BlockscoutBDSNeoX(this);
         this.tokenService = new bs_ethereum_1.TokenServiceEthereum();
-        this.walletConnectService = new bs_ethereum_1.WalletConnectServiceEthereum(this);
+        this.walletConnectService = new WalletConnectServiceNeoX_1.WalletConnectServiceNeoX(this);
+    }
+    transfer(params) {
+        const _super = Object.create(null, {
+            transfer: { get: () => super.transfer }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const isAntiMevRpcNetworkUrl = BSNeoXConstants_1.BSNeoXConstants.ANTI_MEV_RPC_LIST_BY_NETWORK_ID[this.network.id].some(rpcNetworkUrl => rpcNetworkUrl === this.network.url);
+            if (!isAntiMevRpcNetworkUrl)
+                return yield _super.transfer.call(this, params);
+            const signer = yield this.generateSigner(params.senderAccount);
+            let nonce = yield signer.getTransactionCount();
+            if (isNaN(nonce)) {
+                throw new Error('Invalid nonce');
+            }
+            const chainId = +this.network.id;
+            if (isNaN(chainId)) {
+                throw new Error('Invalid chainId');
+            }
+            const transactionHashes = [];
+            let error;
+            for (const intent of params.intents) {
+                try {
+                    const { transactionParams, gasPrice } = yield this._buildTransferParams(intent);
+                    let gasLimit;
+                    try {
+                        gasLimit = yield signer.estimateGas(transactionParams);
+                    }
+                    catch (_b) {
+                        gasLimit = bs_ethereum_1.BSEthereumConstants.DEFAULT_GAS_LIMIT;
+                    }
+                    const [_transaction, transactionError] = yield blockchain_service_1.BSPromisesHelper.tryCatch(() => signer.sendTransaction(Object.assign(Object.assign({}, transactionParams), { chainId,
+                        nonce,
+                        gasLimit, maxPriorityFeePerGas: gasPrice, maxFeePerGas: gasPrice })));
+                    if (!(transactionError === null || transactionError === void 0 ? void 0 : transactionError.error) ||
+                        transactionError.error.code !== -32000 ||
+                        transactionError.error.message !== 'transaction cached') {
+                        throw new Error('Transaction not cached');
+                    }
+                    const signature = yield signer.signMessage(nonce.toString());
+                    const hexNonce = (0, viem_1.toHex)(nonce);
+                    // Keep using Axios because of the signer and provider don't have the eth_getCachedTransaction method
+                    const cachedTransactionResponse = yield axios_1.default.post(this.network.url, {
+                        id: Date.now(),
+                        jsonrpc: '2.0',
+                        method: 'eth_getCachedTransaction',
+                        params: [hexNonce, signature],
+                    });
+                    const cachedTransaction = cachedTransactionResponse.data.result;
+                    const consensusContract = new ethers_1.ethers.Contract(BSNeoXConstants_1.BSNeoXConstants.CONSENSUS_SCRIPT_HASH, consensus_1.CONSENSUS_ABI, signer);
+                    const consensusSize = BigInt(yield consensusContract.consensusSize());
+                    const keyManagementContract = new ethers_1.ethers.Contract(BSNeoXConstants_1.BSNeoXConstants.KEY_MANAGEMENT_SCRIPT_HASH, key_management_1.KEY_MANAGEMENT_ABI, signer);
+                    const roundNumber = BigInt(yield keyManagementContract.roundNumber());
+                    const aggregatedCommitment = yield keyManagementContract.aggregatedCommitments(roundNumber);
+                    const publicKey = neox_tpke_1.PublicKey.fromAggregatedCommitment((0, viem_1.toBytes)(aggregatedCommitment), (0, neox_tpke_1.getScaler)(consensusSize, (0, neox_tpke_1.getConsensusThreshold)(consensusSize)));
+                    const { encryptedKey, encryptedMsg } = publicKey.encrypt((0, viem_1.toBytes)(cachedTransaction));
+                    const parsedTransaction = (0, viem_1.parseTransaction)(cachedTransaction);
+                    const envelopedData = (0, viem_1.concat)([
+                        new Uint8Array([0xff, 0xff, 0xff, 0xff]),
+                        (0, viem_1.pad)((0, viem_1.toBytes)(roundNumber), { size: 4 }),
+                        (0, viem_1.pad)((0, viem_1.toBytes)(parsedTransaction.gas), { size: 4 }),
+                        (0, viem_1.toBytes)((0, viem_1.keccak256)(cachedTransaction)),
+                        encryptedKey,
+                        encryptedMsg,
+                    ]);
+                    const newTransactionParams = {
+                        chainId,
+                        nonce,
+                        to: BSNeoXConstants_1.BSNeoXConstants.GOVERNANCE_REWARD_SCRIPT_HASH,
+                        data: (0, viem_1.toHex)(envelopedData),
+                    };
+                    try {
+                        gasLimit = yield signer.estimateGas(newTransactionParams);
+                    }
+                    catch (_c) {
+                        gasLimit = bs_ethereum_1.BSEthereumConstants.DEFAULT_GAS_LIMIT;
+                    }
+                    const signedTransaction = yield signer.signTransaction(Object.assign({ gasLimit,
+                        gasPrice }, newTransactionParams));
+                    // Keep using Axios because of the signer and provider don't have the eth_sendRawTransaction method
+                    const transactionResponse = yield axios_1.default.post(this.network.url, {
+                        id: Date.now(),
+                        jsonrpc: '2.0',
+                        method: 'eth_sendRawTransaction',
+                        params: [signedTransaction],
+                    });
+                    const transactionHash = (_a = transactionResponse === null || transactionResponse === void 0 ? void 0 : transactionResponse.data) === null || _a === void 0 ? void 0 : _a.result;
+                    if (transactionHash) {
+                        transactionHashes.push(transactionHash);
+                        nonce++;
+                    }
+                }
+                catch (newError) {
+                    console.error(newError);
+                    if (!error)
+                        error = newError;
+                }
+            }
+            if (error && !transactionHashes.some(hash => !!hash))
+                throw error;
+            return transactionHashes;
+        });
     }
 }
 exports.BSNeoX = BSNeoX;

package/dist/assets/abis/consensus.d.ts

@@ -0,0 +1,46 @@
+export declare const CONSENSUS_ABI: ({
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    anonymous?: undefined;
+    outputs?: undefined;
+    stateMutability?: undefined;
+} | {
+    anonymous: boolean;
+    inputs: {
+        indexed: boolean;
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    type: string;
+    outputs?: undefined;
+    stateMutability?: undefined;
+} | {
+    inputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    name: string;
+    outputs: {
+        internalType: string;
+        name: string;
+        type: string;
+    }[];
+    stateMutability: string;
+    type: string;
+    anonymous?: undefined;
+} | {
+    stateMutability: string;
+    type: string;
+    inputs?: undefined;
+    name?: undefined;
+    anonymous?: undefined;
+    outputs?: undefined;
+})[];