otomato-sdk 1.2.0 → 1.3.0

package/test/node.spec.ts

@@ -10,11 +10,12 @@ 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;
@@ -22,12 +23,13 @@ describe('Node Class', () => {
 
   it('should create a node with coordinates', () => {
     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(node.position?.x).to.equal(100);
@@ -36,11 +38,12 @@ describe('Node Class', () => {
 
   it('should set and get coordinates correctly', () => {
     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);
@@ -50,11 +53,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);
@@ -67,11 +71,12 @@ 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);
@@ -79,26 +84,25 @@ describe('Node Class', () => {
 
     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);
@@ -106,14 +110,12 @@ describe('Node Class', () => {
 
     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}
     });
@@ -121,22 +123,24 @@ describe('Node Class', () => {
 
   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/test/trigger.spec.ts

@@ -37,12 +37,16 @@ describe('Trigger Class', () => {
     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
       }
     });
@@ -53,7 +57,7 @@ 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);
 
@@ -61,7 +65,8 @@ 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().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/test/typeValidator.spec.ts

@@ -58,7 +58,8 @@ describe('Type Validator Utility Functions', () => {
         });
 
         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;
         });
 

package/examples/create-automation.ts

@@ -1,41 +0,0 @@
-import { ACTIONS, Action, TRIGGERS, Trigger, Automation, CHAINS, getToken, Edge } from '../src/index.js';
-
-const main = async () => {
-    const usdcTransferTrigger = new Trigger({
-        id: TRIGGERS.TOKENS.ERC20.TRANSFER.id,
-        name: TRIGGERS.TOKENS.ERC20.TRANSFER.name,
-        description: TRIGGERS.TOKENS.ERC20.TRANSFER.description,
-        type: TRIGGERS.TOKENS.ERC20.TRANSFER.type,
-        parameters: TRIGGERS.TOKENS.ERC20.TRANSFER.parameters,
-        ref: 'n-1',
-    });
-    usdcTransferTrigger.setChainId(CHAINS.ETHEREUM);
-    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
-    });
-    slackAction.setParams("webhook", "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX");
-    slackAction.setParams("text", "USDC has been transferred!");
-    slackAction.setPosition(0, -10);
-
-    const automation = new Automation("USDC Transfer Notification", [usdcTransferTrigger, slackAction]);
-
-    const edge = new Edge({
-        source: usdcTransferTrigger,
-        target: slackAction,
-    });
-
-    automation.addEdge(edge);
-
-    console.log(JSON.stringify(automation.toJSON(), null, 2));
-
-    //await automation.save();
-}
-
-main();

package/src/constants/json.json

@@ -1,16 +0,0 @@
-{
-    "id": 1,
-    "refId": "n-1",
-    "data": {
-        "parameters": {
-            "chainId": 1,
-            "abiParams.value": null,
-            "abiParams.to": null,
-            "contractAddress": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
-        },
-    },
-    "position": {
-        "x": 0,
-        "y": 0
-    }
-}

package/src/models/Automation.ts

@@ -1,47 +0,0 @@
-import { Node } from './Node.js';
-import { Edge } from './Edge.js';
-import { apiServices } from '../services/ApiService.js';
-
-export class Automation {
-  name: string;
-  nodes: Node[];
-  edges: Edge[];
-
-  constructor(name: string, nodes: Node[] = [], edges: Edge[] = []) {
-    this.name = name;
-    this.nodes = nodes;
-    this.edges = edges;
-  }
-
-  setName(name: string): void {
-    this.name = name;
-  }
-
-  addNode(node: Node): void {
-    this.nodes.push(node);
-  }
-
-  addNodes(nodes: Node[]): void {
-    this.nodes.push(...nodes);
-  }
-
-  addEdge(edge: Edge): void {
-    this.edges.push(edge);
-  }
-
-  addEdges(edges: Edge[]): void {
-    this.edges.push(...edges);
-  }
-
-  toJSON() {
-    return {
-      name: this.name,
-      nodes: this.nodes.map(node => node.toJSON()),
-      edges: this.edges.map(edge => edge.toJSON()),
-    };
-  }
-
-  async save() {
-    return apiServices.post('/workflows', this.toJSON());
-  }
-}