otomato-sdk 1.0.1 → 1.2.0

package/src/models/Automation.ts

@@ -1,6 +1,47 @@
-export interface Automation {
-    key: string;
-    type: string;
-    description: string;
-    value: any;
-  }
+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());
+  }
+}

package/src/models/Edge.ts

@@ -0,0 +1,33 @@
+import { Node } from './Node.js';
+
+let edgeCounter = 0;
+const generatedEdgeIds = new Set<string>();
+
+export class Edge {
+    id: string;
+    source: Node;
+    target: Node;
+
+    constructor(edge: { id?: string, source: Node, target: Node }) {
+        if (edge.id) {
+            this.id = edge.id;
+        } else {
+            this.id = `e-${++edgeCounter}`;
+            while (generatedEdgeIds.has(this.id)) {
+                this.id = `e-${++edgeCounter}`;
+            }
+        }
+        generatedEdgeIds.add(this.id);
+
+        this.source = edge.source;
+        this.target = edge.target;
+    }
+
+    toJSON(): { [key: string]: any } {
+        return {
+            id: this.id,
+            source: this.source.getRef(),
+            target: this.target.getRef(),
+        };
+    }
+}

package/src/models/Node.ts

@@ -0,0 +1,118 @@
+import { Parameter } from './Parameter.js';
+import { validateType } from '../utils/typeValidator.js';
+
+export interface Position {
+  x: number;
+  y: number;
+}
+
+let nodeCounter = 0;
+const generatedRefs = new Set<string>();
+
+export class Node {
+  id: number;
+  name: string;
+  description: string;
+  parameters: { [key: string]: Parameter };
+  keyMap: { [key: string]: string };
+  position?: Position;
+  ref: string;
+  class: string;  // Updated to use class instead of type
+
+  constructor(node: { id: number; name: string; description: string; parameters: Parameter[], ref?: string, position?: Position, class: string }) {
+    this.id = node.id;
+    this.name = node.name;
+    this.description = node.description;
+    this.parameters = {};
+    this.keyMap = {};
+    this.class = node.class;  // Set class property
+
+    if (node.ref) {
+      this.ref = node.ref;
+    } else {
+      this.ref = `n-${++nodeCounter}`;
+      while (generatedRefs.has(this.ref)) {
+        this.ref = `n-${++nodeCounter}`;
+      }
+    }
+    generatedRefs.add(this.ref);
+
+    node.parameters.forEach(param => {
+      this.parameters[param.key] = { ...param, value: null };
+      const simplifiedKey = this.getSimplifiedKey(param.key);
+      this.keyMap[simplifiedKey] = param.key;
+    });
+
+    if (node.position) {
+      this.position = node.position;
+    }
+  }
+
+  setChainId(value: number): void {
+    this.setParameter('chainId', value);
+  }
+
+  setContractAddress(value: string): void {
+    this.setParameter('contractAddress', value);
+  }
+
+  setParams(key: string, value: any): void {
+    const fullKey = this.parameters[`abiParams.${key}`] ? `abiParams.${key}` : key;
+    this.setParameter(fullKey, value);
+  }
+
+  setPosition(x: number, y: number): void {
+    this.position = { x, y };
+  }
+
+  getRef(): string {
+    return this.ref;
+  }
+
+  protected setParameter(key: string, value: any): void {
+    if (key in this.parameters) {
+      const param = this.parameters[key];
+      if (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`);
+    }
+  }
+
+  getParameter(key: string): any {
+    if (key in this.parameters) {
+      return this.parameters[key].value;
+    } else {
+      throw new Error(`Parameter with key ${key} not found`);
+    }
+  }
+
+  getParameters(): { [key: string]: any } {
+    return Object.keys(this.parameters).reduce((acc, key) => {
+      acc[key] = this.parameters[key].value;
+      return acc;
+    }, {} as { [key: string]: any });
+  }
+
+  toJSON(): { [key: string]: any } {
+    const json: { [key: string]: any } = {
+      id: this.id,
+      ref: this.ref,
+      type: this.class,
+      data: {
+        parameters: this.getParameters(),
+      }
+    };
+    if (this.position) {
+      json.position = this.position;
+    }
+    return json;
+  }
+
+  private getSimplifiedKey(key: string): string {
+    return key.replace(/[.\[\]]/g, '_');
+  }
+}

package/src/models/Trigger.ts

@@ -1,34 +1,12 @@
 import { Parameter } from './Parameter.js';
-import { ethers } from 'ethers';
+import { Node, Position } from './Node.js';
 
-export class Trigger {
-  id: number;
-  name: string;
-  description: string;
+export class Trigger extends Node {
   type: number;
-  parameters: { [key: string]: Parameter };
-  keyMap: { [key: string]: string };
 
-  constructor(trigger: { id: number; name: string; description: string; type: number; parameters: Parameter[] }) {
-    this.id = trigger.id;
-    this.name = trigger.name;
-    this.description = trigger.description;
+  constructor(trigger: { id: number; name: string; description: string; type: number; parameters: Parameter[], ref?: string, position?: Position }) {
+    super({ ...trigger, class: 'trigger' });
     this.type = trigger.type;
-    this.parameters = {};
-    this.keyMap = {};
-    trigger.parameters.forEach(param => {
-      this.parameters[param.key] = { ...param, value: null };
-      const simplifiedKey = this.getSimplifiedKey(param.key);
-      this.keyMap[simplifiedKey] = param.key;
-    });
-  }
-
-  setChainId(value: number): void {
-    this.setParameter('chainId', value);
-  }
-
-  setContractAddress(value: string): void {
-    this.setParameter('contractAddress', value);
   }
 
   setCondition(value: string): void {
@@ -51,78 +29,4 @@ export class Trigger {
     }
     this.setParameter('interval', value);
   }
-
-  setParams(key: string, value: any): void {
-    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`);
-    }
-  }
-
-  private setParameter(key: string, value: any): void {
-    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`);
-    }
-  }
-
-  private validateType(expectedType: string, value: any): boolean {
-    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;
-    }
-  }
-
-  private isAddress(value: string): boolean {
-    return ethers.isAddress(value);
-  }
-
-  getParameter(key: string): any {
-    if (key in this.parameters) {
-      return this.parameters[key].value;
-    } else {
-      throw new Error(`Parameter with key ${key} not found`);
-    }
-  }
-
-  getParameters(): { [key: string]: any } {
-    return Object.keys(this.parameters).reduce((acc, key) => {
-      acc[key] = this.parameters[key].value;
-      return acc;
-    }, {} as { [key: string]: any });
-  }
-
-  toJSON(): { [key: string]: any } {
-    const json: { [key: string]: any } = {
-      id: this.id,
-      parameters: this.getParameters(),
-    };
-    return json;
-  }
-
-  private getSimplifiedKey(key: string): string {
-    return key.replace(/[.\[\]]/g, '_');
-  }
-}
+}

package/src/services/ApiService.ts

@@ -1,6 +1,31 @@
-export interface APISERVICES {
-    key: string;
-    type: string;
-    description: string;
-    value: any;
-  }
+// 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 = {
+  async post(endpoint: string, data: any) {
+    try {
+      const response = await 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/src/utils/typeValidator.ts

@@ -0,0 +1,65 @@
+import { ethers } from 'ethers';
+
+export function validateType(expectedType: string, value: any): boolean {
+    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: number, bits: number): boolean {
+    const min = -(2 ** (bits - 1));
+    const max = (2 ** (bits - 1)) - 1;
+    return value >= min && value <= max;
+}
+
+function isUintInRange(value: number, bits: number): boolean {
+    const max = (2 ** bits) - 1;
+    return value >= 0 && value <= max;
+}
+
+export function isAddress(value: string): boolean {
+    return ethers.isAddress(value);
+}
+
+export function isValidUrl(value: string): boolean {
+    try {
+        new URL(value);
+        return true;
+    } catch (_) {
+        return false;
+    }
+}
+
+export function isValidPhoneNumber(value: string): boolean {
+    return /^[\+]?[0-9]{0,3}\W?[(]?[0-9]{3}[)]?[-\s\.]?[0-9]{3}[-\s\.]?[0-9]{4,6}$/im.test(value);
+}

package/test/action.spec.ts

@@ -0,0 +1,90 @@
+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/test/automation.spec.ts

@@ -0,0 +1,88 @@
+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]);
+  });
+});