@clonegod/ttd-base-common 1.0.0 → 1.0.1

package/dist/common/constants.d.ts

@@ -16,3 +16,4 @@ export declare const EVENT_SIGNATURES: {
     BURN: string;
 };
 export declare const UniswapV3PoolABI: string[];
+export declare const UniswapV3RouterABI: string[];

package/dist/common/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.UniswapV3PoolABI = exports.EVENT_SIGNATURES = exports.EVENT_NAMES = exports.WETH_ADDRESS = exports.BASE_CHAIN_ID = void 0;
+exports.UniswapV3RouterABI = exports.UniswapV3PoolABI = exports.EVENT_SIGNATURES = exports.EVENT_NAMES = exports.WETH_ADDRESS = exports.BASE_CHAIN_ID = void 0;
 exports.BASE_CHAIN_ID = 8453;
 exports.WETH_ADDRESS = '0x4200000000000000000000000000000000000006';
 exports.EVENT_NAMES = {
@@ -32,3 +32,11 @@ exports.UniswapV3PoolABI = [
     "event Mint(address sender, address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1)",
     "event Burn(address indexed owner, int24 indexed tickLower, int24 indexed tickUpper, uint128 amount, uint256 amount0, uint256 amount1)"
 ];
+exports.UniswapV3RouterABI = [
+    'function exactInputSingle(tuple(address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96)) external payable returns (uint256 amountOut)',
+    'function exactInput(tuple(bytes path, address recipient, uint256 deadline, uint256 amountIn, uint256 amountOutMinimum)) external payable returns (uint256 amountOut)',
+    'function exactOutputSingle(tuple(address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum, uint160 sqrtPriceLimitX96)) external payable returns (uint256 amountIn)',
+    'function exactOutput(tuple(bytes path, address recipient, uint256 deadline, uint256 amountOut, uint256 amountInMaximum)) external payable returns (uint256 amountIn)',
+    'function factory() external view returns (address)',
+    'function WETH9() external view returns (address)'
+];

package/dist/trade/send/alchemy_base.d.ts

@@ -0,0 +1,5 @@
+export declare class AlchemyBase {
+    private endpoint;
+    constructor();
+    sendTransaction(signedTx: string): Promise<string>;
+}

package/dist/trade/send/alchemy_base.js

@@ -0,0 +1,48 @@
+"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.AlchemyBase = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const axios_1 = __importDefault(require("axios"));
+class AlchemyBase {
+    constructor() {
+        this.endpoint = process.env.BASE_ALCHEMY_RPC_ENDPOINT || '';
+    }
+    sendTransaction(signedTx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield axios_1.default.post(this.endpoint, {
+                    jsonrpc: '2.0',
+                    method: 'eth_sendRawTransaction',
+                    params: [signedTx],
+                    id: 1
+                }, {
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    timeout: 3000
+                });
+                if (response.data.error) {
+                    throw new Error(`Alchemy RPC error: ${response.data.error.message}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                (0, dist_1.log_info)(`Alchemy transaction sending failed`, { error: error.message });
+                throw error;
+            }
+        });
+    }
+}
+exports.AlchemyBase = AlchemyBase;

package/dist/trade/send/base_rpc.d.ts

@@ -0,0 +1,5 @@
+export declare class BaseRpc {
+    private endpoint;
+    constructor(rpc_endpoint: string);
+    eth_sendRawTransaction(signedTx: string): Promise<string>;
+}

package/dist/trade/send/base_rpc.js

@@ -0,0 +1,48 @@
+"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.BaseRpc = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const axios_1 = __importDefault(require("axios"));
+class BaseRpc {
+    constructor(rpc_endpoint) {
+        this.endpoint = rpc_endpoint || process.env.BASE_OFFICIAL_RPC_ENDPOINT || 'https://mainnet.base.org';
+    }
+    eth_sendRawTransaction(signedTx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield axios_1.default.post(this.endpoint, {
+                    jsonrpc: "2.0",
+                    method: "eth_sendRawTransaction",
+                    params: [signedTx],
+                    id: 1
+                }, {
+                    headers: {
+                        "Content-Type": "application/json"
+                    },
+                    timeout: 3000
+                });
+                if (response.data.error) {
+                    throw new Error(`Base Mainnet RPC error: ${response.data.error.message}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                (0, dist_1.log_info)(`Base Mainnet transaction sending failed`, { error: error.message });
+                throw error;
+            }
+        });
+    }
+}
+exports.BaseRpc = BaseRpc;

package/dist/trade/send/bloxroute_base.d.ts

@@ -0,0 +1,7 @@
+export declare class BloxrouteBase {
+    private endpoint;
+    private authToken;
+    constructor();
+    sendPrivateTransaction(signedTx: string): Promise<string>;
+    sendBundle(transactions: string[], targetBlockNumber?: number): Promise<string>;
+}

package/dist/trade/send/bloxroute_base.js

@@ -0,0 +1,83 @@
+"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.BloxrouteBase = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const axios_1 = __importDefault(require("axios"));
+class BloxrouteBase {
+    constructor() {
+        this.endpoint = process.env.BASE_BLOXROUTE_RPC_ENDPOINT || '';
+        this.authToken = process.env.BASE_BLOXROUTE_AUTH_TOKEN || '';
+    }
+    sendPrivateTransaction(signedTx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield axios_1.default.post(this.endpoint, {
+                    jsonrpc: "2.0",
+                    id: "1",
+                    method: "eth_sendPrivateTransaction",
+                    params: [signedTx]
+                }, {
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': this.authToken
+                    },
+                    timeout: 3000
+                });
+                if (response.data.error) {
+                    throw new Error(`BloXroute Base Error: ${response.data.error.code} - ${response.data.error.message}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                (0, dist_1.log_error)('BloXroute Base sendPrivateTransaction failed!!!', error);
+                throw error;
+            }
+        });
+    }
+    sendBundle(transactions, targetBlockNumber) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const currentBlock = targetBlockNumber || Math.floor(Date.now() / 1000);
+                const targetBlock = currentBlock + 1;
+                const response = yield axios_1.default.post(this.endpoint, {
+                    jsonrpc: "2.0",
+                    id: "1",
+                    method: "eth_sendBundle",
+                    params: [{
+                            txs: transactions,
+                            blockNumber: `0x${targetBlock.toString(16)}`,
+                            minTimestamp: Math.floor(Date.now() / 1000),
+                            maxTimestamp: Math.floor(Date.now() / 1000) + 30
+                        }]
+                }, {
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'Authorization': this.authToken
+                    },
+                    timeout: 3000
+                });
+                if (response.data.error) {
+                    throw new Error(`BloXroute Base Bundle Error: ${response.data.error.code} - ${response.data.error.message}`);
+                }
+                return response.data.result.bundleHash;
+            }
+            catch (error) {
+                (0, dist_1.log_error)('BloXroute Base sendBundle failed!!!', error);
+                throw error;
+            }
+        });
+    }
+}
+exports.BloxrouteBase = BloxrouteBase;

package/dist/trade/send/drpc_base.d.ts

@@ -0,0 +1,5 @@
+export declare class DrpcBase {
+    private endpoint;
+    constructor();
+    sendTransaction(signedTx: string): Promise<string>;
+}

package/dist/trade/send/drpc_base.js

@@ -0,0 +1,48 @@
+"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.DrpcBase = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const axios_1 = __importDefault(require("axios"));
+class DrpcBase {
+    constructor() {
+        this.endpoint = process.env.BASE_DRPC_RPC_ENDPOINT || '';
+    }
+    sendTransaction(signedTx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield axios_1.default.post(this.endpoint, {
+                    jsonrpc: '2.0',
+                    method: 'eth_sendRawTransaction',
+                    params: [signedTx],
+                    id: 1
+                }, {
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    timeout: 3000
+                });
+                if (response.data.error) {
+                    throw new Error(`DRPC RPC error: ${response.data.error.message}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                (0, dist_1.log_info)(`DRPC transaction sending failed`, { error: error.message });
+                throw error;
+            }
+        });
+    }
+}
+exports.DrpcBase = DrpcBase;

package/dist/trade/send/index.d.ts

@@ -1,5 +1,3 @@
 export * from './send_tx';
-export declare enum BSC_EOA_ADDRESS {
-    BLOCKRAZOR = "0x1266C6bE60392A8Ff346E8d5ECCd3E69dD9c5F20",
-    _48CLUB = "0x4848489f0b2BEdd788c696e2D79b6b69D7484848"
+export declare enum BASE_EOA_ADDRESS {
 }

package/dist/trade/send/index.js

@@ -14,10 +14,8 @@ 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 });
-exports.BSC_EOA_ADDRESS = void 0;
+exports.BASE_EOA_ADDRESS = void 0;
 __exportStar(require("./send_tx"), exports);
-var BSC_EOA_ADDRESS;
-(function (BSC_EOA_ADDRESS) {
-    BSC_EOA_ADDRESS["BLOCKRAZOR"] = "0x1266C6bE60392A8Ff346E8d5ECCd3E69dD9c5F20";
-    BSC_EOA_ADDRESS["_48CLUB"] = "0x4848489f0b2BEdd788c696e2D79b6b69D7484848";
-})(BSC_EOA_ADDRESS || (exports.BSC_EOA_ADDRESS = BSC_EOA_ADDRESS = {}));
+var BASE_EOA_ADDRESS;
+(function (BASE_EOA_ADDRESS) {
+})(BASE_EOA_ADDRESS || (exports.BASE_EOA_ADDRESS = BASE_EOA_ADDRESS = {}));

package/dist/trade/send/infura_base.d.ts

@@ -0,0 +1,5 @@
+export declare class InfuraBase {
+    private endpoint;
+    constructor();
+    sendTransaction(signedTx: string): Promise<string>;
+}

package/dist/trade/send/infura_base.js

@@ -0,0 +1,48 @@
+"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.InfuraBase = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const axios_1 = __importDefault(require("axios"));
+class InfuraBase {
+    constructor() {
+        this.endpoint = process.env.BASE_INFURA_RPC_ENDPOINT || '';
+    }
+    sendTransaction(signedTx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield axios_1.default.post(this.endpoint, {
+                    jsonrpc: '2.0',
+                    method: 'eth_sendRawTransaction',
+                    params: [signedTx],
+                    id: 1
+                }, {
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    timeout: 3000
+                });
+                if (response.data.error) {
+                    throw new Error(`Infura RPC error: ${response.data.error.message}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                (0, dist_1.log_info)(`Infura transaction sending failed`, { error: error.message });
+                throw error;
+            }
+        });
+    }
+}
+exports.InfuraBase = InfuraBase;

package/dist/trade/send/quicknode_base.d.ts

@@ -0,0 +1,5 @@
+export declare class QuickNodeBase {
+    private endpoint;
+    constructor();
+    sendTransaction(signedTx: string): Promise<string>;
+}

package/dist/trade/send/quicknode_base.js

@@ -0,0 +1,48 @@
+"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.QuickNodeBase = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const axios_1 = __importDefault(require("axios"));
+class QuickNodeBase {
+    constructor() {
+        this.endpoint = process.env.BASE_QUICKNODE_RPC_ENDPOINT || '';
+    }
+    sendTransaction(signedTx) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield axios_1.default.post(this.endpoint, {
+                    jsonrpc: "2.0",
+                    id: "1",
+                    method: "eth_sendRawTransaction",
+                    params: [signedTx]
+                }, {
+                    headers: {
+                        'Content-Type': 'application/json'
+                    },
+                    timeout: 3000
+                });
+                if (response.data.error) {
+                    throw new Error(`QuickNode Base Error: ${response.data.error.code} - ${response.data.error.message}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                (0, dist_1.log_error)('QuickNode Base sendTransaction failed!!!', error);
+                throw error;
+            }
+        });
+    }
+}
+exports.QuickNodeBase = QuickNodeBase;

package/dist/trade/send/send_tx.d.ts

@@ -1,8 +1,11 @@
 import { AppConfig } from "@clonegod/ttd-core/dist";
-export declare class TransactionSender {
+export declare class BaseTransactionSender {
     private rpc;
-    private blockRazor;
-    private _48Club;
+    private quicknode;
+    private bloxroute;
+    private alchemy;
+    private infura;
+    private drpc;
     constructor(appConfig: AppConfig);
     sendTransaction(signedMainTx: string, eoa_tip_transaction: (eoa_address: string) => Promise<string>, order_trace_id: string): Promise<string[]>;
 }

package/dist/trade/send/send_tx.js

@@ -9,56 +9,66 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionSender = void 0;
+exports.BaseTransactionSender = void 0;
 const dist_1 = require("@clonegod/ttd-core/dist");
-const blockrazor_1 = require("./blockrazor");
-const bsc_rpc_1 = require("./bsc_rpc");
-const _48club_1 = require("./48club");
-const _1 = require(".");
-class TransactionSender {
+const base_rpc_1 = require("./base_rpc");
+const quicknode_base_1 = require("./quicknode_base");
+const bloxroute_base_1 = require("./bloxroute_base");
+const alchemy_base_1 = require("./alchemy_base");
+const infura_base_1 = require("./infura_base");
+const drpc_base_1 = require("./drpc_base");
+class BaseTransactionSender {
     constructor(appConfig) {
-        this.rpc = new bsc_rpc_1.BscRpc(appConfig.env_args.rpc_endpoint);
-        this.blockRazor = new blockrazor_1.BlockRazorTrade();
-        this._48Club = new _48club_1._48ClubTrade();
+        this.rpc = new base_rpc_1.BaseRpc(appConfig.env_args.rpc_endpoint);
+        this.quicknode = new quicknode_base_1.QuickNodeBase();
+        this.bloxroute = new bloxroute_base_1.BloxrouteBase();
+        this.alchemy = new alchemy_base_1.AlchemyBase();
+        this.infura = new infura_base_1.InfuraBase();
+        this.drpc = new drpc_base_1.DrpcBase();
     }
     sendTransaction(signedMainTx, eoa_tip_transaction, order_trace_id) {
         return __awaiter(this, void 0, void 0, function* () {
             const rpcProviders = [
                 {
-                    name: 'Default (QuickNode / Merkle)',
-                    enable: process.env.SEND_TX_DEFAULT_RPC_PRIVATE === 'true',
+                    name: 'Base Official RPC',
+                    enable: process.env.SEND_TX_BASE_OFFICIAL_RPC === 'true' || true,
                     send: () => __awaiter(this, void 0, void 0, function* () {
                         return yield this.rpc.eth_sendRawTransaction(signedMainTx);
                     })
                 },
                 {
-                    name: 'BlockRazor - Private Transaction',
-                    enable: process.env.SEND_TX_BLOCKRAZOR_PRIVATE === 'true',
+                    name: 'Base QuickNode RPC',
+                    enable: process.env.SEND_TX_BASE_QUICKNODE_RPC === 'true',
                     send: () => __awaiter(this, void 0, void 0, function* () {
-                        return yield this.blockRazor.sendPrivateTransaction(signedMainTx);
+                        return yield this.quicknode.sendTransaction(signedMainTx);
                     })
                 },
                 {
-                    name: 'BlockRazor - sendBundle',
-                    enable: process.env.SEND_TX_BLOCKRAZOR_BUNDLE === 'true',
+                    name: 'Base DRPC RPC',
+                    enable: process.env.SEND_TX_BASE_DRPC_RPC === 'true',
                     send: () => __awaiter(this, void 0, void 0, function* () {
-                        let bundle = [signedMainTx, yield eoa_tip_transaction(_1.BSC_EOA_ADDRESS.BLOCKRAZOR)];
-                        return yield this.blockRazor.sendBundle(bundle);
+                        return yield this.drpc.sendTransaction(signedMainTx);
                     })
                 },
                 {
-                    name: '48Club - Private Transaction',
-                    enable: process.env.SEND_TX_48CLUB_PRIVATE === 'true',
+                    name: 'Base Alchemy RPC',
+                    enable: process.env.SEND_TX_BASE_ALCHEMY_RPC === 'true',
                     send: () => __awaiter(this, void 0, void 0, function* () {
-                        return yield this._48Club.sendPrivateTransaction(signedMainTx);
+                        return yield this.alchemy.sendTransaction(signedMainTx);
                     })
                 },
                 {
-                    name: '48Club - sendBundle',
-                    enable: process.env.SEND_TX_48CLUB_BUNDLE === 'true',
+                    name: 'Base Infura RPC',
+                    enable: process.env.SEND_TX_BASE_INFURA_RPC === 'true',
                     send: () => __awaiter(this, void 0, void 0, function* () {
-                        let bundle = [signedMainTx, yield eoa_tip_transaction(_1.BSC_EOA_ADDRESS._48CLUB)];
-                        return yield this._48Club.sendBundle({ txs: bundle });
+                        return yield this.infura.sendTransaction(signedMainTx);
+                    })
+                },
+                {
+                    name: 'BloXroute - Private Transaction',
+                    enable: process.env.SEND_TX_BLOXROUTE_PRIVATE === 'true',
+                    send: () => __awaiter(this, void 0, void 0, function* () {
+                        return yield this.bloxroute.sendPrivateTransaction(signedMainTx);
                     })
                 }
             ];
@@ -68,24 +78,32 @@ class TransactionSender {
                 try {
                     const txHash = yield provider.send();
                     results.push(txHash);
-                    (0, dist_1.log_info)(`Transaction sent successfully`, { provider: provider.name, order_trace_id, txHash });
+                    (0, dist_1.log_info)(`Base transaction sent successfully`, {
+                        provider: provider.name,
+                        order_trace_id,
+                        txHash
+                    });
                 }
                 catch (error) {
                     errors.push(`${provider.name}: ${error.message}`);
-                    (0, dist_1.log_info)(`Transaction sending failed`, { provider: provider.name, order_trace_id, error: error.message });
+                    (0, dist_1.log_info)(`Base transaction sending failed`, {
+                        provider: provider.name,
+                        order_trace_id,
+                        error: error.message
+                    });
                 }
             })));
             if (errors.some(error => error.includes('nonce'))) {
-                throw new Error(`!!!!!! Some RPC providers returned nonce error: ${JSON.stringify(errors)}`);
+                throw new Error(`!!!!!! Some Base RPC providers returned nonce error: ${JSON.stringify(errors)}`);
             }
-            if (errors.some(error => error.includes('bundle already exist') || error.includes('already known'))) {
+            if (errors.some(error => error.includes('already known') || error.includes('already exist'))) {
                 return results;
             }
             if (results.length === 0 || errors.length > 0) {
-                throw new Error(`!!!!!! Some RPC providers failed to send transactions: ${JSON.stringify(errors)}`);
+                throw new Error(`!!!!!! Some Base RPC providers failed to send transactions: ${JSON.stringify(errors)}`);
             }
             return results;
         });
     }
 }
-exports.TransactionSender = TransactionSender;
+exports.BaseTransactionSender = BaseTransactionSender;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clonegod/ttd-base-common",
-    "version": "1.0.0",
+    "version": "1.0.1",
     "description": "Base common library",
     "license": "UNLICENSED",
     "main": "dist/index.js",