otomato-sdk 1.2.0 → 1.3.0

package/dist/src/index.js

@@ -4,7 +4,7 @@ export * from './constants/chains.js';
 export * from './constants/tokens.js';
 // Exporting models
 export * from './models/Action.js';
-export * from './models/Automation.js';
+export * from './models/Workflow.js';
 export * from './models/Condition.js';
 export * from './models/Parameter.js';
 export * from './models/Trigger.js';

package/dist/src/models/Edge.js

@@ -17,9 +17,14 @@ export class Edge {
     }
     toJSON() {
         return {
-            id: this.id,
             source: this.source.getRef(),
             target: this.target.getRef(),
         };
     }
+    static fromJSON(json) {
+        return new Edge({
+            source: json.source,
+            target: json.target,
+        });
+    }
 }

package/dist/src/models/Node.js

@@ -1,14 +1,19 @@
+// Assuming you have the ACTIONS constant defined as you provided
 import { validateType } from '../utils/typeValidator.js';
+import { ACTIONS, TRIGGERS } from '../constants/Blocks.js';
 let nodeCounter = 0;
 const generatedRefs = new Set();
 export class Node {
     constructor(node) {
-        this.id = node.id;
+        this.id = null;
+        this.id = null;
+        this.blockId = node.blockId;
         this.name = node.name;
         this.description = node.description;
+        this.image = node.image;
         this.parameters = {};
         this.keyMap = {};
-        this.class = node.class; // Set class property
+        this.class = node.class;
         if (node.ref) {
             this.ref = node.ref;
         }
@@ -28,6 +33,9 @@ export class Node {
             this.position = node.position;
         }
     }
+    setId(id) {
+        this.id = id;
+    }
     setChainId(value) {
         this.setParameter('chainId', value);
     }
@@ -68,7 +76,16 @@ export class Node {
     }
     getParameters() {
         return Object.keys(this.parameters).reduce((acc, key) => {
-            acc[key] = this.parameters[key].value;
+            if (key.startsWith('abiParams.')) {
+                const abiKey = key.replace('abiParams.', '');
+                if (!acc.abi) {
+                    acc.abi = { parameters: {} };
+                }
+                acc.abi.parameters[abiKey] = this.parameters[key].value;
+            }
+            else {
+                acc[key] = this.parameters[key].value;
+            }
             return acc;
         }, {});
     }
@@ -76,10 +93,9 @@ export class Node {
         const json = {
             id: this.id,
             ref: this.ref,
+            blockId: this.blockId,
             type: this.class,
-            data: {
-                parameters: this.getParameters(),
-            }
+            parameters: this.getParameters(),
         };
         if (this.position) {
             json.position = this.position;
@@ -89,4 +105,61 @@ export class Node {
     getSimplifiedKey(key) {
         return key.replace(/[.\[\]]/g, '_');
     }
+    static fromJSON(json) {
+        let enriched = findActionByBlockId(json.blockId);
+        if (!enriched)
+            enriched = findTriggerByBlockId(json.blockId);
+        if (!enriched)
+            enriched = { name: "Unknown", description: "Unknown", image: "Unknown" };
+        const parameters = Object.keys(json.parameters).map(key => ({
+            key,
+            type: typeof json.parameters[key], // Assuming type can be derived from the value's type
+            description: '', // Add appropriate description if needed
+            value: json.parameters[key]
+        }));
+        const node = new Node({
+            blockId: json.blockId,
+            name: enriched.name,
+            description: enriched.description,
+            image: enriched.image,
+            parameters,
+            ref: json.ref,
+            position: json.position,
+            class: json.type
+        });
+        node.setId(json.id);
+        return node;
+    }
 }
+const findActionByBlockId = (blockId) => {
+    for (const category in ACTIONS) {
+        for (const service in ACTIONS[category]) {
+            for (const actionKey in ACTIONS[category][service]) {
+                if (ACTIONS[category][service][actionKey].blockId === blockId) {
+                    return {
+                        name: ACTIONS[category][service][actionKey].name,
+                        description: ACTIONS[category][service][actionKey].description,
+                        image: ACTIONS[category][service][actionKey].image,
+                    };
+                }
+            }
+        }
+    }
+    return null;
+};
+const findTriggerByBlockId = (blockId) => {
+    for (const category in TRIGGERS) {
+        for (const service in TRIGGERS[category]) {
+            for (const triggerKey in TRIGGERS[category][service]) {
+                if (TRIGGERS[category][service][triggerKey].blockId === blockId) {
+                    return {
+                        name: TRIGGERS[category][service][triggerKey].name,
+                        description: TRIGGERS[category][service][triggerKey].description,
+                        image: TRIGGERS[category][service][triggerKey].image,
+                    };
+                }
+            }
+        }
+    }
+    return null;
+};

package/dist/src/models/Trigger.js

@@ -4,20 +4,23 @@ export class Trigger extends Node {
         super(Object.assign(Object.assign({}, trigger), { class: 'trigger' }));
         this.type = trigger.type;
     }
+    notAPollingTrigger() {
+        return this.type === 0;
+    }
     setCondition(value) {
-        if (this.type !== 1) {
+        if (this.notAPollingTrigger()) {
             throw new Error('Condition setting is not applicable for subscription based triggers.');
         }
         this.setParameter('condition', value);
     }
     setComparisonValue(value) {
-        if (this.type !== 1) {
+        if (this.notAPollingTrigger()) {
             throw new Error('Comparison value setting is not applicable for subscription based triggers.');
         }
         this.setParameter('comparisonValue', value);
     }
     setInterval(value) {
-        if (this.type !== 1) {
+        if (this.notAPollingTrigger()) {
             throw new Error('Interval setting is not applicable for subscription based triggers.');
         }
         this.setParameter('interval', value);

package/dist/src/models/Workflow.js

@@ -0,0 +1,67 @@
+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());
+    });
+};
+import { Node } from './Node.js';
+import { Edge } from './Edge.js';
+import { apiServices } from '../services/ApiService.js';
+export class Workflow {
+    constructor(name = '', nodes = [], edges = []) {
+        this.id = null;
+        this.name = name;
+        this.nodes = nodes;
+        this.edges = edges;
+    }
+    setName(name) {
+        this.name = name;
+    }
+    addNode(node) {
+        this.nodes.push(node);
+    }
+    addNodes(nodes) {
+        this.nodes.push(...nodes);
+    }
+    addEdge(edge) {
+        this.edges.push(edge);
+    }
+    addEdges(edges) {
+        this.edges.push(...edges);
+    }
+    toJSON() {
+        return {
+            id: this.id,
+            name: this.name,
+            nodes: this.nodes.map(node => node.toJSON()),
+            edges: this.edges.map(edge => edge.toJSON()),
+        };
+    }
+    create() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield apiServices.post('/workflows', this.toJSON());
+            this.id = response.id; // Assign the returned ID to the workflow instance
+            // Assign IDs to the nodes based on the response
+            response.nodes.forEach((nodeResponse) => {
+                const node = this.nodes.find(n => n.getRef() === nodeResponse.ref);
+                if (node) {
+                    node.setId(nodeResponse.id);
+                }
+            });
+            return response;
+        });
+    }
+    load(workflowId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield apiServices.get(`/workflows/${workflowId}`);
+            this.id = response.id;
+            this.name = response.name;
+            this.nodes = response.nodes.map((nodeData) => Node.fromJSON(nodeData));
+            this.edges = response.edges.map((edgeData) => Edge.fromJSON(edgeData));
+            return this;
+        });
+    }
+}

package/dist/src/services/ApiService.js

@@ -10,30 +10,36 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 // networkService.ts
 import axios from 'axios';
 const API_CONFIG = {
-    BASE_URL: 'http://localhost:3040/api',
+    BASE_URL: 'https://staging-api.otomato.xyz/api',
     HEADERS: {
-        'Content-Type': 'application/json'
+        'Content-Type': 'application/json',
     }
 };
 const axiosInstance = axios.create({
     baseURL: API_CONFIG.BASE_URL,
     headers: API_CONFIG.HEADERS
 });
-export const apiServices = {
-    post(endpoint, data) {
+class ApiServices {
+    constructor() {
+        this.cookie = null;
+        // You can add other methods (get, put, delete) similarly
+    }
+    setCookie(cookie) {
+        this.cookie = `token=${cookie}`;
+    }
+    post(url, 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;
-            }
+            const headers = this.cookie ? { 'Cookie': this.cookie } : {};
+            const response = yield axiosInstance.post(url, data, { headers });
+            return response.data;
         });
-    },
-    // Add other HTTP methods if needed
-    // async get(endpoint: string) { ... }
-    // async put(endpoint: string, data: any) { ... }
-    // async delete(endpoint: string) { ... }
-};
+    }
+    get(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = this.cookie ? { 'Cookie': this.cookie } : {};
+            const response = yield axiosInstance.get(url, { headers });
+            return response.data;
+        });
+    }
+}
+export const apiServices = new ApiServices();

package/dist/src/utils/typeValidator.js

@@ -33,10 +33,11 @@ export function validateType(expectedType, value) {
             return typeof value === 'string' && isValidUrl(value);
         case 'phone_number':
             return typeof value === 'string' && isValidPhoneNumber(value);
+        case 'string':
         case 'paragraph':
             return typeof value === 'string';
         case 'logic_operator':
-            const validOperators = new Set(['<', '>', '<=', '>=', '==', '!=']);
+            const validOperators = new Set(['gte', 'gt', 'lte', 'lt', 'eq', 'neq']);
             return typeof value === 'string' && validOperators.has(value);
         case 'any':
             return true;

package/dist/test/action.spec.js

@@ -30,7 +30,9 @@ describe('Action Class', () => {
         transferAction.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
         const json = transferAction.toJSON();
         expect(json).to.deep.equal({
-            id: ACTIONS.TOKENS.ERC20.TRANSFER.id,
+            blockId: ACTIONS.TOKENS.ERC20.TRANSFER.blockId,
+            ref: transferAction.getRef(),
+            type: 'action',
             parameters: {
                 chainId: CHAINS.ETHEREUM,
                 'abiParams.value': 1000,
@@ -39,21 +41,22 @@ describe('Action Class', () => {
             }
         });
     });
-    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 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);
+        const slackAction = new Action(ACTIONS.NOTIFICATIONS.SLACK.SEND_MESSAGE);
         slackAction.setParams("webhook", "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX");
-        slackAction.setParams("text", "This is a test message!");
+        slackAction.setParams("message", "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!");
+        expect(params.message).to.equal("This is a test message!");
     });
     it('should throw an error for invalid parameter type', () => {
         const transferAction = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
@@ -64,11 +67,11 @@ describe('Action Class', () => {
         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);
+        const slackAction = new Action(ACTIONS.NOTIFICATIONS.SLACK.SEND_MESSAGE);
         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.');
-    });
+    /*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

@@ -1,10 +1,10 @@
 import { expect } from 'chai';
-import { Automation } from '../src/models/Automation.js';
+import { Workflow } from '../src/models/Workflow.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', () => {
+describe('Workflow Class', () => {
+    it('should create a workflow with a trigger and actions', () => {
         const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
         trigger.setChainId(CHAINS.ETHEREUM);
         trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
@@ -15,27 +15,28 @@ describe('Automation Class', () => {
         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");
+        const action2 = new Action(ACTIONS.NOTIFICATIONS.SLACK.SEND_MESSAGE);
+        action2.setParams("webhook", "https://webhook.url");
+        action2.setParams("message", "This is a test message");
         action2.setPosition(2, 0);
-        const automation = new Automation("Test Automation", [trigger, action1, action2]);
-        const json = automation.toJSON();
+        const workflow = new Workflow("Test Workflow", [trigger, action1, action2]);
+        const json = workflow.toJSON();
         expect(json).to.deep.equal({
-            name: "Test Automation",
+            name: "Test Workflow",
             nodes: [trigger.toJSON(), action1.toJSON(), action2.toJSON()],
+            edges: []
         });
     });
-    it('should set the name of the automation', () => {
+    it('should set the name of the workflow', () => {
         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");
+        const workflow = new Workflow("Initial Name", [trigger]);
+        workflow.setName("Updated Name");
+        expect(workflow.name).to.equal("Updated Name");
     });
-    it('should add a trigger to the automation', () => {
+    it('should add a trigger to the workflow', () => {
         const initialTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
         initialTrigger.setChainId(CHAINS.ETHEREUM);
         initialTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
@@ -44,11 +45,11 @@ describe('Automation Class', () => {
         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]);
+        const workflow = new Workflow("Test Workflow", [initialTrigger]);
+        workflow.addNode(newTrigger);
+        expect(workflow.nodes).to.deep.equal([initialTrigger, newTrigger]);
     });
-    it('should add actions to the automation', () => {
+    it('should add actions to the workflow', () => {
         const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
         trigger.setChainId(CHAINS.ETHEREUM);
         trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
@@ -59,13 +60,13 @@ describe('Automation Class', () => {
         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");
+        const action2 = new Action(ACTIONS.NOTIFICATIONS.SLACK.SEND_MESSAGE);
+        action2.setParams("webhook", "https://webhook.url");
+        action2.setParams("message", "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]);
+        const workflow = new Workflow("Test Workflow", [trigger]);
+        workflow.addNode(action1);
+        workflow.addNode(action2);
+        expect(workflow.nodes).to.deep.equal([trigger, action1, action2]);
     });
 });

package/dist/test/node.spec.js

@@ -7,23 +7,25 @@ const DEFAULT_PARAMETERS = [
 describe('Node Class', () => {
     it('should create a node without coordinates', () => {
         const node = new Node({
-            id: 1,
+            blockId: 1,
             name: 'Test Node',
             description: 'A node for testing',
             parameters: DEFAULT_PARAMETERS,
-            class: 'testClass'
+            class: 'testClass',
+            image: 'a',
         });
         expect(node.position).to.be.undefined;
     });
     it('should create a node with coordinates', () => {
         var _a, _b;
         const node = new Node({
-            id: 2,
+            blockId: 2,
             name: 'Test Node with Coordinates',
             description: 'A node for testing with coordinates',
             parameters: DEFAULT_PARAMETERS,
             class: 'testClass',
-            position: { x: 100, y: 200 }
+            position: { x: 100, y: 200 },
+            image: 'a',
         });
         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);
@@ -31,11 +33,12 @@ describe('Node Class', () => {
     it('should set and get coordinates correctly', () => {
         var _a, _b;
         const node = new Node({
-            id: 3,
+            blockId: 3,
             name: 'Test Node for Coordinates',
             description: 'A node for testing coordinate setting',
             parameters: DEFAULT_PARAMETERS,
-            class: 'testClass'
+            class: 'testClass',
+            image: 'a',
         });
         node.setPosition(300, 400);
         expect((_a = node.position) === null || _a === void 0 ? void 0 : _a.x).to.equal(300);
@@ -43,11 +46,12 @@ describe('Node Class', () => {
     });
     it('should create a node and set parameters correctly', () => {
         const node = new Node({
-            id: 4,
+            blockId: 4,
             name: 'Test Node for Parameters',
             description: 'A node for testing parameter setting',
             parameters: DEFAULT_PARAMETERS,
-            class: 'testClass'
+            class: 'testClass',
+            image: 'a',
         });
         node.setChainId(1);
         node.setContractAddress("0x0000000000000000000000000000000000000000");
@@ -57,69 +61,69 @@ describe('Node Class', () => {
     });
     it('should be able to export a node as json without coordinates', () => {
         const node = new Node({
-            id: 5,
+            blockId: 5,
             name: 'Test Node for JSON',
             description: 'A node for testing JSON export',
             parameters: DEFAULT_PARAMETERS,
-            class: 'testClass'
+            class: 'testClass',
+            image: 'a',
         });
         node.setChainId(1);
         node.setContractAddress("0x0000000000000000000000000000000000000000");
         const json = node.toJSON();
         expect(json).to.deep.equal({
-            id: 5,
+            blockId: 5,
             ref: node.getRef(),
-            class: 'testClass',
-            data: {
-                parameters: {
-                    chainId: 1,
-                    contractAddress: "0x0000000000000000000000000000000000000000"
-                }
+            type: 'testClass',
+            parameters: {
+                chainId: 1,
+                contractAddress: "0x0000000000000000000000000000000000000000"
             }
         });
     });
     it('should be able to export a node as json with coordinates', () => {
         const node = new Node({
-            id: 6,
+            blockId: 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 }
+            position: { x: 1, y: 2 },
+            image: 'a',
         });
         node.setChainId(1);
         node.setContractAddress("0x0000000000000000000000000000000000000000");
         const json = node.toJSON();
         expect(json).to.deep.equal({
-            id: 6,
+            type: 'testClass',
+            blockId: 6,
             ref: node.getRef(),
-            class: 'testClass',
-            data: {
-                parameters: {
-                    chainId: 1,
-                    contractAddress: "0x0000000000000000000000000000000000000000"
-                }
+            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,
+            blockId: 7,
             name: 'Test Node for Invalid Parameter Type',
             description: 'A node for testing invalid parameter type',
             parameters: DEFAULT_PARAMETERS,
-            class: 'testClass'
+            class: 'testClass',
+            image: 'a',
         });
         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,
+            blockId: 8,
             name: 'Test Node for Invalid Address',
             description: 'A node for testing invalid address',
             parameters: DEFAULT_PARAMETERS,
-            class: 'testClass'
+            class: 'testClass',
+            image: 'a',
         });
         expect(() => node.setParams("contractAddress", "invalid_address")).to.throw('Invalid type for parameter contractAddress. Expected address.');
     });

package/dist/test/trigger.spec.js

@@ -29,12 +29,16 @@ describe('Trigger Class', () => {
         transferTrigger.setParams("to", DEFAULT_ADDRESS);
         transferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
         const json = transferTrigger.toJSON();
+        console.log(json);
         expect(json).to.deep.equal({
-            id: TRIGGERS.TOKENS.ERC20.TRANSFER.id,
+            blockId: TRIGGERS.TOKENS.ERC20.TRANSFER.blockId,
+            ref: transferTrigger.getRef(),
+            type: 'trigger',
             parameters: {
                 chainId: CHAINS.ETHEREUM,
                 'abiParams.value': 1000,
                 'abiParams.to': DEFAULT_ADDRESS,
+                'abiParams.from': null,
                 contractAddress: getToken(CHAINS.ETHEREUM, 'USDC').contractAddress
             }
         });
@@ -44,14 +48,15 @@ describe('Trigger Class', () => {
         balanceTrigger.setChainId(CHAINS.ETHEREUM);
         balanceTrigger.setParams("account", DEFAULT_ADDRESS);
         balanceTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
-        balanceTrigger.setCondition(">");
+        balanceTrigger.setCondition("gte");
         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().parameters.condition).to.equal(">");
+        console.log(balanceTrigger.toJSON());
+        expect(balanceTrigger.toJSON().parameters.condition).to.equal("gte");
         expect(balanceTrigger.toJSON().parameters.comparisonValue).to.equal(45000);
         expect(balanceTrigger.toJSON().parameters.interval).to.equal(5000);
     });