@clonegod/ttd-base-common 1.0.5 → 1.0.7

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

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

package/dist/trade/send/ankr_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.AnkrBase = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const axios_1 = __importDefault(require("axios"));
+class AnkrBase {
+    constructor() {
+        this.endpoint = process.env.BASE_ANKR_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(`Ankr RPC error: ${response.data.error.message}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                (0, dist_1.log_info)(`Ankr transaction sending failed`, { error: error.message });
+                throw error;
+            }
+        });
+    }
+}
+exports.AnkrBase = AnkrBase;

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

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

package/dist/trade/send/blockpi_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.BlockpiBase = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const axios_1 = __importDefault(require("axios"));
+class BlockpiBase {
+    constructor() {
+        this.endpoint = process.env.BASE_BLOCKPI_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(`BlockPI RPC error: ${response.data.error.message}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                (0, dist_1.log_info)(`BlockPI transaction sending failed`, { error: error.message });
+                throw error;
+            }
+        });
+    }
+}
+exports.BlockpiBase = BlockpiBase;

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

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

package/dist/trade/send/chainstack_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.ChainstackBase = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const axios_1 = __importDefault(require("axios"));
+class ChainstackBase {
+    constructor() {
+        this.endpoint = process.env.BASE_CHAINSTACK_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(`Chainstack RPC error: ${response.data.error.message}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                (0, dist_1.log_info)(`Chainstack transaction sending failed`, { error: error.message });
+                throw error;
+            }
+        });
+    }
+}
+exports.ChainstackBase = ChainstackBase;

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

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

package/dist/trade/send/getblock_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.GetblockBase = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const axios_1 = __importDefault(require("axios"));
+class GetblockBase {
+    constructor() {
+        this.endpoint = process.env.BASE_GETBLOCK_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(`GetBlock RPC error: ${response.data.error.message}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                (0, dist_1.log_info)(`GetBlock transaction sending failed`, { error: error.message });
+                throw error;
+            }
+        });
+    }
+}
+exports.GetblockBase = GetblockBase;

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

@@ -1,3 +1,15 @@
 export * from './send_tx';
+export * from './alchemy_base';
+export * from './base_rpc';
+export * from './bloxroute_base';
+export * from './drpc_base';
+export * from './quicknode_base';
+export * from './infura_base';
+export * from './blockpi_base';
+export * from './getblock_base';
+export * from './ankr_base';
+export * from './chainstack_base';
+export * from './moralis_base';
+export * from './onerpc_base';
 export declare enum BASE_EOA_ADDRESS {
 }

package/dist/trade/send/index.js

@@ -16,6 +16,18 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BASE_EOA_ADDRESS = void 0;
 __exportStar(require("./send_tx"), exports);
+__exportStar(require("./alchemy_base"), exports);
+__exportStar(require("./base_rpc"), exports);
+__exportStar(require("./bloxroute_base"), exports);
+__exportStar(require("./drpc_base"), exports);
+__exportStar(require("./quicknode_base"), exports);
+__exportStar(require("./infura_base"), exports);
+__exportStar(require("./blockpi_base"), exports);
+__exportStar(require("./getblock_base"), exports);
+__exportStar(require("./ankr_base"), exports);
+__exportStar(require("./chainstack_base"), exports);
+__exportStar(require("./moralis_base"), exports);
+__exportStar(require("./onerpc_base"), exports);
 var BASE_EOA_ADDRESS;
 (function (BASE_EOA_ADDRESS) {
 })(BASE_EOA_ADDRESS || (exports.BASE_EOA_ADDRESS = BASE_EOA_ADDRESS = {}));

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

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

package/dist/trade/send/moralis_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.MoralisBase = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const axios_1 = __importDefault(require("axios"));
+class MoralisBase {
+    constructor() {
+        this.endpoint = process.env.BASE_MORALIS_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(`Moralis RPC error: ${response.data.error.message}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                (0, dist_1.log_info)(`Moralis transaction sending failed`, { error: error.message });
+                throw error;
+            }
+        });
+    }
+}
+exports.MoralisBase = MoralisBase;

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

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

package/dist/trade/send/onerpc_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.OneRpcBase = void 0;
+const dist_1 = require("@clonegod/ttd-core/dist");
+const axios_1 = __importDefault(require("axios"));
+class OneRpcBase {
+    constructor() {
+        this.endpoint = process.env.BASE_1RPC_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(`1RPC error: ${response.data.error.message}`);
+                }
+                return response.data.result;
+            }
+            catch (error) {
+                (0, dist_1.log_info)(`1RPC transaction sending failed`, { error: error.message });
+                throw error;
+            }
+        });
+    }
+}
+exports.OneRpcBase = OneRpcBase;

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

@@ -2,10 +2,16 @@ import { AppConfig } from "@clonegod/ttd-core/dist";
 export declare class BaseTransactionSender {
     private rpc;
     private quicknode;
-    private bloxroute;
     private alchemy;
     private infura;
     private drpc;
+    private blockpi;
+    private getblock;
+    private ankr;
+    private chainstack;
+    private oneRpc;
+    private moralis;
+    private bloxroute;
     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

@@ -17,14 +17,26 @@ 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");
+const blockpi_base_1 = require("./blockpi_base");
+const getblock_base_1 = require("./getblock_base");
+const ankr_base_1 = require("./ankr_base");
+const chainstack_base_1 = require("./chainstack_base");
+const moralis_base_1 = require("./moralis_base");
+const onerpc_base_1 = require("./onerpc_base");
 class BaseTransactionSender {
     constructor(appConfig) {
         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();
+        this.blockpi = new blockpi_base_1.BlockpiBase();
+        this.getblock = new getblock_base_1.GetblockBase();
+        this.ankr = new ankr_base_1.AnkrBase();
+        this.chainstack = new chainstack_base_1.ChainstackBase();
+        this.oneRpc = new onerpc_base_1.OneRpcBase();
+        this.moralis = new moralis_base_1.MoralisBase();
+        this.bloxroute = new bloxroute_base_1.BloxrouteBase();
     }
     sendTransaction(signedMainTx, eoa_tip_transaction, order_trace_id) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -64,6 +76,48 @@ class BaseTransactionSender {
                         return yield this.infura.sendTransaction(signedMainTx);
                     })
                 },
+                {
+                    name: 'Base BlockPI RPC',
+                    enable: process.env.SEND_TX_BASE_BLOCKPI_RPC === 'true',
+                    send: () => __awaiter(this, void 0, void 0, function* () {
+                        return yield this.blockpi.sendTransaction(signedMainTx);
+                    })
+                },
+                {
+                    name: 'Base GetBlock RPC',
+                    enable: process.env.SEND_TX_BASE_GETBLOCK_RPC === 'true',
+                    send: () => __awaiter(this, void 0, void 0, function* () {
+                        return yield this.getblock.sendTransaction(signedMainTx);
+                    })
+                },
+                {
+                    name: 'Base Ankr RPC',
+                    enable: process.env.SEND_TX_BASE_ANKR_RPC === 'true',
+                    send: () => __awaiter(this, void 0, void 0, function* () {
+                        return yield this.ankr.sendTransaction(signedMainTx);
+                    })
+                },
+                {
+                    name: 'Base Chainstack RPC',
+                    enable: process.env.SEND_TX_BASE_CHAINSTACK_RPC === 'true',
+                    send: () => __awaiter(this, void 0, void 0, function* () {
+                        return yield this.chainstack.sendTransaction(signedMainTx);
+                    })
+                },
+                {
+                    name: 'Base Moralis RPC',
+                    enable: process.env.SEND_TX_BASE_MORALIS_RPC === 'true',
+                    send: () => __awaiter(this, void 0, void 0, function* () {
+                        return yield this.moralis.sendTransaction(signedMainTx);
+                    })
+                },
+                {
+                    name: 'Base 1RPC',
+                    enable: process.env.SEND_TX_BASE_1RPC_RPC === 'true',
+                    send: () => __awaiter(this, void 0, void 0, function* () {
+                        return yield this.oneRpc.sendTransaction(signedMainTx);
+                    })
+                },
                 {
                     name: 'BloXroute - Private Transaction',
                     enable: process.env.SEND_TX_BLOXROUTE_PRIVATE === 'true',

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@clonegod/ttd-base-common",
-    "version": "1.0.5",
+    "version": "1.0.7",
     "description": "Base common library",
     "license": "UNLICENSED",
     "main": "dist/index.js",
@@ -14,7 +14,7 @@
         "push": "npm run build && npm publish"
     },
     "dependencies": {
-        "@clonegod/ttd-core": "2.0.45",
+        "@clonegod/ttd-core": "2.0.46",
         "axios": "^1.11.00",
         "dotenv": "^16.4.7",
         "ethers": "^5.8.0"