otomato-sdk 1.2.0 → 1.2.1

package/dist/src/models/Node.js

@@ -68,7 +68,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;
         }, {});
     }
@@ -77,9 +86,7 @@ export class Node {
             id: this.id,
             ref: this.ref,
             type: this.class,
-            data: {
-                parameters: this.getParameters(),
-            }
+            parameters: this.getParameters(),
         };
         if (this.position) {
             json.position = this.position;

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/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

@@ -31,6 +31,8 @@ describe('Action Class', () => {
         const json = transferAction.toJSON();
         expect(json).to.deep.equal({
             id: ACTIONS.TOKENS.ERC20.TRANSFER.id,
+            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

@@ -15,15 +15,16 @@ 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();
         expect(json).to.deep.equal({
             name: "Test Automation",
             nodes: [trigger.toJSON(), action1.toJSON(), action2.toJSON()],
+            edges: []
         });
     });
     it('should set the name of the automation', () => {
@@ -59,9 +60,9 @@ 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);

package/dist/test/node.spec.js

@@ -69,12 +69,10 @@ describe('Node Class', () => {
         expect(json).to.deep.equal({
             id: 5,
             ref: node.getRef(),
-            class: 'testClass',
-            data: {
-                parameters: {
-                    chainId: 1,
-                    contractAddress: "0x0000000000000000000000000000000000000000"
-                }
+            type: 'testClass',
+            parameters: {
+                chainId: 1,
+                contractAddress: "0x0000000000000000000000000000000000000000"
             }
         });
     });
@@ -91,14 +89,12 @@ describe('Node Class', () => {
         node.setContractAddress("0x0000000000000000000000000000000000000000");
         const json = node.toJSON();
         expect(json).to.deep.equal({
+            type: 'testClass',
             id: 6,
             ref: node.getRef(),
-            class: 'testClass',
-            data: {
-                parameters: {
-                    chainId: 1,
-                    contractAddress: "0x0000000000000000000000000000000000000000"
-                }
+            parameters: {
+                chainId: 1,
+                contractAddress: "0x0000000000000000000000000000000000000000"
             },
             position: { x: 1, y: 2 }
         });

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,
+            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);
     });

package/dist/test/typeValidator.spec.js

@@ -47,7 +47,8 @@ describe('Type Validator Utility Functions', () => {
             expect(validateType('paragraph', 12345)).to.be.false;
         });
         it('should validate logic operators', () => {
-            expect(validateType('logic_operator', '>')).to.be.true;
+            expect(validateType('logic_operator', 'gte')).to.be.true;
+            expect(validateType('logic_operator', '>')).to.be.false;
             expect(validateType('logic_operator', 'invalid_operator')).to.be.false;
         });
         it('should validate any type', () => {

package/dist/types/examples/sandbox.d.ts

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

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

@@ -15,6 +15,8 @@ export declare const TRIGGERS: {
                 name: string;
                 description: string;
                 type: number;
+                method: string;
+                handler: string;
                 parameters: Parameter[];
             };
         };
@@ -27,6 +29,7 @@ export declare const TRIGGERS: {
                 name: string;
                 description: string;
                 type: number;
+                contractAddress: string;
                 parameters: Parameter[];
             };
             LIQUIDITY_REMOVED: {
@@ -34,6 +37,7 @@ export declare const TRIGGERS: {
                 name: string;
                 description: string;
                 type: number;
+                contractAddress: string;
                 parameters: Parameter[];
             };
             MARKET_CREATION: {
@@ -41,6 +45,7 @@ export declare const TRIGGERS: {
                 name: string;
                 description: string;
                 type: number;
+                contractAddress: string;
                 parameters: Parameter[];
             };
             INTEREST_RATE_UPDATE: {
@@ -48,6 +53,7 @@ export declare const TRIGGERS: {
                 name: string;
                 description: string;
                 type: number;
+                contractAddress: string;
                 parameters: Parameter[];
             };
         };
@@ -60,6 +66,7 @@ export declare const TRIGGERS: {
                 name: string;
                 description: string;
                 type: number;
+                contractAddress: string;
                 parameters: Parameter[];
             };
         };
@@ -72,6 +79,7 @@ export declare const TRIGGERS: {
                 name: string;
                 description: string;
                 type: number;
+                contractAddress: string;
                 parameters: Parameter[];
             };
         };
@@ -80,6 +88,19 @@ export declare const TRIGGERS: {
         MODE_NAME_SERVICE: {
             CHAINS: number[];
             NAME_REGISTERED: {
+                id: number;
+                name: string;
+                description: string;
+                type: number;
+                contractAddress: string;
+                parameters: Parameter[];
+            };
+        };
+    };
+    PRICE_ACTION: {
+        ON_CHAIN_PRICE_MOVEMENT: {
+            CHAINS: number[];
+            PRICE_MOVEMENT_AGAINST_CURRENCY: {
                 id: number;
                 name: string;
                 description: string;
@@ -90,6 +111,35 @@ export declare const TRIGGERS: {
     };
 };
 export declare const ACTIONS: {
+    NOTIFICATIONS: {
+        SLACK: {
+            SEND_MESSAGE: {
+                id: number;
+                name: string;
+                type: number;
+                description: string;
+                parameters: Parameter[];
+            };
+        };
+        DISCORD: {
+            SEND_MESSAGE: {
+                id: number;
+                name: string;
+                type: number;
+                description: string;
+                parameters: Parameter[];
+            };
+        };
+        TELEGRAM: {
+            SEND_MESSAGE: {
+                id: number;
+                name: string;
+                type: number;
+                description: string;
+                parameters: Parameter[];
+            };
+        };
+    };
     TOKENS: {
         ERC20: {
             CHAINS: number[];
@@ -97,22 +147,10 @@ export declare const ACTIONS: {
                 id: number;
                 name: string;
                 description: string;
+                type: number;
+                method: string;
                 parameters: Parameter[];
             };
         };
     };
-    NOTIFICATIONS: {
-        SMS: {
-            id: number;
-            name: string;
-            description: string;
-            parameters: Parameter[];
-        };
-        SLACK: {
-            id: number;
-            name: string;
-            description: string;
-            parameters: Parameter[];
-        };
-    };
 };

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

@@ -2,5 +2,5 @@ export interface Parameter {
     key: string;
     type: string;
     description: string;
-    value: any;
+    value?: any;
 }

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

@@ -11,6 +11,7 @@ export declare class Trigger extends Node {
         ref?: string;
         position?: Position;
     });
+    private notAPollingTrigger;
     setCondition(value: string): void;
     setComparisonValue(value: number): void;
     setInterval(value: number): void;

package/examples/create-action.ts

@@ -11,14 +11,14 @@ const createAction = () => {
   console.log(transferAction.toJSON());
 
   // Create an SMS notification action
-  const smsAction = new Action(ACTIONS.NOTIFICATIONS.SMS);
+  const smsAction = new Action(ACTIONS.NOTIFICATIONS.DISCORD.SEND_MESSAGE);
   smsAction.setParams("phoneNumber", "+1234567890");
   smsAction.setParams("text", "This is a test message");
 
   console.log(smsAction.toJSON());
 
   // Create a Slack notification action
-  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");
 

package/examples/create-automation.ts

@@ -13,15 +13,9 @@ const main = async () => {
     usdcTransferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
     usdcTransferTrigger.setPosition(0, 0);
 
-    const slackAction = new Action({
-        id: ACTIONS.NOTIFICATIONS.SLACK.id,
-        name: ACTIONS.NOTIFICATIONS.SLACK.name,
-        description: ACTIONS.NOTIFICATIONS.SLACK.description,
-        parameters: ACTIONS.NOTIFICATIONS.SLACK.parameters,
-        // not forced to provide a ref id, it will generate it
-    });
+    const slackAction = new Action(ACTIONS.NOTIFICATIONS.SLACK.SEND_MESSAGE);
     slackAction.setParams("webhook", "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX");
-    slackAction.setParams("text", "USDC has been transferred!");
+    slackAction.setParams("message", "USDC has been transferred!");
     slackAction.setPosition(0, -10);
 
     const automation = new Automation("USDC Transfer Notification", [usdcTransferTrigger, slackAction]);

package/examples/create-trigger.ts

@@ -6,7 +6,7 @@ const transferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
 
 transferTrigger.setChainId(CHAINS.ETHEREUM);
 // transferTrigger.setParams("value", 1000);
-// transferTrigger.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+transferTrigger.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
 transferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
 
-console.log(transferTrigger.toJSON());
+console.log(JSON.stringify(transferTrigger.toJSON(), null, 2));

package/examples/sandbox.ts

@@ -0,0 +1,12 @@
+import { TRIGGERS, getToken, CHAINS, Trigger } from '../src/index.js';
+
+const trigger = new Trigger(TRIGGERS.PRICE_ACTION.ON_CHAIN_PRICE_MOVEMENT.PRICE_MOVEMENT_AGAINST_CURRENCY);
+
+trigger.setChainId(CHAINS.MODE);
+trigger.setComparisonValue(3200);
+trigger.setCondition("gte");
+trigger.setParams('currency', 'USD');
+trigger.setParams('contractAddress', getToken(CHAINS.MODE, 'MODE').contractAddress);
+trigger.setPosition(1, 0);
+
+console.log(JSON.stringify(trigger.toJSON(), null, 2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "otomato-sdk",
-  "version": "1.2.0",
+  "version": "1.2.1",
   "description": "An SDK for building and managing automations on Otomato",
   "main": "dist/src/index.js",
   "types": "dist/types/src/index.d.ts",