otomato-sdk 1.0.1 → 1.2.0

package/dist/src/models/Trigger.js

@@ -1,23 +1,8 @@
-import { ethers } from 'ethers';
-export class Trigger {
+import { Node } from './Node.js';
+export class Trigger extends Node {
     constructor(trigger) {
-        this.id = trigger.id;
-        this.name = trigger.name;
-        this.description = trigger.description;
+        super(Object.assign(Object.assign({}, trigger), { class: 'trigger' }));
         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) {
@@ -37,74 +22,4 @@ export class Trigger {
         }
         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

@@ -1 +1,39 @@
-export {};
+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());
+    });
+};
+// networkService.ts
+import axios from 'axios';
+const API_CONFIG = {
+    BASE_URL: 'http://localhost:3040/api',
+    HEADERS: {
+        'Content-Type': 'application/json'
+    }
+};
+const axiosInstance = axios.create({
+    baseURL: API_CONFIG.BASE_URL,
+    headers: API_CONFIG.HEADERS
+});
+export const apiServices = {
+    post(endpoint, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield axiosInstance.post(endpoint, data);
+                return response.data;
+            }
+            catch (error) {
+                console.error('Network request failed', error);
+                throw error;
+            }
+        });
+    },
+    // Add other HTTP methods if needed
+    // async get(endpoint: string) { ... }
+    // async put(endpoint: string, data: any) { ... }
+    // async delete(endpoint: string) { ... }
+};

package/dist/src/utils/typeValidator.js

@@ -0,0 +1,70 @@
+import { ethers } from 'ethers';
+export function validateType(expectedType, value) {
+    switch (expectedType) {
+        case 'bool':
+        case 'boolean':
+            return typeof value === 'boolean';
+        case 'chainId':
+        case 'integer':
+            return Number.isInteger(value);
+        case 'int8':
+        case 'int16':
+        case 'int32':
+        case 'int64':
+        case 'int128':
+        case 'int256':
+            return Number.isInteger(value) && isIntInRange(value, parseInt(expectedType.replace('int', '')));
+        case 'uint8':
+        case 'uint16':
+        case 'uint32':
+        case 'uint64':
+        case 'uint128':
+        case 'uint256':
+            return Number.isInteger(value) && isUintInRange(value, parseInt(expectedType.replace('uint', '')));
+        case 'erc20':
+        case 'nftCollection':
+        case 'address':
+            return typeof value === 'string' && isAddress(value);
+        case 'float':
+        case 'fixed':
+        case 'ufixed':
+            return typeof value === 'number';
+        case 'url':
+            return typeof value === 'string' && isValidUrl(value);
+        case 'phone_number':
+            return typeof value === 'string' && isValidPhoneNumber(value);
+        case 'paragraph':
+            return typeof value === 'string';
+        case 'logic_operator':
+            const validOperators = new Set(['<', '>', '<=', '>=', '==', '!=']);
+            return typeof value === 'string' && validOperators.has(value);
+        case 'any':
+            return true;
+        default:
+            return false;
+    }
+}
+function isIntInRange(value, bits) {
+    const min = -(Math.pow(2, (bits - 1)));
+    const max = (Math.pow(2, (bits - 1))) - 1;
+    return value >= min && value <= max;
+}
+function isUintInRange(value, bits) {
+    const max = (Math.pow(2, bits)) - 1;
+    return value >= 0 && value <= max;
+}
+export function isAddress(value) {
+    return ethers.isAddress(value);
+}
+export function isValidUrl(value) {
+    try {
+        new URL(value);
+        return true;
+    }
+    catch (_) {
+        return false;
+    }
+}
+export function isValidPhoneNumber(value) {
+    return /^[\+]?[0-9]{0,3}\W?[(]?[0-9]{3}[)]?[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4,6}$/im.test(value);
+}

package/dist/test/action.spec.js

@@ -0,0 +1,74 @@
+import { expect } from 'chai';
+import { Action, ACTIONS, getToken, CHAINS } from '../src/index';
+const DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
+describe('Action Class', () => {
+    it('should create a transfer action without parameters', () => {
+        const transferAction = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
+        const params = transferAction.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 action and set parameters correctly', () => {
+        const transferAction = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
+        transferAction.setChainId(CHAINS.ETHEREUM);
+        transferAction.setParams("value", 1000);
+        transferAction.setParams("to", DEFAULT_ADDRESS);
+        transferAction.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        const params = transferAction.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 an action as json', () => {
+        const transferAction = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
+        transferAction.setChainId(CHAINS.ETHEREUM);
+        transferAction.setParams("value", 1000);
+        transferAction.setParams("to", DEFAULT_ADDRESS);
+        transferAction.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        const json = transferAction.toJSON();
+        expect(json).to.deep.equal({
+            id: ACTIONS.TOKENS.ERC20.TRANSFER.id,
+            parameters: {
+                chainId: CHAINS.ETHEREUM,
+                'abiParams.value': 1000,
+                'abiParams.to': DEFAULT_ADDRESS,
+                contractAddress: getToken(CHAINS.ETHEREUM, 'USDC').contractAddress
+            }
+        });
+    });
+    it('should create an SMS action and set parameters correctly', () => {
+        const smsAction = new Action(ACTIONS.NOTIFICATIONS.SMS);
+        smsAction.setParams("phoneNumber", "+1234567890");
+        smsAction.setParams("text", "Hello, this is a test message!");
+        const params = smsAction.getParameters();
+        expect(params.phoneNumber).to.equal("+1234567890");
+        expect(params.text).to.equal("Hello, this is a test message!");
+    });
+    it('should create a Slack action and set parameters correctly', () => {
+        const slackAction = new Action(ACTIONS.NOTIFICATIONS.SLACK);
+        slackAction.setParams("webhook", "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX");
+        slackAction.setParams("text", "This is a test message!");
+        const params = slackAction.getParameters();
+        expect(params.webhook).to.equal("https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX");
+        expect(params.text).to.equal("This is a test message!");
+    });
+    it('should throw an error for invalid parameter type', () => {
+        const transferAction = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
+        expect(() => transferAction.setParams("value", "invalid")).to.throw('Invalid type for parameter abiParams.value. Expected uint256.');
+    });
+    it('should throw an error for invalid address', () => {
+        const transferAction = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
+        expect(() => transferAction.setParams("to", "invalid_address")).to.throw('Invalid type for parameter abiParams.to. Expected address.');
+    });
+    it('should throw an error for invalid URL', () => {
+        const slackAction = new Action(ACTIONS.NOTIFICATIONS.SLACK);
+        expect(() => slackAction.setParams("webhook", "invalid_url")).to.throw('Invalid type for parameter webhook. Expected url.');
+    });
+    it('should throw an error for invalid phone number', () => {
+        const smsAction = new Action(ACTIONS.NOTIFICATIONS.SMS);
+        expect(() => smsAction.setParams("phoneNumber", "invalid_phone_number")).to.throw('Invalid type for parameter phoneNumber. Expected phone_number.');
+    });
+});

package/dist/test/automation.spec.js

@@ -0,0 +1,71 @@
+import { expect } from 'chai';
+import { Automation } from '../src/models/Automation.js';
+import { Trigger } from '../src/models/Trigger.js';
+import { Action } from '../src/models/Action.js';
+import { TRIGGERS, ACTIONS, getToken, CHAINS } from '../src/index.js';
+describe('Automation Class', () => {
+    it('should create an automation with a trigger and actions', () => {
+        const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+        trigger.setChainId(CHAINS.ETHEREUM);
+        trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        trigger.setPosition(0, 0);
+        const action1 = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
+        action1.setChainId(CHAINS.ETHEREUM);
+        action1.setParams("value", 1000);
+        action1.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+        action1.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        action1.setPosition(1, 0);
+        const action2 = new Action(ACTIONS.NOTIFICATIONS.SMS);
+        action2.setParams("phoneNumber", "+1234567890");
+        action2.setParams("text", "This is a test message");
+        action2.setPosition(2, 0);
+        const automation = new Automation("Test Automation", [trigger, action1, action2]);
+        const json = automation.toJSON();
+        expect(json).to.deep.equal({
+            name: "Test Automation",
+            nodes: [trigger.toJSON(), action1.toJSON(), action2.toJSON()],
+        });
+    });
+    it('should set the name of the automation', () => {
+        const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+        trigger.setChainId(CHAINS.ETHEREUM);
+        trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        trigger.setPosition(0, 0);
+        const automation = new Automation("Initial Name", [trigger]);
+        automation.setName("Updated Name");
+        expect(automation.name).to.equal("Updated Name");
+    });
+    it('should add a trigger to the automation', () => {
+        const initialTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+        initialTrigger.setChainId(CHAINS.ETHEREUM);
+        initialTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        initialTrigger.setPosition(0, 0);
+        const newTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+        newTrigger.setChainId(CHAINS.ETHEREUM);
+        newTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        newTrigger.setPosition(1, 0);
+        const automation = new Automation("Test Automation", [initialTrigger]);
+        automation.addNode(newTrigger);
+        expect(automation.nodes).to.deep.equal([initialTrigger, newTrigger]);
+    });
+    it('should add actions to the automation', () => {
+        const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+        trigger.setChainId(CHAINS.ETHEREUM);
+        trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        trigger.setPosition(0, 0);
+        const action1 = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
+        action1.setChainId(CHAINS.ETHEREUM);
+        action1.setParams("value", 1000);
+        action1.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+        action1.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        action1.setPosition(1, 0);
+        const action2 = new Action(ACTIONS.NOTIFICATIONS.SMS);
+        action2.setParams("phoneNumber", "+1234567890");
+        action2.setParams("text", "This is a test message");
+        action2.setPosition(2, 0);
+        const automation = new Automation("Test Automation", [trigger]);
+        automation.addNode(action1);
+        automation.addNode(action2);
+        expect(automation.nodes).to.deep.equal([trigger, action1, action2]);
+    });
+});

package/dist/test/node.spec.js

@@ -0,0 +1,126 @@
+import { expect } from 'chai';
+import { Node } from '../src/index'; // Adjust the import path according to your project structure
+const DEFAULT_PARAMETERS = [
+    { key: 'chainId', type: 'integer', description: 'Chain ID', value: null },
+    { key: 'contractAddress', type: 'address', description: 'Contract Address', value: null }
+];
+describe('Node Class', () => {
+    it('should create a node without coordinates', () => {
+        const node = new Node({
+            id: 1,
+            name: 'Test Node',
+            description: 'A node for testing',
+            parameters: DEFAULT_PARAMETERS,
+            class: 'testClass'
+        });
+        expect(node.position).to.be.undefined;
+    });
+    it('should create a node with coordinates', () => {
+        var _a, _b;
+        const node = new Node({
+            id: 2,
+            name: 'Test Node with Coordinates',
+            description: 'A node for testing with coordinates',
+            parameters: DEFAULT_PARAMETERS,
+            class: 'testClass',
+            position: { x: 100, y: 200 }
+        });
+        expect((_a = node.position) === null || _a === void 0 ? void 0 : _a.x).to.equal(100);
+        expect((_b = node.position) === null || _b === void 0 ? void 0 : _b.y).to.equal(200);
+    });
+    it('should set and get coordinates correctly', () => {
+        var _a, _b;
+        const node = new Node({
+            id: 3,
+            name: 'Test Node for Coordinates',
+            description: 'A node for testing coordinate setting',
+            parameters: DEFAULT_PARAMETERS,
+            class: 'testClass'
+        });
+        node.setPosition(300, 400);
+        expect((_a = node.position) === null || _a === void 0 ? void 0 : _a.x).to.equal(300);
+        expect((_b = node.position) === null || _b === void 0 ? void 0 : _b.y).to.equal(400);
+    });
+    it('should create a node and set parameters correctly', () => {
+        const node = new Node({
+            id: 4,
+            name: 'Test Node for Parameters',
+            description: 'A node for testing parameter setting',
+            parameters: DEFAULT_PARAMETERS,
+            class: 'testClass'
+        });
+        node.setChainId(1);
+        node.setContractAddress("0x0000000000000000000000000000000000000000");
+        const params = node.getParameters();
+        expect(params.chainId).to.equal(1);
+        expect(params.contractAddress).to.equal("0x0000000000000000000000000000000000000000");
+    });
+    it('should be able to export a node as json without coordinates', () => {
+        const node = new Node({
+            id: 5,
+            name: 'Test Node for JSON',
+            description: 'A node for testing JSON export',
+            parameters: DEFAULT_PARAMETERS,
+            class: 'testClass'
+        });
+        node.setChainId(1);
+        node.setContractAddress("0x0000000000000000000000000000000000000000");
+        const json = node.toJSON();
+        expect(json).to.deep.equal({
+            id: 5,
+            ref: node.getRef(),
+            class: 'testClass',
+            data: {
+                parameters: {
+                    chainId: 1,
+                    contractAddress: "0x0000000000000000000000000000000000000000"
+                }
+            }
+        });
+    });
+    it('should be able to export a node as json with coordinates', () => {
+        const node = new Node({
+            id: 6,
+            name: 'Test Node for JSON with Coordinates',
+            description: 'A node for testing JSON export with coordinates',
+            parameters: DEFAULT_PARAMETERS,
+            class: 'testClass',
+            position: { x: 1, y: 2 }
+        });
+        node.setChainId(1);
+        node.setContractAddress("0x0000000000000000000000000000000000000000");
+        const json = node.toJSON();
+        expect(json).to.deep.equal({
+            id: 6,
+            ref: node.getRef(),
+            class: 'testClass',
+            data: {
+                parameters: {
+                    chainId: 1,
+                    contractAddress: "0x0000000000000000000000000000000000000000"
+                }
+            },
+            position: { x: 1, y: 2 }
+        });
+    });
+    it('should throw an error for invalid parameter type', () => {
+        const node = new Node({
+            id: 7,
+            name: 'Test Node for Invalid Parameter Type',
+            description: 'A node for testing invalid parameter type',
+            parameters: DEFAULT_PARAMETERS,
+            class: 'testClass'
+        });
+        expect(() => node.setParams("chainId", "invalid")).to.throw('Invalid type for parameter chainId. Expected integer.');
+    });
+    it('should throw an error for invalid address', () => {
+        const node = new Node({
+            id: 8,
+            name: 'Test Node for Invalid Address',
+            description: 'A node for testing invalid address',
+            parameters: DEFAULT_PARAMETERS,
+            class: 'testClass'
+        });
+        expect(() => node.setParams("contractAddress", "invalid_address")).to.throw('Invalid type for parameter contractAddress. Expected address.');
+    });
+});

package/dist/test/trigger.spec.js

@@ -51,9 +51,9 @@ describe('Trigger Class', () => {
         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);
+        expect(balanceTrigger.toJSON().parameters.condition).to.equal(">");
+        expect(balanceTrigger.toJSON().parameters.comparisonValue).to.equal(45000);
+        expect(balanceTrigger.toJSON().parameters.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);

package/dist/test/typeValidator.spec.js

@@ -0,0 +1,59 @@
+import { expect } from 'chai';
+import { validateType } from '../src/utils/typeValidator';
+describe('Type Validator Utility Functions', () => {
+    describe('validateType', () => {
+        it('should validate boolean values', () => {
+            expect(validateType('bool', true)).to.be.true;
+            expect(validateType('boolean', false)).to.be.true;
+            expect(validateType('bool', 'true')).to.be.false;
+        });
+        it('should validate integer values', () => {
+            expect(validateType('integer', 10)).to.be.true;
+            expect(validateType('int256', 10)).to.be.true;
+            expect(validateType('int8', 127)).to.be.true;
+            expect(validateType('int8', 128)).to.be.false;
+            expect(validateType('int8', -128)).to.be.true;
+            expect(validateType('int8', -129)).to.be.false;
+        });
+        it('should validate unsigned integer values', () => {
+            expect(validateType('uint256', 10)).to.be.true;
+            expect(validateType('uint8', 255)).to.be.true;
+            expect(validateType('uint8', 256)).to.be.false;
+            expect(validateType('uint8', -1)).to.be.false;
+        });
+        it('should validate address values', () => {
+            expect(validateType('address', '0x0000000000000000000000000000000000000000')).to.be.true;
+            expect(validateType('address', 'invalid_address')).to.be.false;
+        });
+        it('should validate float values', () => {
+            expect(validateType('float', 10.5)).to.be.true;
+            expect(validateType('fixed', 10.5)).to.be.true;
+            expect(validateType('float', '10.5')).to.be.false;
+        });
+        it('should validate URL values', () => {
+            expect(validateType('url', 'https://example.com')).to.be.true;
+            expect(validateType('url', 'invalid_url')).to.be.false;
+        });
+        it('should validate phone number values', () => {
+            expect(validateType('phone_number', '+1234567890')).to.be.true;
+            expect(validateType('phone_number', '12345')).to.be.false;
+            expect(validateType('phone_number', '+11234567890')).to.be.true;
+            expect(validateType('phone_number', '+447911123456')).to.be.true;
+            // fixme: it should not accept it
+            // expect(validateType('phone_number', '001234567890')).to.be.false;
+        });
+        it('should validate paragraph values', () => {
+            expect(validateType('paragraph', 'This is a test paragraph.')).to.be.true;
+            expect(validateType('paragraph', 12345)).to.be.false;
+        });
+        it('should validate logic operators', () => {
+            expect(validateType('logic_operator', '>')).to.be.true;
+            expect(validateType('logic_operator', 'invalid_operator')).to.be.false;
+        });
+        it('should validate any type', () => {
+            expect(validateType('any', 'any_value')).to.be.true;
+            expect(validateType('any', 12345)).to.be.true;
+            expect(validateType('any', true)).to.be.true;
+        });
+    });
+});

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

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

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

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