otomato-sdk 1.5.64 → 1.5.66

package/dist/src/models/Action.js

@@ -10,79 +10,10 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { Node } from './Node.js';
 import { ACTIONS } from '../constants/Blocks.js';
 import { typeIsNumber } from '../utils/typeValidator.js';
-import { SessionKeyPermission } from './SessionKeyPermission.js';
 export class Action extends Node {
     constructor(action) {
         super(Object.assign(Object.assign({}, action), { class: 'action', parentInfo: findActionByBlockId(action.blockId).parentInfo }));
     }
-    getSessionKeyPermissions() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const parentBlock = findActionByBlockId(this.blockId).block;
-            if (!parentBlock.permissions)
-                return null;
-            const permissions = SessionKeyPermission.fromJSON(parentBlock.permissions);
-            permissions.fillParameters(this.getParameters());
-            yield permissions.fillMethod();
-            // Handle 'before' code for the main action
-            if (parentBlock.before) {
-                yield permissions.fillBeforeVariables(parentBlock.before, this.getParameters());
-            }
-            // Handle batchWith: for any batched actions, merge their permissions
-            if (parentBlock.batchWith && parentBlock.batchWith.length > 0) {
-                for (const batch of parentBlock.batchWith) {
-                    const batchedAction = findActionByBlockId(batch.id).block;
-                    if (batchedAction.permissions) {
-                        const batchedActionInstance = new Action(batchedAction);
-                        // Replace placeholders in parameters
-                        const resolvedBatchParams = batch.parameters;
-                        Object.keys(resolvedBatchParams).forEach(key => {
-                            var _a;
-                            // If it's an ABI parameter, handle it separately
-                            if (key === 'abi' && ((_a = resolvedBatchParams.abi) === null || _a === void 0 ? void 0 : _a.parameters)) {
-                                Object.keys(resolvedBatchParams.abi.parameters).forEach(abiKey => {
-                                    const abiValue = this.replaceVariables(resolvedBatchParams.abi.parameters[abiKey]);
-                                    batchedActionInstance.setParams(`${abiKey}`, abiValue);
-                                });
-                            }
-                            else {
-                                let value = this.replaceVariables(resolvedBatchParams[key]);
-                                batchedActionInstance.setParams(key, value);
-                            }
-                        });
-                        // Get batched permissions
-                        const batchedPermissions = yield batchedActionInstance.getSessionKeyPermissions();
-                        if (!batchedPermissions)
-                            continue;
-                        batchedPermissions.fillParameters(batch.parameters); // Pass batched action parameters
-                        yield batchedPermissions.fillMethod();
-                        // Handle 'before' code for the batched action
-                        if (batchedAction.before) {
-                            yield batchedPermissions.fillBeforeVariables(batchedAction.before, batch.parameters);
-                        }
-                        // Merge the batched action's permissions with the main action's permissions
-                        permissions.merge(batchedPermissions);
-                    }
-                }
-            }
-            return permissions;
-        });
-    }
-    /**
-     * Replace any placeholders like {{parameters.tokenToDeposit}} with actual values
-     * from the parameters of the current action. Supports both strings and arrays.
-     */
-    replaceVariables(value) {
-        if (typeof value === 'string') {
-            return value.replace(/\{\{parameters\.(.*?)\}\}/g, (_, key) => {
-                return this.getParameter(key) || '';
-            });
-        }
-        if (Array.isArray(value)) {
-            return value.map(item => this.replaceVariables(item)); // Recursively handle each array element
-        }
-        // Return the value unchanged if it's neither a string nor an array
-        return value;
-    }
     static fromJSON(json) {
         return __awaiter(this, void 0, void 0, function* () {
             const enriched = findActionByBlockId(json.blockId);

package/dist/src/models/SessionKeyPermission.js

@@ -1,185 +1 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { CHAINS } from "../constants/chains.js";
-import { getToken, getTokenFromSymbol } from "../constants/tokens.js";
-export class SessionKeyPermission {
-    constructor({ approvedTargets = [], label = [], labelNotAuthorized = [], } = {}) {
-        this.approvedTargets = approvedTargets;
-        this.label = label;
-        this.labelNotAuthorized = labelNotAuthorized;
-    }
-    fill(key, value) {
-        // Escape special regex characters in the key
-        const escapedKey = key.replace(/[.*+?^${}()|[\]\\[\]]/g, '\\$&');
-        const placeholder = new RegExp(`{{${escapedKey}}}`, 'g');
-        // Function to replace placeholders in a target string
-        const replacePlaceholder = (target) => target.replace(placeholder, value);
-        // Apply the placeholder replacement logic
-        this.approvedTargets = this.approvedTargets.map(replacePlaceholder);
-        this.label = this.label.map(replacePlaceholder);
-        this.labelNotAuthorized = this.labelNotAuthorized.map(replacePlaceholder);
-    }
-    /**
-     * Fill placeholders using variables returned by the 'before' string execution.
-     * @param beforeCode - A string representing the 'before' logic to execute.
-     */
-    fillBeforeVariables(beforeCode, parameters) {
-        return __awaiter(this, void 0, void 0, function* () {
-            console.log("filling before variable");
-            try {
-                // Prepare the otomatoSdk object with required functions
-                const otomatoSdk = {
-                    getToken,
-                    getTokenFromSymbol,
-                    CHAINS
-                    // Include any other functions you need from otomato-sdk
-                };
-                // Prepare the environment with parameters and otomatoSdk
-                const env = { parameters, otomatoSdk };
-                // Replace the dynamic import in beforeCode
-                const beforeCodeUpdated = beforeCode.replace(/const\s+otomatoSdk\s*=\s*await\s*import\(['"]otomato-sdk['"]\);/, 'const otomatoSdk = env.otomatoSdk;');
-                // Wrap the beforeCode in an async function and immediately invoke it
-                const asyncBeforeFn = new Function('env', `
-        return (async function() {
-          return await (${beforeCodeUpdated})(env);
-        })();
-      `);
-                // Execute the async function and await the result
-                const beforeResult = yield asyncBeforeFn(env);
-                // Replace placeholders like {{before.variableName}} with the corresponding values
-                if (beforeResult && typeof beforeResult === 'object') {
-                    Object.keys(beforeResult).forEach((key) => {
-                        this.fill(`before.${key}`, beforeResult[key]);
-                    });
-                }
-                else {
-                    console.error("Before function did not return an object:", beforeResult);
-                }
-            }
-            catch (error) {
-                console.error("Error executing before code:", error);
-            }
-        });
-    }
-    // The rest of your existing code
-    fillParameters(params) {
-        var _a;
-        // Helper to handle the replacement in case of arrays
-        const fillArray = (key, array) => {
-            array.forEach((item, index) => {
-                if (typeof item === 'string') {
-                    this.fill(`${key}[${index}]`, item);
-                }
-            });
-        };
-        // 1. Replace non-ABI params
-        for (let key in params) {
-            if (key !== 'abi') {
-                if (Array.isArray(params[key])) {
-                    fillArray(`parameters.${key}`, params[key]);
-                }
-                else {
-                    this.fill(`parameters.${key}`, params[key]);
-                }
-            }
-        }
-        // 2. Replace ABI params
-        const abiParams = (_a = params.abi) === null || _a === void 0 ? void 0 : _a.parameters;
-        for (let key in abiParams) {
-            if (Array.isArray(abiParams[key])) {
-                fillArray(`parameters.abi.parameters.${key}`, abiParams[key]);
-            }
-            else {
-                this.fill(`parameters.abi.parameters.${key}`, abiParams[key]);
-            }
-        }
-    }
-    fillMethod() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const executeMethod = (target) => __awaiter(this, void 0, void 0, function* () {
-                const methodPattern = /\{\{(\w+)\(([^)]+)\)\}\}/g;
-                // Find all matches of the pattern in the target string
-                const matches = [...target.matchAll(methodPattern)];
-                // Process each match asynchronously
-                for (const match of matches) {
-                    const [fullMatch, methodName, params] = match;
-                    const paramList = params.split(',').map((param) => param.trim());
-                    let replacement;
-                    switch (methodName) {
-                        case 'tokenSymbol': {
-                            const [chainId, address] = paramList;
-                            const token = yield getToken(parseInt(chainId, 10), address);
-                            replacement = token ? token.symbol : fullMatch;
-                            break;
-                        }
-                        case 'otherTokenSymbol': {
-                            const [chainId, address] = paramList;
-                            const symbol = yield getDifferentToken(parseInt(chainId, 10), address);
-                            replacement = symbol;
-                            break;
-                        }
-                        // Add other methods here as needed
-                        default:
-                            replacement = fullMatch; // If no method matches, leave it unchanged
-                    }
-                    // Replace the matched pattern with the resolved value
-                    target = target.replace(fullMatch, replacement || fullMatch);
-                }
-                return target;
-            });
-            // Apply executeMethod asynchronously to approvedTargets, label, and labelNotAuthorized
-            this.approvedTargets = yield Promise.all(this.approvedTargets.map(executeMethod));
-            this.label = yield Promise.all(this.label.map(executeMethod));
-            this.labelNotAuthorized = yield Promise.all(this.labelNotAuthorized.map(executeMethod));
-        });
-    }
-    toJSON() {
-        const containsPlaceholder = this.approvedTargets.some(target => target.includes('$'));
-        if (containsPlaceholder) {
-            throw new Error('Approved targets contain unresolved placeholders.');
-        }
-        return {
-            approvedTargets: this.approvedTargets,
-            label: this.label,
-            labelNotAuthorized: this.labelNotAuthorized,
-        };
-    }
-    static fromJSON(json) {
-        if (!json || !Array.isArray(json.approvedTargets)) {
-            console.error('Invalid JSON object for SessionKeyPermission:', json);
-            throw new Error('Invalid JSON object for SessionKeyPermission');
-        }
-        return new SessionKeyPermission(json);
-    }
-    merge(other) {
-        // Merge approvedTargets
-        const uniqueTargets = new Set(this.approvedTargets);
-        other.approvedTargets.forEach(target => uniqueTargets.add(target));
-        this.approvedTargets = Array.from(uniqueTargets);
-        // Merge labels
-        const uniqueLabels = new Set(this.label);
-        other.label.forEach(lbl => uniqueLabels.add(lbl));
-        this.label = Array.from(uniqueLabels);
-        // Merge labelNotAuthorized
-        const uniqueLabelsNotAuthorized = new Set(this.labelNotAuthorized);
-        other.labelNotAuthorized.forEach(lbl => uniqueLabelsNotAuthorized.add(lbl));
-        this.labelNotAuthorized = Array.from(uniqueLabelsNotAuthorized);
-        // Remove labels from labelNotAuthorized if they are present in label
-        this.labelNotAuthorized = this.labelNotAuthorized.filter(lbl => !this.label.includes(lbl));
-    }
-}
-// Helper function to get a different token
-const getDifferentToken = (chain, contractAddress) => __awaiter(void 0, void 0, void 0, function* () {
-    var _a;
-    const tokenSymbol = (_a = (yield getToken(chain, contractAddress))) === null || _a === void 0 ? void 0 : _a.symbol;
-    if (!tokenSymbol || tokenSymbol !== 'WETH')
-        return 'WETH';
-    return 'USDT';
-});
+export {};

package/dist/src/models/Workflow.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { Node } from './Node.js';
 import { Edge } from './Edge.js';
 import { apiServices } from '../services/ApiService.js';
-import { SessionKeyPermission } from './SessionKeyPermission.js';
 export class Workflow {
     constructor(name = '', nodes = [], edges = []) {
         this.id = null;
@@ -93,6 +92,7 @@ export class Workflow {
                 }
             }
             catch (error) {
+                console.log(error);
                 return { success: false, error: error.message || 'Unknown error' };
             }
         });
@@ -207,21 +207,9 @@ export class Workflow {
     }
     getSessionKeyPermissions() {
         return __awaiter(this, void 0, void 0, function* () {
-            const permissions = new SessionKeyPermission();
-            for (const node of this.nodes) {
-                try {
-                    if (node.class === 'action' && 'getSessionKeyPermissions' in node) {
-                        const nodePermissions = yield node.getSessionKeyPermissions();
-                        if (nodePermissions) {
-                            permissions.merge(nodePermissions);
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error(`Error getting session key permissions for node ${node.getRef()}:`, error);
-                }
-            }
-            return permissions;
+            if (!this.id)
+                throw new Error('The workflow needs to be published first');
+            return apiServices.getSessionKeyPermissions(this.id);
         });
     }
 }

package/dist/src/services/ApiService.js

@@ -81,10 +81,31 @@ class ApiServices {
     }
     getWorkflowsOfUser() {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.auth) {
+                throw new Error('Authorization token is required');
+            }
             const headers = this.auth ? { 'Authorization': this.auth } : {};
             const response = yield axiosInstance.get('/workflows', { headers });
             return response.data;
         });
     }
+    getSessionKeyPermissions(workflowId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b, _c;
+            if (!this.auth) {
+                throw new Error('Authorization token is required');
+            }
+            try {
+                const url = `/workflows/${workflowId}/verify-contracts`;
+                const headers = { Authorization: this.auth };
+                const response = yield axiosInstance.post(url, {}, { headers });
+                return response.data; // Return the data from the response
+            }
+            catch (error) {
+                console.error('Error verifying contracts:', ((_a = error.response) === null || _a === void 0 ? void 0 : _a.data) || error.message);
+                throw new Error(((_c = (_b = error.response) === null || _b === void 0 ? void 0 : _b.data) === null || _c === void 0 ? void 0 : _c.message) || 'Failed to verify contracts');
+            }
+        });
+    }
 }
 export const apiServices = new ApiServices();

package/dist/src/services/RpcServices.js

@@ -36,7 +36,6 @@ class RPCServices {
     getTokenDetails(chainId, contractAddress) {
         return __awaiter(this, void 0, void 0, function* () {
             const rpcUrl = this.getRPC(chainId); // Get the RPC URL for the chain
-            // Create a provider using ethers.js
             const provider = new ethers.JsonRpcProvider(rpcUrl);
             // Define the contract ABI for the read-only functions (decimals, name, symbol)
             const erc20ABI = [
@@ -44,14 +43,33 @@ class RPCServices {
                 'function name() view returns (string)',
                 'function symbol() view returns (string)',
             ];
-            // Create a contract instance
             const contract = new ethers.Contract(contractAddress, erc20ABI, provider);
-            // Fetch the decimals, name, and symbol in parallel using Promise.all
+            const maxRetries = 3; // Max number of retries
+            const retryDelay = (attempt) => Math.pow(2, attempt) * 1000; // Exponential backoff delay (in milliseconds)
+            // Define a helper function to retry the RPC call
+            const fetchWithRetry = (fn, retries) => __awaiter(this, void 0, void 0, function* () {
+                let attempt = 0;
+                while (attempt <= retries) {
+                    try {
+                        return yield fn();
+                    }
+                    catch (error) {
+                        if (attempt === retries) {
+                            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...`);
+                        yield new Promise(resolve => setTimeout(resolve, retryDelay(attempt)));
+                    }
+                }
+                throw new Error('Max retries exceeded');
+            });
+            // Fetch the decimals, name, and symbol with retries
             try {
                 const [decimals, name, symbol] = yield Promise.all([
-                    contract.decimals(),
-                    contract.name(),
-                    contract.symbol(),
+                    fetchWithRetry(() => contract.decimals(), maxRetries),
+                    fetchWithRetry(() => contract.name(), maxRetries),
+                    fetchWithRetry(() => contract.symbol(), maxRetries),
                 ]);
                 const token = {
                     contractAddress,

package/dist/src/utils/helpers.js

@@ -15,13 +15,10 @@ export function convertToTokenUnits(amount, chainId, contractAddress) {
         const decimals = token.decimals;
         // Calculate the result as a number first
         const result = amount * Math.pow(10, decimals);
-        console.log("result", result);
         // Check if the result is an integer
         if (!Number.isInteger(result)) {
-            console.log("throwing");
             throw new Error(`Conversion resulted in a non-integer value: ${result}. Please provide an amount that results in a whole number of token units.`);
         }
-        console.log("is an integer");
         // If we've reached here, the result is an integer, so we can safely convert to BigInt
         return BigInt(Math.round(result));
     });

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

@@ -1,6 +1,5 @@
 import { Parameter } from './Parameter.js';
 import { Node, ParentInfo, Position, NodeState } from './Node.js';
-import { SessionKeyPermission } from './SessionKeyPermission.js';
 export declare class Action extends Node {
     constructor(action: {
         blockId: number;
@@ -16,12 +15,6 @@ export declare class Action extends Node {
         parentInfo?: ParentInfo;
         state?: NodeState;
     });
-    getSessionKeyPermissions(): Promise<SessionKeyPermission | null>;
-    /**
-     * Replace any placeholders like {{parameters.tokenToDeposit}} with actual values
-     * from the parameters of the current action. Supports both strings and arrays.
-     */
-    replaceVariables(value: any): any;
     static fromJSON(json: {
         [key: string]: any;
     }): Promise<Action>;

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

@@ -1,29 +1,6 @@
-export declare class SessionKeyPermission {
+export type SessionKeyPermission = {
+    isValid: boolean;
     approvedTargets: string[];
     label: string[];
     labelNotAuthorized: string[];
-    constructor({ approvedTargets, label, labelNotAuthorized, }?: {
-        approvedTargets?: string[];
-        label?: string[];
-        labelNotAuthorized?: string[];
-    });
-    fill(key: string, value: any): void;
-    /**
-     * Fill placeholders using variables returned by the 'before' string execution.
-     * @param beforeCode - A string representing the 'before' logic to execute.
-     */
-    fillBeforeVariables(beforeCode: string, parameters: {
-        [key: string]: any;
-    }): Promise<void>;
-    fillParameters(params: {
-        [key: string]: any;
-    }): void;
-    fillMethod(): Promise<void>;
-    toJSON(): {
-        [key: string]: any;
-    };
-    static fromJSON(json: {
-        [key: string]: any;
-    }): SessionKeyPermission;
-    merge(other: SessionKeyPermission): void;
-}
+};

package/dist/types/src/services/ApiService.d.ts

@@ -12,6 +12,7 @@ declare class ApiServices {
     }>;
     verifyToken(token: string): Promise<any>;
     getWorkflowsOfUser(): Promise<any>;
+    getSessionKeyPermissions(workflowId: string): Promise<any>;
 }
 export declare const apiServices: ApiServices;
 export {};

package/dist/types/test/e2e/e2e.spec.d.ts

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

package/package.json

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