otomato-sdk 1.5.80 → 1.5.82

package/dist/src/constants/tokens.js

@@ -29,7 +29,8 @@ export const TOKENS = {
             name: "ETH",
             symbol: "ETH",
             decimals: 18,
-            hideInUI: true,
+            nativeCurrency: true,
+            equivalentERC20: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
             image: "https://static.debank.com/image/chain/logo_url/eth/42ba589cd077e7bdd97db6480b0ff61d.png"
         },
         {
@@ -46,7 +47,8 @@ export const TOKENS = {
             name: "ETH",
             symbol: "ETH",
             decimals: 18,
-            hideInUI: true,
+            nativeCurrency: true,
+            equivalentERC20: "0x4200000000000000000000000000000000000006",
             image: "https://static.debank.com/image/chain/logo_url/eth/42ba589cd077e7bdd97db6480b0ff61d.png"
         },
         {

package/dist/src/constants/version.js

@@ -1,4 +1,4 @@
-export const SDK_VERSION = '1.5.80';
+export const SDK_VERSION = '1.5.82';
 export function compareVersions(v1, v2) {
     // Split the version strings into parts
     const v1Parts = v1.split('.').map(Number);

package/dist/src/index.js

@@ -4,10 +4,12 @@ export * from './constants/chains.js';
 export * from './constants/version.js';
 export * from './constants/tokens.js';
 export * from './constants/WorkflowTemplates.js';
+export * from './constants/logicOperators.js';
 // Exporting models
 export * from './models/Action.js';
 export * from './models/Workflow.js';
-export * from './models/Condition.js';
+export * from './models/conditions/ConditionCheck.js';
+export * from './models/conditions/ConditionGroup.js';
 export * from './models/Parameter.js';
 export * from './models/Trigger.js';
 export * from './models/Node.js';

package/dist/src/models/Edge.js

@@ -7,31 +7,49 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+import { Node } from './Node.js';
 import { apiServices } from '../services/ApiService.js';
 export class Edge {
     constructor(edge) {
         var _a;
+        if (!edge.source || !(edge.source instanceof Node)) {
+            throw new Error('Edge must have a valid source node.');
+        }
+        if (!edge.target || !(edge.target instanceof Node)) {
+            throw new Error('Edge must have a valid target node.');
+        }
         this.id = (_a = edge.id) !== null && _a !== void 0 ? _a : null;
         this.source = edge.source;
         this.target = edge.target;
+        this.label = edge.label;
+        this.value = edge.value;
     }
     toJSON() {
-        return {
+        const result = {
             id: this.id,
             source: this.source.getRef(),
             target: this.target.getRef(),
         };
+        if (this.label != null) {
+            result.label = this.label;
+        }
+        if (this.value != null) {
+            result.value = this.value;
+        }
+        return result;
     }
     static fromJSON(json, nodes) {
-        const source = nodes.find(n => n.getRef() === json.source);
-        const target = nodes.find(n => n.getRef() === json.target);
+        const source = nodes.find((n) => n.getRef() === json.source);
+        const target = nodes.find((n) => n.getRef() === json.target);
         if (!source || !target) {
-            throw new Error("Edge refers to a non-existing node");
+            throw new Error('Edge refers to a non-existing node');
         }
         return new Edge({
             id: json.id,
             source,
-            target
+            target,
+            label: json.label,
+            value: json.value,
         });
     }
     delete() {

package/dist/src/models/Node.js

@@ -149,8 +149,12 @@ export class Node {
             if (typeof value === 'bigint') {
                 return value.toString() + 'n';
             }
+            else if (Array.isArray(value)) {
+                // Handle arrays by mapping over each element
+                return value.map((item) => serializeBigInt('', item));
+            }
             else if (typeof value === 'object' && value !== null) {
-                // Recursively call serializeBigInt for nested objects
+                // Recursively handle objects
                 return Object.entries(value).reduce((acc, [k, v]) => {
                     acc[k] = serializeBigInt(k, v);
                     return acc;

package/dist/src/services/RpcServices.js

@@ -59,7 +59,7 @@ class RPCServices {
                             throw new Error(`Error fetching token details ${contractAddress} on chain ${chainId}`);
                         }
                         attempt++;
-                        console.warn(`Attempt ${attempt} to fetch token details failed. Retrying in ${retryDelay(attempt)}ms...`);
+                        // console.warn(`Attempt ${attempt} to fetch token details failed. Retrying in ${retryDelay(attempt)}ms...`);
                         yield new Promise(resolve => setTimeout(resolve, retryDelay(attempt)));
                     }
                 }

package/dist/src/utils/helpers.js

@@ -9,6 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { ethers } from 'ethers';
 import { getToken, getTokenFromSymbol } from '../constants/tokens.js';
+import { isAddress, isNumericString } from './typeValidator.js';
 export function convertToTokenUnits(amount, chainId, contractAddress) {
     return __awaiter(this, void 0, void 0, function* () {
         const token = yield getToken(chainId, contractAddress);
@@ -72,3 +73,21 @@ export function compareAddresses(address1, address2) {
     // Compare the normalized addresses
     return normalizedAddress1 === normalizedAddress2;
 }
+/**
+ * Generates a formula string for dynamically computing the ERC20 amount in the workflow,
+ * based on the amount, chain ID, and contract address.
+ * If the contract address is valid, it will be wrapped in double quotes.
+ * If the amount is a numeric string, it will also be wrapped in double quotes.
+ * @param amount - The amount of the ERC20 token to compute.
+ * @param chainId - The ID of the blockchain network.
+ * @param contractAddress - The contract address of the ERC20 token.
+ * @returns string - A formatted string to be used as a variable in the workflow.
+ */
+export function getComputeERC20Variable(amount, chainId, contractAddress) {
+    // Check if the contract address is a valid Ethereum address and wrap in quotes if it is
+    const formattedContractAddress = isAddress(contractAddress) ? `"${contractAddress}"` : contractAddress;
+    // Check if the amount is a numeric string and wrap it in quotes if it is
+    const formattedAmount = isNumericString(amount) ? `${amount}` : amount;
+    // Construct the computeERC20Amount formula
+    return `{{computeERC20Amount(${formattedAmount}, ${chainId}, ${formattedContractAddress})}}`;
+}

package/dist/src/utils/typeValidator.js

@@ -49,12 +49,64 @@ export function validateType(expectedType, value) {
         case 'addresses_array':
             // Ensure value is an array, and each element is a valid address
             return Array.isArray(value) && value.every(isAddress);
+        case 'condition_groups':
+            return Array.isArray(value) && value.every(isValidConditionGroup);
+        case 'and_or':
+            const validLogicOperators = new Set(['and', 'or']);
+            return typeof value === 'string' && validLogicOperators.has(value.toLowerCase());
         case 'any':
             return true;
         default:
             return false;
     }
 }
+function isValidConditionGroup(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const { logic, checks } = value;
+    validateType('and_or', logic);
+    // Validate checks array
+    if (!Array.isArray(checks) || checks.length === 0) {
+        return false;
+    }
+    // Validate each condition check
+    for (const check of checks) {
+        if (!isValidConditionCheck(check)) {
+            return false;
+        }
+    }
+    return true;
+}
+function isValidConditionCheck(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    const { value1, condition, value2 } = value;
+    // Validate condition operator
+    const validConditionOperators = new Set(['gte', 'gt', 'lte', 'lt', 'eq', 'neq']);
+    if (typeof condition !== 'string' || !validConditionOperators.has(condition.toLowerCase())) {
+        return false;
+    }
+    // Validate value1 and value2 (they can be numbers, strings, or variables)
+    if (!isValidValue(value1) || !isValidValue(value2)) {
+        return false;
+    }
+    return true;
+}
+function isValidValue(value) {
+    if (typeof value === 'number' || typeof value === 'bigint') {
+        return true;
+    }
+    if (typeof value === 'string') {
+        if (isVariable(value)) {
+            return true; // It's a variable placeholder
+        }
+        // Optionally, add further validation for strings if needed
+        return true;
+    }
+    return false;
+}
 function isVariable(value) {
     return /\{\{nodeMap\.[^.}]+\.(?:output|parameters(?:\.abi\.parameters)?)\.[^.}]+\}\}/.test(value);
 }
@@ -111,3 +163,11 @@ export function isValidPhoneNumber(value) {
 export function isValidEmail(value) {
     return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
 }
+/**
+ * Checks if a string is numeric (represents a valid number).
+ * @param value - The string to check.
+ * @returns boolean - True if the string represents a number, false otherwise.
+ */
+export function isNumericString(value) {
+    return !isNaN(Number(value)) && value.trim() !== '';
+}

package/dist/types/examples/create-workflow-with-condition-and-split.d.ts

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

package/dist/types/examples/create-workflow-with-split.d.ts

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

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

@@ -5,6 +5,8 @@ export interface Token {
     decimals: number;
     image: string | null;
     hideInUI?: boolean | null;
+    nativeCurrency?: boolean | null;
+    equivalentERC20?: string | null;
 }
 export interface Tokens {
     [key: number]: Token[];

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

@@ -1,2 +1,2 @@
-export declare const SDK_VERSION = "1.5.80";
+export declare const SDK_VERSION = "1.5.82";
 export declare function compareVersions(v1: string, v2: string): number;

package/dist/types/src/index.d.ts

@@ -3,9 +3,11 @@ export * from './constants/chains.js';
 export * from './constants/version.js';
 export * from './constants/tokens.js';
 export * from './constants/WorkflowTemplates.js';
+export * from './constants/logicOperators.js';
 export * from './models/Action.js';
 export * from './models/Workflow.js';
-export * from './models/Condition.js';
+export * from './models/conditions/ConditionCheck.js';
+export * from './models/conditions/ConditionGroup.js';
 export * from './models/Parameter.js';
 export * from './models/Trigger.js';
 export * from './models/Node.js';

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

@@ -3,10 +3,14 @@ export declare class Edge {
     id: string | null;
     source: Node;
     target: Node;
+    label?: string;
+    value?: any;
     constructor(edge: {
         id?: string | null;
         source: Node;
         target: Node;
+        label?: string;
+        value?: any;
     });
     toJSON(): {
         [key: string]: any;

package/dist/types/src/utils/helpers.d.ts

@@ -12,3 +12,14 @@ export declare function convertTokenUnitsFromDecimals(amount: bigint, decimals:
  * @returns boolean - True if the addresses are equal, false otherwise.
  */
 export declare function compareAddresses(address1: string, address2: string): boolean;
+/**
+ * Generates a formula string for dynamically computing the ERC20 amount in the workflow,
+ * based on the amount, chain ID, and contract address.
+ * If the contract address is valid, it will be wrapped in double quotes.
+ * If the amount is a numeric string, it will also be wrapped in double quotes.
+ * @param amount - The amount of the ERC20 token to compute.
+ * @param chainId - The ID of the blockchain network.
+ * @param contractAddress - The contract address of the ERC20 token.
+ * @returns string - A formatted string to be used as a variable in the workflow.
+ */
+export declare function getComputeERC20Variable(amount: string, chainId: any, contractAddress: string): string;

package/dist/types/src/utils/typeValidator.d.ts

@@ -4,3 +4,9 @@ export declare function isAddress(value: string): boolean;
 export declare function isValidUrl(value: string): boolean;
 export declare function isValidPhoneNumber(value: string): boolean;
 export declare function isValidEmail(value: string): boolean;
+/**
+ * Checks if a string is numeric (represents a valid number).
+ * @param value - The string to check.
+ * @returns boolean - True if the string represents a number, false otherwise.
+ */
+export declare function isNumericString(value: string): boolean;

package/package.json

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