otomato-sdk 1.3.2 → 1.3.5

package/src/constants/tokens.ts

@@ -18,7 +18,7 @@ export const TOKENS: Tokens = {
       decimals: 6
     },
   ],
-  43334: [
+  34443: [
     {
       contractAddress: "0x0000000000000000000000000000000000000000",
       name: "ETH",
@@ -101,7 +101,7 @@ export const NFTS: NFTs = {
       contractAddress: "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d",
       name: "BoredApeYachtClub"
     },
-    
+
     {
       contractAddress: "0xbd3531da5cf5857e7cfaa92426877b022e612cf8",
       name: "Pudgy Penguins"
@@ -116,7 +116,7 @@ export const NFTS: NFTs = {
     },
 
   ],
-  43334: [
+  34443: [
     {
       contractAddress: "0x2ad86eeec513ac16804bb05310214c3fd496835b",
       name: "Space id"
@@ -124,7 +124,21 @@ export const NFTS: NFTs = {
   ]
 };
 
-export function getToken(chain: number, symbol: string): Token {
+export function getToken(chain: number, contractAddress: string): Token {
+  if (!(chain in TOKENS)) {
+    throw new Error(`Unsupported chain: ${chain}`);
+  }
+
+  const token = TOKENS[chain].find(token => token.contractAddress.toLowerCase() === contractAddress.toLowerCase());
+
+  if (!token) {
+    throw new Error(`Token with contract address ${contractAddress} not found on chain ${chain}`);
+  }
+
+  return token;
+}
+
+export function getTokenFromSymbol(chain: number, symbol: string): Token {
   if (!(chain in TOKENS)) {
     throw new Error(`Unsupported chain: ${chain}`);
   }

package/src/index.ts

@@ -14,3 +14,4 @@ export * from './models/Edge.js';
 
 // Exporting services
 export * from './services/ApiService.js';
+export * from './utils/helpers.js';

package/src/models/Action.ts

@@ -1,8 +1,82 @@
 import { Parameter } from './Parameter.js';
-import { Node, Position } from './Node.js';
+import { Node, ParentInfo, Position } from './Node.js';
+import { ACTIONS } from '../constants/Blocks.js';
+import { ethers } from 'ethers';
+import { typeIsNumber } from '../utils/typeValidator.js';
 
 export class Action extends Node {
-  constructor(action: { blockId: number; name: string; description: string; parameters: Parameter[], image: string, ref?: string, position?: Position }) {
+  constructor(action: { blockId: number; name: string; description: string; parameters: Parameter[], image: string, ref?: string, position?: Position,  parentInfo?: ParentInfo }) {
     super({ ...action, class: 'action' });
   }
-}
+
+  getStaticParameters(): null {
+    return null;
+  }
+
+  static async fromJSON(json: { [key: string]: any }): Promise<Action> {
+    const enriched = findActionByBlockId(json.blockId);
+
+    const action = new Action({
+      ...enriched.block,
+      ref: json.ref,
+      position: json.position,
+      parentInfo: enriched.parentInfo
+    });
+
+    for (const [key, value] of Object.entries(json.parameters)) {
+      switch (key) {
+        case 'chainId':
+          action.setChainId(value as number);
+          break;
+        case 'contractAddress':
+          action.setContractAddress(value as string);
+          break;
+        case 'abi':
+          const abiParameters = (value as { parameters: { [key: string]: any } }).parameters;
+          for (const abiKey in abiParameters) {
+            const enrichedParameter = enriched.block.parameters.find((param: Parameter) => param.key === `abiParams.${abiKey}`);
+            const paramType = enrichedParameter ? enrichedParameter.type : null;
+
+            if (!abiParameters[abiKey] || !paramType)
+              continue;
+
+            if (typeIsNumber(paramType) && typeof abiParameters[abiKey] === 'string' && abiParameters[abiKey].endsWith('n')) {
+              action.setParams(abiKey, BigInt(abiParameters[abiKey].slice(0, -1)));
+            } else {
+              action.setParams(abiKey, abiParameters[abiKey]);
+            }
+          }
+          break;
+        case 'interval':
+          // ignore
+          break;
+        default:
+          action.setParams(key, value);
+          break;
+      }
+    }
+
+    action.setId(json.id);
+    return action;
+  }
+}
+
+const findActionByBlockId = (blockId: number): { parentInfo: ParentInfo; block: any } => {
+  for (const category in ACTIONS) {
+    for (const service in (ACTIONS as any)[category]) {
+      for (const actionKey in (ACTIONS as any)[category][service]) {
+        if ((ACTIONS as any)[category][service][actionKey].blockId === blockId) {
+          return {
+            parentInfo: {
+              name: service,
+              description: (ACTIONS as any)[category][service].description,
+              image: (ACTIONS as any)[category][service].image,
+            },
+            block: (ACTIONS as any)[category][service][actionKey],
+          };
+        }
+      }
+    }
+  }
+  throw new Error(`Action with id ${blockId} not found`);
+};

package/src/models/Node.ts

@@ -1,18 +1,24 @@
-// Assuming you have the ACTIONS constant defined as you provided
-
 import { Parameter } from './Parameter.js';
 import { validateType } from '../utils/typeValidator.js';
 import { ACTIONS, TRIGGERS } from '../constants/Blocks.js';
+import { Trigger } from './Trigger.js';
+import { Action } from './Action.js';
 
 export interface Position {
   x: number;
   y: number;
 }
 
+export interface ParentInfo {
+  name: string;
+  description: string;
+  image: string;
+}
+
 let nodeCounter = 0;
 const generatedRefs = new Set<string>();
 
-export class Node {
+export abstract class Node {
   id: string | null = null;
   blockId: number;
   name: string;
@@ -23,8 +29,9 @@ export class Node {
   ref: string;
   class: string;
   image: string;
+  parentInfo?: ParentInfo;
 
-  constructor(node: { blockId: number; name: string; description: string; parameters: Parameter[], ref?: string, position?: Position, class: string; image: string }) {
+  constructor(node: { blockId: number; name: string; description: string; parameters: Parameter[], ref?: string, position?: Position, class: string; image: string; parentInfo?: ParentInfo }) {
     this.id = null;
     this.blockId = node.blockId;
     this.name = node.name;
@@ -33,7 +40,8 @@ export class Node {
     this.parameters = {};
     this.keyMap = {};
     this.class = node.class;
-    
+    this.parentInfo = node.parentInfo;
+
     if (node.ref) {
       this.ref = node.ref;
     } else {
@@ -80,6 +88,10 @@ export class Node {
     return this.ref;
   }
 
+  getParentInfo(): ParentInfo | undefined {
+    return this.parentInfo;
+  }
+
   protected setParameter(key: string, value: any): void {
     if (key in this.parameters) {
       const param = this.parameters[key];
@@ -116,83 +128,60 @@ export class Node {
     }, {} as { [key: string]: any });
   }
 
+  getStaticParameters(): { [key: string]: any } | null {
+    return null;
+  }
+
   toJSON(): { [key: string]: any } {
+    const serializeBigInt = (key: string, value: any) => {
+      if (typeof value === 'bigint') {
+        return value.toString() + 'n';
+      } else if (typeof value === 'object' && value !== null) {
+        // Recursively call serializeBigInt for nested objects
+        return Object.entries(value).reduce((acc, [k, v]) => {
+          acc[k] = serializeBigInt(k, v);
+          return acc;
+        }, {} as { [key: string]: any });
+      } else {
+        return value;
+      }
+    };
+
+    const staticParameters = this.getStaticParameters() || {};
+
     const json: { [key: string]: any } = {
       id: this.id,
       ref: this.ref,
       blockId: this.blockId,
       type: this.class,
-      parameters: this.getParameters(),
+      parameters: {
+        ...this.getParameters(),
+        ...staticParameters,
+      },
     };
     if (this.position) {
       json.position = this.position;
     }
-    return json;
+    return JSON.parse(JSON.stringify(json, serializeBigInt));
   }
 
   private getSimplifiedKey(key: string): string {
     return key.replace(/[.\[\]]/g, '_');
   }
 
-  static fromJSON(json: { [key: string]: any }): Node {
-
-    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: number): { name: string; description: string; image: string } | null => {
-  for (const category in ACTIONS) {
-    for (const service in (ACTIONS as any)[category]) {
-      for (const actionKey in (ACTIONS as any)[category][service]) {
-        if ((ACTIONS as any)[category][service][actionKey].blockId === blockId) {
-          return {
-            name: (ACTIONS as any)[category][service][actionKey].name,
-            description: (ACTIONS as any)[category][service][actionKey].description,
-            image: (ACTIONS as any)[category][service][actionKey].image,
-          };
-        }
+  static async fromJSON(json: { [key: string]: any }): Promise<Node> {
+    switch (json.type) {
+      case 'trigger': {
+        const { Trigger } = await import('./Trigger.js');
+        return Trigger.fromJSON(json);
       }
-    }
-  }
-  return null;
-};
-
-const findTriggerByBlockId = (blockId: number): { name: string; description: string; image: string } | null => {
-  for (const category in TRIGGERS) {
-    for (const service in (TRIGGERS as any)[category]) {
-      for (const triggerKey in (TRIGGERS as any)[category][service]) {
-        if ((TRIGGERS as any)[category][service][triggerKey].blockId === blockId) {
-          return {
-            name: (TRIGGERS as any)[category][service][triggerKey].name,
-            description: (TRIGGERS as any)[category][service][triggerKey].description,
-            image: (TRIGGERS as any)[category][service][triggerKey].image,
-          };
-        }
+      case 'action': {
+        const { Action } = await import('./Action.js');
+        return Action.fromJSON(json);
       }
+      default:
+        throw new Error(`Unsupported type: ${json.type}`);
     }
   }
-  return null;
-};
+
+}

package/src/models/Trigger.ts

@@ -1,10 +1,13 @@
+import { Node, ParentInfo, Position } from './Node.js';
 import { Parameter } from './Parameter.js';
-import { Node, Position } from './Node.js';
+import { TRIGGERS } from '../constants/Blocks.js';
+import { ethers } from 'ethers';
+import { typeIsNumber } from '../utils/typeValidator.js';
 
 export class Trigger extends Node {
   type: number;
 
-  constructor(trigger: { blockId: number; name: string; description: string; type: number; parameters: Parameter[], image: string, ref?: string, position?: Position }) {
+  constructor(trigger: { blockId: number; name: string; description: string; type: number; parameters: Parameter[], image: string, ref?: string, position?: Position, parentInfo?: ParentInfo }) {
     super({ ...trigger, class: 'trigger' });
     this.type = trigger.type;
   }
@@ -27,10 +30,85 @@ export class Trigger extends Node {
     this.setParameter('comparisonValue', value);
   }
 
-  setInterval(value: number): void {
-    if (this.notAPollingTrigger()) {
-      throw new Error('Interval setting is not applicable for subscription based triggers.');
+  getStaticParameters(): { interval: number } | null {
+    if (!this.notAPollingTrigger()) {
+      return { interval: 5000 };
     }
-    this.setParameter('interval', value);
+    return null;
+  }
+
+  static async fromJSON(json: { [key: string]: any }): Promise<Trigger> {
+    const enriched = findTriggerByBlockId(json.blockId);
+
+    const trigger = new Trigger({
+      ...enriched.block,
+      ref: json.ref,
+      position: json.position,
+      parentInfo: enriched.parentInfo
+    });
+
+    for (const [key, value] of Object.entries(json.parameters)) {
+      switch (key) {
+        case 'chainId':
+          trigger.setChainId(value as number);
+          break;
+        case 'contractAddress':
+          trigger.setContractAddress(value as string);
+          break;
+        case 'condition':
+          trigger.setCondition(value as string);
+          break;
+        case 'comparisonValue':
+          trigger.setComparisonValue(value as number);
+          break;
+        case 'abi':
+          const abiParameters = (value as { parameters: { [key: string]: any } }).parameters;
+          for (const abiKey in abiParameters) {
+            const enrichedParameter = enriched.block.parameters.find((param: Parameter) => param.key === `abiParams.${abiKey}`);
+            const paramType = enrichedParameter ? enrichedParameter.type : null;
+
+            if (!abiParameters[abiKey] || !paramType)
+              continue;
+
+            if (typeIsNumber(paramType) && typeof abiParameters[abiKey] === 'string' && abiParameters[abiKey].endsWith('n')) {
+              trigger.setParams(abiKey, BigInt(abiParameters[abiKey].slice(0, -1)));
+            } else {
+              trigger.setParams(abiKey, abiParameters[abiKey]);
+            }
+
+          }
+          break;
+        case 'interval':
+          // ignore
+          break;
+        default:
+          trigger.setParams(key, value);
+          break;
+      }
+    }
+
+    trigger.setId(json.id);
+    return trigger;
   }
 }
+
+// Assuming findTriggerByBlockId function is defined as mentioned
+const findTriggerByBlockId = (blockId: number): { parentInfo: ParentInfo; block: any } => {
+  for (const category in TRIGGERS) {
+    for (const service in (TRIGGERS as any)[category]) {
+      for (const triggerKey in (TRIGGERS as any)[category][service]) {
+        if ((TRIGGERS as any)[category][service][triggerKey].blockId === blockId) {
+          return {
+            parentInfo: {
+              name: service,
+              description: (TRIGGERS as any)[category][service].description,
+              image: (TRIGGERS as any)[category][service].image,
+            },
+            block: (TRIGGERS as any)[category][service][triggerKey],
+          };
+        }
+      }
+    }
+  }
+  throw new Error(`Trigger with id ${blockId} not found`);
+};

package/src/models/Workflow.ts

@@ -44,18 +44,27 @@ export class Workflow {
   }
 
   async create() {
-    const response = await apiServices.post('/workflows', this.toJSON());
-    this.id = response.id; // Assign the returned ID to the workflow instance
+    try {
+      const response = await apiServices.post('/workflows', this.toJSON());
 
-    // Assign IDs to the nodes based on the response
-    response.nodes.forEach((nodeResponse: any) => {
-      const node = this.nodes.find(n => n.getRef() === nodeResponse.ref);
-      if (node) {
-        node.setId(nodeResponse.id);
-      }
-    });
+      if (response.status === 201) {
+        this.id = response.data.id; // Assign the returned ID to the workflow instance
+
+        // Assign IDs to the nodes based on the response
+        response.data.nodes.forEach((nodeResponse: any) => {
+          const node = this.nodes.find(n => n.getRef() === nodeResponse.ref);
+          if (node) {
+            node.setId(nodeResponse.id);
+          }
+        });
 
-    return response;
+        return { success: true };
+      } else {
+        return { success: false, error: response.data?.error || 'Unknown error' };
+      }
+    } catch (error: any) {
+      return { success: false, error: error.message || 'Unknown error' };
+    }
   }
 
   async load(workflowId: string): Promise<Workflow> {
@@ -66,4 +75,22 @@ export class Workflow {
     this.edges = response.edges.map((edgeData: any) => Edge.fromJSON(edgeData));
     return this;
   }
+
+  async run() {
+    if (!this.id) {
+      throw new Error('The workflow needs to be published first');
+    }
+  
+    try {
+      const response = await apiServices.post(`/workflows/${this.id}/run`, this.toJSON());
+  
+      if (response.status === 204) {
+        return { success: true };
+      } else {
+        return { success: false, error: response.data?.error || 'Unknown error' };
+      }
+    } catch (error: any) {
+      return { success: false, error: error.message || 'Unknown error' };
+    }
+  }
 }

package/src/services/ApiService.ts

@@ -1,4 +1,3 @@
-// networkService.ts
 import axios from 'axios';
 
 const API_CONFIG = {
@@ -21,10 +20,8 @@ class ApiServices {
   }
 
   async post(url: string, data: any) {
-    console.log(JSON.stringify(data));
     const headers = this.auth ? { 'Authorization': this.auth } : {};
-    const response = await axiosInstance.post(url, data, { headers });
-    return response.data;
+    return await axiosInstance.post(url, data, { headers });
   }
 
   async get(url: string) {
@@ -33,7 +30,29 @@ class ApiServices {
     return response.data;
   }
 
-  // You can add other methods (get, put, delete) similarly
+  async generateLoginPayload(address: string, chainId: number) {
+    const headers = { 'Content-Type': 'application/json' };
+    const response = await axiosInstance.post('/auth/generate-payload', { address, chainId }, { headers });
+    return response.data;
+  }
+
+  async getToken(loginPayload: any, signature: string) {
+    const headers = { 'Content-Type': 'application/json' };
+    const body = {
+      payload: loginPayload,
+      signature,
+    };
+    const response = await axiosInstance.post('/auth/token', body, { headers });
+    const token = response.data.token;
+
+    return { token };
+  }
+
+  async verifyToken(token: string) {
+    const headers = { 'Content-Type': 'application/json' };
+    const response = await axiosInstance.post('/auth/verify-token', { token }, { headers });
+    return response.data;
+  }
 }
 
 export const apiServices = new ApiServices();

package/src/utils/helpers.ts

@@ -0,0 +1,9 @@
+import { ethers } from 'ethers';
+import { getToken } from '../constants/tokens.js';
+
+export async function convertToTokenUnits(amount: number, chainId: number, contractAddress: string): Promise<ethers.BigNumberish> {
+    const token = await getToken(chainId, contractAddress);
+    const decimals = token.decimals;
+    const adjustedAmount = ethers.parseUnits(amount.toString(), decimals);
+    return adjustedAmount;
+}

package/src/utils/typeValidator.ts

@@ -7,11 +7,11 @@ export function validateType(expectedType: string, value: any): boolean {
             return typeof value === 'boolean';
         case 'chainId':
         case 'integer':
-            return Number.isInteger(value)
+            return Number.isInteger(value) || typeof value === 'bigint';
         case 'int8': case 'int16': case 'int32': case 'int64': case 'int128': case 'int256':
-            return Number.isInteger(value) && isIntInRange(value, parseInt(expectedType.replace('int', '')));
+            return (Number.isInteger(value) || typeof value === 'bigint') && 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', '')));
+            return (Number.isInteger(value) || typeof value === 'bigint') && isUintInRange(value, parseInt(expectedType.replace('uint', '')));
         case 'erc20':
         case 'nftCollection':
         case 'address':
@@ -37,15 +37,32 @@ export function validateType(expectedType: string, value: any): boolean {
     }
 }
 
-function isIntInRange(value: number, bits: number): boolean {
-    const min = -(2 ** (bits - 1));
-    const max = (2 ** (bits - 1)) - 1;
-    return value >= min && value <= max;
+export function typeIsNumber(type: string): boolean {
+    switch (type) {
+        case 'integer':
+        case 'float':
+        case 'fixed':
+        case 'ufixed':
+        case 'chainId':
+        case 'int8': case 'int16': case 'int32': case 'int64': case 'int128': case 'int256':
+        case 'uint8': case 'uint16': case 'uint32': case 'uint64': case 'uint128': case 'uint256':
+            return true;
+        default:
+            return false;
+    }
 }
 
-function isUintInRange(value: number, bits: number): boolean {
-    const max = (2 ** bits) - 1;
-    return value >= 0 && value <= max;
+function isIntInRange(value: number | bigint, bits: number): boolean {
+    const min = BigInt(-(2 ** (bits - 1)));
+    const max = BigInt((2 ** (bits - 1)) - 1);
+    const bigIntValue = BigInt(value);
+    return bigIntValue >= min && bigIntValue <= max;
+}
+
+function isUintInRange(value: number | bigint, bits: number): boolean {
+    const max = BigInt((2 ** bits) - 1);
+    const bigIntValue = BigInt(value);
+    return bigIntValue >= 0 && bigIntValue <= max;
 }
 
 export function isAddress(value: string): boolean {
@@ -63,4 +80,4 @@ export function isValidUrl(value: string): boolean {
 
 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);
-}
+}