otomato-sdk 1.0.0

package/dist/src/models/Trigger.js

@@ -0,0 +1,110 @@
+import { ethers } from 'ethers';
+export class Trigger {
+    constructor(trigger) {
+        this.id = trigger.id;
+        this.name = trigger.name;
+        this.description = trigger.description;
+        this.type = trigger.type;
+        this.parameters = {};
+        this.keyMap = {};
+        trigger.parameters.forEach(param => {
+            this.parameters[param.key] = Object.assign(Object.assign({}, param), { value: null });
+            const simplifiedKey = this.getSimplifiedKey(param.key);
+            this.keyMap[simplifiedKey] = param.key;
+        });
+    }
+    setChainId(value) {
+        this.setParameter('chainId', value);
+    }
+    setContractAddress(value) {
+        this.setParameter('contractAddress', value);
+    }
+    setCondition(value) {
+        if (this.type !== 1) {
+            throw new Error('Condition setting is not applicable for subscription based triggers.');
+        }
+        this.setParameter('condition', value);
+    }
+    setComparisonValue(value) {
+        if (this.type !== 1) {
+            throw new Error('Comparison value setting is not applicable for subscription based triggers.');
+        }
+        this.setParameter('comparisonValue', value);
+    }
+    setInterval(value) {
+        if (this.type !== 1) {
+            throw new Error('Interval setting is not applicable for subscription based triggers.');
+        }
+        this.setParameter('interval', value);
+    }
+    setParams(key, value) {
+        const fullKey = `abiParams.${key}`;
+        if (fullKey in this.parameters) {
+            this.setParameter(fullKey, value);
+        }
+        else {
+            throw new Error(`Parameter with simplified key ${key} not found in abiParams`);
+        }
+    }
+    setParameter(key, value) {
+        if (key in this.parameters) {
+            const param = this.parameters[key];
+            if (this.validateType(param.type, value)) {
+                this.parameters[key].value = value;
+            }
+            else {
+                throw new Error(`Invalid type for parameter ${key}. Expected ${param.type}.`);
+            }
+        }
+        else {
+            throw new Error(`Parameter with key ${key} not found`);
+        }
+    }
+    validateType(expectedType, value) {
+        switch (expectedType) {
+            case 'int':
+            case 'integer':
+            case 'uint256':
+            case 'int256':
+                return Number.isInteger(value);
+            case 'address':
+                return typeof value === 'string' && this.isAddress(value);
+            case 'float':
+                return typeof value === 'number';
+            case 'logic_operator':
+                const validOperators = new Set(['<', '>', '<=', '>=', '==']);
+                return typeof value === 'string' && validOperators.has(value);
+            case 'any':
+                return true;
+            default:
+                return false;
+        }
+    }
+    isAddress(value) {
+        return ethers.isAddress(value);
+    }
+    getParameter(key) {
+        if (key in this.parameters) {
+            return this.parameters[key].value;
+        }
+        else {
+            throw new Error(`Parameter with key ${key} not found`);
+        }
+    }
+    getParameters() {
+        return Object.keys(this.parameters).reduce((acc, key) => {
+            acc[key] = this.parameters[key].value;
+            return acc;
+        }, {});
+    }
+    toJSON() {
+        const json = {
+            id: this.id,
+            parameters: this.getParameters(),
+        };
+        return json;
+    }
+    getSimplifiedKey(key) {
+        return key.replace(/[.\[\]]/g, '_');
+    }
+}

package/dist/src/services/ApiService.js

@@ -0,0 +1 @@
+export {};

package/dist/src/services/AutomationService.js

@@ -0,0 +1 @@
+export {};

package/dist/test/trigger.spec.js

@@ -0,0 +1,72 @@
+import { expect } from 'chai';
+import { Trigger, TRIGGERS, getToken, CHAINS } from '../src/index';
+const DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
+describe('Trigger Class', () => {
+    it('should create a transfer trigger without parameters', () => {
+        const transferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+        const params = transferTrigger.getParameters();
+        expect(params.chainId).to.be.null;
+        expect(params['abiParams.value']).to.be.null;
+        expect(params['abiParams.to']).to.be.null;
+        expect(params.contractAddress).to.be.null;
+    });
+    it('should create a transfer trigger and set parameters correctly', () => {
+        const transferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+        transferTrigger.setChainId(CHAINS.ETHEREUM);
+        transferTrigger.setParams("value", 1000);
+        transferTrigger.setParams("to", DEFAULT_ADDRESS);
+        transferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        const params = transferTrigger.getParameters();
+        expect(params.chainId).to.equal(CHAINS.ETHEREUM);
+        expect(params['abiParams.value']).to.equal(1000);
+        expect(params['abiParams.to']).to.equal(DEFAULT_ADDRESS);
+        expect(params.contractAddress).to.equal(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    });
+    it('should be able to export a trigger as json', () => {
+        const transferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+        transferTrigger.setChainId(CHAINS.ETHEREUM);
+        transferTrigger.setParams("value", 1000);
+        transferTrigger.setParams("to", DEFAULT_ADDRESS);
+        transferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        const json = transferTrigger.toJSON();
+        expect(json).to.deep.equal({
+            id: TRIGGERS.TOKENS.ERC20.TRANSFER.id,
+            parameters: {
+                chainId: CHAINS.ETHEREUM,
+                'abiParams.value': 1000,
+                'abiParams.to': DEFAULT_ADDRESS,
+                contractAddress: getToken(CHAINS.ETHEREUM, 'USDC').contractAddress
+            }
+        });
+    });
+    it('should create a balance trigger with polling parameters correctly', () => {
+        const balanceTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.BALANCE);
+        balanceTrigger.setChainId(CHAINS.ETHEREUM);
+        balanceTrigger.setParams("account", DEFAULT_ADDRESS);
+        balanceTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        balanceTrigger.setCondition(">");
+        balanceTrigger.setComparisonValue(45000);
+        balanceTrigger.setInterval(5000);
+        const params = balanceTrigger.getParameters();
+        expect(params.chainId).to.equal(CHAINS.ETHEREUM);
+        expect(params['abiParams.account']).to.equal(DEFAULT_ADDRESS);
+        expect(params.contractAddress).to.equal(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        expect(balanceTrigger.toJSON().condition).to.equal(">");
+        expect(balanceTrigger.toJSON().comparisonValue).to.equal(45000);
+        expect(balanceTrigger.toJSON().interval).to.equal(5000);
+    });
+    it('should not be able to set conditions, comparison value and interval for subscription based triggers', () => {
+        const transferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+        expect(() => transferTrigger.setCondition(">")).to.throw('Condition setting is not applicable for subscription based triggers.');
+        expect(() => transferTrigger.setComparisonValue(45000)).to.throw('Comparison value setting is not applicable for subscription based triggers.');
+        expect(() => transferTrigger.setInterval(5000)).to.throw('Interval setting is not applicable for subscription based triggers.');
+    });
+    it('should throw an error for invalid parameter type', () => {
+        const transferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+        expect(() => transferTrigger.setParams("value", "invalid")).to.throw('Invalid type for parameter abiParams.value. Expected uint256.');
+    });
+    it('should throw an error for invalid address', () => {
+        const transferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+        expect(() => transferTrigger.setParams("to", "invalid_address")).to.throw('Invalid type for parameter abiParams.to. Expected address.');
+    });
+});

package/dist/types/examples/create-trigger-list.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/examples/create-trigger.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/src/constants/ActionBlocks.d.ts

@@ -0,0 +1,91 @@
+import { Parameter } from '../models/Parameter.js';
+export declare const TRIGGERS: {
+    TOKENS: {
+        ERC20: {
+            CHAINS: number[];
+            TRANSFER: {
+                id: number;
+                name: string;
+                description: string;
+                type: number;
+                parameters: Parameter[];
+            };
+            BALANCE: {
+                id: number;
+                name: string;
+                description: string;
+                type: number;
+                parameters: Parameter[];
+            };
+        };
+    };
+    YIELD: {
+        SPLICE_FI: {
+            CHAINS: number[];
+            SWAP: {
+                id: number;
+                name: string;
+                description: string;
+                type: number;
+                parameters: Parameter[];
+            };
+            LIQUIDITY_REMOVED: {
+                id: number;
+                name: string;
+                description: string;
+                type: number;
+                parameters: Parameter[];
+            };
+            MARKET_CREATION: {
+                id: number;
+                name: string;
+                description: string;
+                type: number;
+                parameters: Parameter[];
+            };
+            INTEREST_RATE_UPDATE: {
+                id: number;
+                name: string;
+                description: string;
+                type: number;
+                parameters: Parameter[];
+            };
+        };
+    };
+    LENDING: {
+        ASTARIA: {
+            CHAINS: number[];
+            LEND_RECALLED: {
+                id: number;
+                name: string;
+                description: string;
+                type: number;
+                parameters: Parameter[];
+            };
+        };
+    };
+    DEXES: {
+        ODOS: {
+            CHAINS: number[];
+            SWAP: {
+                id: number;
+                name: string;
+                description: string;
+                type: number;
+                parameters: Parameter[];
+            };
+        };
+    };
+    SOCIALS: {
+        MODE_NAME_SERVICE: {
+            CHAINS: number[];
+            NAME_REGISTERED: {
+                id: number;
+                name: string;
+                description: string;
+                type: number;
+                parameters: Parameter[];
+            };
+        };
+    };
+};

package/dist/types/src/constants/chains.d.ts

@@ -0,0 +1,5 @@
+export declare const CHAINS: {
+    ALL: number;
+    ETHEREUM: number;
+    MODE: number;
+};

package/dist/types/src/constants/tokens.d.ts

@@ -0,0 +1,11 @@
+export interface Token {
+    contractAddress: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+}
+export interface Tokens {
+    [key: number]: Token[];
+}
+export declare const TOKENS: Tokens;
+export declare function getToken(chain: number, symbol: string): Token;

package/dist/types/src/index.d.ts

@@ -0,0 +1,10 @@
+export * from './constants/ActionBlocks.js';
+export * from './constants/chains.js';
+export * from './constants/tokens.js';
+export * from './models/Action.js';
+export * from './models/Automation.js';
+export * from './models/Condition.js';
+export * from './models/Parameter.js';
+export * from './models/Trigger.js';
+export * from './services/ApiService.js';
+export * from './services/AutomationService.js';

package/dist/types/src/models/Action.d.ts

@@ -0,0 +1,6 @@
+export interface Action {
+    key: string;
+    type: string;
+    description: string;
+    value: any;
+}

package/dist/types/src/models/Automation.d.ts

@@ -0,0 +1,6 @@
+export interface Automation {
+    key: string;
+    type: string;
+    description: string;
+    value: any;
+}

package/dist/types/src/models/Condition.d.ts

@@ -0,0 +1,6 @@
+export interface COndition {
+    key: string;
+    type: string;
+    description: string;
+    value: any;
+}

package/dist/types/src/models/Parameter.d.ts

@@ -0,0 +1,6 @@
+export interface Parameter {
+    key: string;
+    type: string;
+    description: string;
+    value: any;
+}

package/dist/types/src/models/Trigger.d.ts

@@ -0,0 +1,37 @@
+import { Parameter } from './Parameter.js';
+export declare class Trigger {
+    id: number;
+    name: string;
+    description: string;
+    type: number;
+    parameters: {
+        [key: string]: Parameter;
+    };
+    keyMap: {
+        [key: string]: string;
+    };
+    constructor(trigger: {
+        id: number;
+        name: string;
+        description: string;
+        type: number;
+        parameters: Parameter[];
+    });
+    setChainId(value: number): void;
+    setContractAddress(value: string): void;
+    setCondition(value: string): void;
+    setComparisonValue(value: number): void;
+    setInterval(value: number): void;
+    setParams(key: string, value: any): void;
+    private setParameter;
+    private validateType;
+    private isAddress;
+    getParameter(key: string): any;
+    getParameters(): {
+        [key: string]: any;
+    };
+    toJSON(): {
+        [key: string]: any;
+    };
+    private getSimplifiedKey;
+}

package/dist/types/src/services/ApiService.d.ts

@@ -0,0 +1,6 @@
+export interface APISERVICES {
+    key: string;
+    type: string;
+    description: string;
+    value: any;
+}

package/dist/types/src/services/AutomationService.d.ts

@@ -0,0 +1,6 @@
+export interface AUTOSERVICES {
+    key: string;
+    type: string;
+    description: string;
+    value: any;
+}

package/dist/types/test/trigger.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/examples/create-trigger-list.ts

@@ -0,0 +1,159 @@
+import { TRIGGERS, getToken, TOKENS, CHAINS, Trigger } from '../src/index.js';
+
+const generateDefaultTriggers = (): any[] => {
+    const triggersList: any[] = [];
+
+    const createDefaultTrigger = (trigger: any) => {
+        const triggerInstance = new Trigger(trigger);
+
+        // Set common parameters if they exist
+        if (trigger.parameters.some((p: any) => p.key === "chainId")) {
+            triggerInstance.setChainId(CHAINS.ETHEREUM);
+        }
+        if (trigger.parameters.some((p: any) => p.key === "contractAddress")) {
+            triggerInstance.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        }
+        if (trigger.parameters.some((p: any) => p.key === "condition")) {
+            triggerInstance.setCondition('>');
+        }
+        if (trigger.parameters.some((p: any) => p.key === "comparisonValue")) {
+            triggerInstance.setComparisonValue(1000);
+        }
+        if (trigger.parameters.some((p: any) => p.key === "interval")) {
+            triggerInstance.setInterval(60000); // 1 minute interval
+        }
+        if (trigger.parameters.some((p: any) => p.key === "abiParams.account")) {
+            triggerInstance.setParams('account', '0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6');
+        }
+
+        return triggerInstance.toJSON();
+    };
+
+    // Explicitly create each trigger
+    triggersList.push(createDefaultTrigger(TRIGGERS.TOKENS.ERC20.TRANSFER));
+    triggersList.push(createDefaultTrigger(TRIGGERS.YIELD.SPLICE_FI.SWAP));
+    triggersList.push(createDefaultTrigger(TRIGGERS.YIELD.SPLICE_FI.LIQUIDITY_REMOVED));
+    triggersList.push(createDefaultTrigger(TRIGGERS.YIELD.SPLICE_FI.MARKET_CREATION));
+    triggersList.push(createDefaultTrigger(TRIGGERS.YIELD.SPLICE_FI.INTEREST_RATE_UPDATE));
+    triggersList.push(createDefaultTrigger(TRIGGERS.LENDING.ASTARIA.LEND_RECALLED));
+    triggersList.push(createDefaultTrigger(TRIGGERS.DEXES.ODOS.SWAP));
+    triggersList.push(createDefaultTrigger(TRIGGERS.SOCIALS.MODE_NAME_SERVICE.NAME_REGISTERED));
+
+    return triggersList;
+};
+
+function generateTriggersForAllTokens(chain: number) {
+    if (!(chain in TOKENS)) {
+        throw new Error(`Unsupported chain: ${chain}`);
+    }
+
+    const tokens = TOKENS[chain];
+    const triggersList: any[] = [];
+
+    tokens.forEach(token => {
+        // Generate transfer trigger
+        const transferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+        transferTrigger.setChainId(chain);
+        // transferTrigger.setParams("value", 1000);
+        // transferTrigger.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+        transferTrigger.setContractAddress(token.contractAddress);
+        triggersList.push(transferTrigger);
+
+        // Generate balance trigger
+        const balanceTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.BALANCE);
+        balanceTrigger.setChainId(chain);
+        balanceTrigger.setParams("account", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+        balanceTrigger.setContractAddress(token.contractAddress);
+        balanceTrigger.setCondition(">");
+        balanceTrigger.setComparisonValue(10);
+        balanceTrigger.setInterval(5000);
+        triggersList.push(balanceTrigger);
+    });
+
+    return triggersList.map(t => t.toJSON());
+}
+
+const generateSpecificTriggers = (): any[] => {
+    // Create individual triggers
+    const transferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+    transferTrigger.setChainId(CHAINS.ETHEREUM);
+    transferTrigger.setParams("value", 1000);
+    transferTrigger.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    transferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+
+    const balanceTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.BALANCE);
+    balanceTrigger.setChainId(CHAINS.ETHEREUM);
+    balanceTrigger.setParams("account", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    balanceTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    balanceTrigger.setCondition(">");
+    balanceTrigger.setComparisonValue(45000);
+    balanceTrigger.setInterval(5000);
+
+    const spliceFiSwapTrigger = new Trigger(TRIGGERS.YIELD.SPLICE_FI.SWAP);
+    spliceFiSwapTrigger.setParams("caller", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    spliceFiSwapTrigger.setParams("market", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    spliceFiSwapTrigger.setParams("receiver", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    spliceFiSwapTrigger.setParams("netPtToAccount", 1000);
+    spliceFiSwapTrigger.setParams("netSyToAccount", 2000);
+
+    const liquidityRemovedTrigger = new Trigger(TRIGGERS.YIELD.SPLICE_FI.LIQUIDITY_REMOVED);
+    liquidityRemovedTrigger.setParams("caller", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    liquidityRemovedTrigger.setParams("market", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    liquidityRemovedTrigger.setParams("receiver", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    liquidityRemovedTrigger.setParams("netLpToRemove", 1000);
+    liquidityRemovedTrigger.setParams("netPtOut", 500);
+    liquidityRemovedTrigger.setParams("netSyOut", 1500);
+
+    const marketCreationTrigger = new Trigger(TRIGGERS.YIELD.SPLICE_FI.MARKET_CREATION);
+    marketCreationTrigger.setParams("market", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    marketCreationTrigger.setParams("PT", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    marketCreationTrigger.setParams("scalarRoot", 1234);
+    marketCreationTrigger.setParams("initialAnchor", 5678);
+    marketCreationTrigger.setParams("lnFeeRateRoot", 91011);
+
+    const interestRateUpdateTrigger = new Trigger(TRIGGERS.YIELD.SPLICE_FI.INTEREST_RATE_UPDATE);
+    interestRateUpdateTrigger.setParams("timestamp", 1627848271);
+    interestRateUpdateTrigger.setParams("lastLnImpliedRate", 123456);
+    interestRateUpdateTrigger.setContractAddress("0xDE95511418EBD8Bd36294B11C86314DdFA50e212");
+
+    const lendRecalledTrigger = new Trigger(TRIGGERS.LENDING.ASTARIA.LEND_RECALLED);
+    lendRecalledTrigger.setParams("loanId", 123456);
+    lendRecalledTrigger.setParams("recaller", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    lendRecalledTrigger.setParams("end", 1627848271);
+
+    const odosSwapTrigger = new Trigger(TRIGGERS.DEXES.ODOS.SWAP);
+    odosSwapTrigger.setChainId(CHAINS.ETHEREUM);
+    odosSwapTrigger.setParams("sender", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    odosSwapTrigger.setParams("inputAmount", 1000);
+    odosSwapTrigger.setParams("inputToken", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    odosSwapTrigger.setParams("amountOut", 500);
+    odosSwapTrigger.setParams("outputToken", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    odosSwapTrigger.setParams("exchangeRate", 1.23);
+
+    const nameRegisteredTrigger = new Trigger(TRIGGERS.SOCIALS.MODE_NAME_SERVICE.NAME_REGISTERED);
+    nameRegisteredTrigger.setParams("id", 123456);
+    nameRegisteredTrigger.setParams("owner", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    nameRegisteredTrigger.setParams("expires", 1627848271);
+
+    return [
+        transferTrigger.toJSON(),
+        balanceTrigger.toJSON(),
+        spliceFiSwapTrigger.toJSON(),
+        liquidityRemovedTrigger.toJSON(),
+        marketCreationTrigger.toJSON(),
+        interestRateUpdateTrigger.toJSON(),
+        lendRecalledTrigger.toJSON(),
+        odosSwapTrigger.toJSON(),
+        nameRegisteredTrigger.toJSON(),
+    ]
+};
+
+// Collect all triggers in a list
+const triggersList = [
+    ...generateTriggersForAllTokens(CHAINS.ETHEREUM),
+    ...generateTriggersForAllTokens(CHAINS.MODE),
+    ...generateDefaultTriggers(),
+    ...generateSpecificTriggers()
+];
+
+console.log(JSON.stringify(triggersList));

package/examples/create-trigger.ts

@@ -0,0 +1,12 @@
+import { TRIGGERS, getToken, CHAINS, Trigger } from '../src/index.js';
+
+
+
+const transferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+
+transferTrigger.setChainId(CHAINS.ETHEREUM);
+// transferTrigger.setParams("value", 1000);
+// transferTrigger.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+transferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+
+console.log(transferTrigger.toJSON());

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "otomato-sdk",
+  "version": "1.0.0",
+  "description": "An SDK for building and managing automations on Otomato",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "npx tsc",
+    "test": "mocha --config .mocharc.json"
+  },
+  "keywords": [
+    "sdk",
+    "automation",
+    "typescript",
+    "javascript",
+    "crypto",
+    "evm",
+    "ethereum"
+  ],
+  "author": "otomato",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/axios": "^0.14.0",
+    "@types/chai": "^4.3.16",
+    "@types/mocha": "^10.0.6",
+    "@types/node": "^20.14.2",
+    "chai": "^5.1.1",
+    "mocha": "^10.4.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  },
+  "dependencies": {
+    "axios": "^1.7.2",
+    "ethers": "^6.13.0"
+  }
+}