otomato-sdk 2.0.21 → 2.0.22

package/dist/src/constants/Blocks.js

@@ -2575,6 +2575,139 @@ export const TRIGGERS = {
 };
 export const ACTIONS = {
     "CORE": {
+        "EMPTYBLOCK": {
+            "image": "",
+            "description": "",
+            "chains": [],
+            "EMPTYBLOCK": {
+                "name": "Odos swap",
+                "description": "Swap on Odos to get the best market rates accross multiple pools",
+                "type": 1,
+                "requiredApprovals": [
+                    {
+                        "address": "{{parameters.tokenIn}}",
+                        "amount": "{{parameters.amount}}",
+                        "to": "{{before.contractAddress}}"
+                    }
+                ],
+                "checks": [
+                    {
+                        "type": 0,
+                        "chainId": "{{parameters.chainId}}",
+                        "contractAddress": "{{parameters.tokenIn}}",
+                        "amount": "{{parameters.amount}}"
+                    }
+                ],
+                "output": {
+                    "amountIn": "uint256",
+                    "tokenIn": "erc20",
+                    "amountOut": "uint256",
+                    "tokenOut": "erc20",
+                    "transactionHash": "string"
+                },
+                "frontendHelpers": {
+                    "output": {
+                        "amountIn": {
+                            "erc20Token": {
+                                "contractAddress": "{{output.tokenIn}}",
+                                "chainId": "{{parameters.chainId}}"
+                            }
+                        },
+                        "amountOut": {
+                            "erc20Token": {
+                                "contractAddress": "{{output.tokenOut}}",
+                                "chainId": "{{parameters.chainId}}"
+                            }
+                        }
+                    }
+                },
+                "parameters": [
+                    {
+                        "key": "chainId",
+                        "type": "chainId",
+                        "description": "Chain ID of the network",
+                        "mandatory": true,
+                        "category": 0
+                    },
+                    {
+                        "key": "tokenIn",
+                        "type": "erc20",
+                        "description": "Token to sell",
+                        "mandatory": true,
+                        "category": 0
+                    },
+                    {
+                        "key": "tokenOut",
+                        "type": "erc20",
+                        "description": "Token to buy",
+                        "mandatory": true,
+                        "category": 0
+                    },
+                    {
+                        "key": "amount",
+                        "type": "uint256",
+                        "description": "Amount to sell",
+                        "mandatory": true,
+                        "category": 0,
+                        "erc20FormattedAmount": {
+                            "contractAddress": "{{parameters.tokenIn}}",
+                            "chain": "{{parameters.chainId}}"
+                        }
+                    },
+                    {
+                        "key": "slippage",
+                        "type": "percentage",
+                        "description": "The maximum allowable difference between the expected price and the actual price at the time of execution, expressed as a percentage. This protects the transaction from significant price fluctuations.",
+                        "value": 1,
+                        "mandatory": true,
+                        "category": 1
+                    },
+                ],
+                "examples": [
+                    {
+                        "name": "Swap USDC to WETH",
+                        "description": "Swap 100 USDC to WETH on Mode Network using Odos",
+                        "parameters": [
+                            {
+                                "key": "chainId",
+                                "value": 34443
+                            },
+                            {
+                                "key": "tokenIn",
+                                "value": "0xd988097fb8612cc24eeC14542bC03424c656005f"
+                            },
+                            {
+                                "key": "tokenOut",
+                                "value": "0x4200000000000000000000000000000000000006"
+                            },
+                            {
+                                "key": "amount",
+                                "value": "100000000n"
+                            },
+                            {
+                                "key": "slippage",
+                                "value": 1
+                            }
+                        ]
+                    }
+                ],
+                "permissions": {
+                    "chainId": "{{parameters.chainId}}",
+                    "approvedTargets": [
+                        "{{before.contractAddress}}",
+                        "{{parameters.tokenIn}}"
+                    ],
+                    "label": [
+                        "Swap {{tokenSymbol({{parameters.chainId}}, {{parameters.tokenIn}})}} to {{tokenSymbol({{parameters.chainId}}, {{parameters.tokenOut}})}}"
+                    ],
+                    "labelNotAuthorized": [
+                        "Transfer ETH"
+                    ]
+                },
+                "blockId": 0,
+                "image": ""
+            }
+        },
         "DELAY": {
             "description": "Set of functions to delay the executions of the following blocks.",
             "image": "https://otomato-sdk-images.s3.eu-west-1.amazonaws.com/delay.png",
@@ -3409,7 +3542,8 @@ export const ACTIONS = {
                 "permissions": {
                     "chainId": "{{parameters.chainId}}",
                     "approvedTargets": [
-                        "{{before.contractAddress}}"
+                        "{{before.contractAddress}}",
+                        "{{parameters.tokenToRepay}}"
                     ],
                     "label": [
                         "Repay {{tokenSymbol({{parameters.chainId}}, {{parameters.tokenToRepay}})}} on IONIC"

package/dist/src/constants/version.js

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

package/dist/src/models/Workflow.js

@@ -59,17 +59,42 @@ export class Workflow {
         // Recalculate positions
         positionWorkflowNodesAvoidOverlap(this);
     }
-    insertNode(nodeToInsert, nodeBefore, nodeAfter) {
+    /**
+     * Inserts a new node into the workflow:
+     * - If both nodeBefore and nodeAfter are provided, we expect an existing edge
+     *   from nodeBefore -> nodeAfter, which gets replaced by two edges:
+     *   nodeBefore -> nodeToInsert and nodeToInsert -> nodeAfter.
+     *
+     * - If nodeAfter is NOT provided, we create a single edge from nodeBefore
+     *   to nodeToInsert. The user can optionally provide `edgeLabel` and `edgeValue`
+     *   in that scenario only.
+     *
+     * @param nodeToInsert  The node you want to insert
+     * @param nodeBefore    The existing node in the workflow that precedes `nodeToInsert`
+     * @param nodeAfter     (Optional) The existing node that should follow `nodeToInsert`
+     * @param edgeLabel     (Optional) Label for the edge, only allowed if `nodeAfter` is not provided
+     * @param edgeValue     (Optional) Value for the edge, only allowed if `nodeAfter` is not provided
+     */
+    insertNode(nodeToInsert, nodeBefore, nodeAfter, edgeLabel = null, edgeValue = null) {
         // Ensure nodeBefore exists in the workflow
         if (!this.nodes.includes(nodeBefore)) {
             throw new Error('The nodeBefore must exist in the workflow.');
         }
+        // If nodeAfter is provided, disallow edgeLabel/edgeValue
+        if (nodeAfter && (edgeLabel !== null || edgeValue !== null)) {
+            throw new Error('Cannot provide edgeLabel/edgeValue if nodeAfter is specified.');
+        }
         // If nodeAfter is not provided, insert the new node as a child of nodeBefore
         if (!nodeAfter) {
             // Add the new node to the workflow
             this.addNode(nodeToInsert);
-            // Add a new edge between nodeBefore and nodeToInsert
-            const newEdge = new Edge({ source: nodeBefore, target: nodeToInsert });
+            // Add a new edge between nodeBefore and nodeToInsert (with optional label/value)
+            const newEdge = new Edge({
+                source: nodeBefore,
+                target: nodeToInsert,
+                label: edgeLabel !== null && edgeLabel !== void 0 ? edgeLabel : undefined,
+                value: edgeValue !== null && edgeValue !== void 0 ? edgeValue : undefined
+            });
             this.addEdge(newEdge);
             // Recalculate positions
             positionWorkflowNodesAvoidOverlap(this);
@@ -167,6 +192,19 @@ export class Workflow {
         return this.notes.map(note => note.toJSON());
     }
     toJSON() {
+        // 1. Create a new Workflow instance, copying only the nodes, edges, and notes
+        const clonedWorkflow = new Workflow(this.name, // same name
+        [...this.nodes], // shallow copy of nodes
+        [...this.edges] // shallow copy of edges
+        );
+        clonedWorkflow.notes = [...this.notes]; // shallow copy of notes array
+        // 2. Identify any empty nodes (blockId === 0), then delete them from the clone
+        const emptyNodes = clonedWorkflow.nodes.filter(node => node.blockId === 0);
+        for (const emptyNode of emptyNodes) {
+            clonedWorkflow.deleteNode(emptyNode);
+        }
+        // 3. Return JSON using 'this' for top-level info (id, state, etc.),
+        //    but using the clonedWorkflow's nodes, edges, and notes
         return {
             id: this.id,
             name: this.name,
@@ -174,9 +212,9 @@ export class Workflow {
             dateCreated: this.dateCreated,
             dateModified: this.dateModified,
             executionId: this.executionId,
-            nodes: this.nodes.map(node => node.toJSON()),
-            edges: this.edges.map(edge => edge.toJSON()),
-            notes: this.getNotes(),
+            nodes: clonedWorkflow.nodes.map(node => node.toJSON()),
+            edges: clonedWorkflow.edges.map(edge => edge.toJSON()),
+            notes: clonedWorkflow.getNotes(),
         };
     }
     create() {

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

@@ -1067,6 +1067,70 @@ export declare const TRIGGERS: {
 };
 export declare const ACTIONS: {
     CORE: {
+        EMPTYBLOCK: {
+            image: string;
+            description: string;
+            chains: never[];
+            EMPTYBLOCK: {
+                name: string;
+                description: string;
+                type: number;
+                requiredApprovals: {
+                    address: string;
+                    amount: string;
+                    to: string;
+                }[];
+                checks: {
+                    type: number;
+                    chainId: string;
+                    contractAddress: string;
+                    amount: string;
+                }[];
+                output: {
+                    amountIn: string;
+                    tokenIn: string;
+                    amountOut: string;
+                    tokenOut: string;
+                    transactionHash: string;
+                };
+                frontendHelpers: {
+                    output: {
+                        amountIn: {
+                            erc20Token: {
+                                contractAddress: string;
+                                chainId: string;
+                            };
+                        };
+                        amountOut: {
+                            erc20Token: {
+                                contractAddress: string;
+                                chainId: string;
+                            };
+                        };
+                    };
+                };
+                parameters: Parameter[];
+                examples: {
+                    name: string;
+                    description: string;
+                    parameters: ({
+                        key: string;
+                        value: number;
+                    } | {
+                        key: string;
+                        value: string;
+                    })[];
+                }[];
+                permissions: {
+                    chainId: string;
+                    approvedTargets: string[];
+                    label: string[];
+                    labelNotAuthorized: string[];
+                };
+                blockId: number;
+                image: string;
+            };
+        };
         DELAY: {
             description: string;
             image: string;

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

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

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

@@ -18,7 +18,23 @@ export declare class Workflow {
     addNode(node: Node): void;
     addNodes(nodes: Node[]): void;
     deleteNode(nodeToDelete: Node): void;
-    insertNode(nodeToInsert: Node, nodeBefore: Node, nodeAfter?: Node): void;
+    /**
+     * Inserts a new node into the workflow:
+     * - If both nodeBefore and nodeAfter are provided, we expect an existing edge
+     *   from nodeBefore -> nodeAfter, which gets replaced by two edges:
+     *   nodeBefore -> nodeToInsert and nodeToInsert -> nodeAfter.
+     *
+     * - If nodeAfter is NOT provided, we create a single edge from nodeBefore
+     *   to nodeToInsert. The user can optionally provide `edgeLabel` and `edgeValue`
+     *   in that scenario only.
+     *
+     * @param nodeToInsert  The node you want to insert
+     * @param nodeBefore    The existing node in the workflow that precedes `nodeToInsert`
+     * @param nodeAfter     (Optional) The existing node that should follow `nodeToInsert`
+     * @param edgeLabel     (Optional) Label for the edge, only allowed if `nodeAfter` is not provided
+     * @param edgeValue     (Optional) Value for the edge, only allowed if `nodeAfter` is not provided
+     */
+    insertNode(nodeToInsert: Node, nodeBefore: Node, nodeAfter?: Node, edgeLabel?: string | null, edgeValue?: any | null): void;
     swapNode(oldNode: Node, newNode: Node): void;
     addEdge(edge: Edge): void;
     updateEdge(edgeId: string, newEdge: Edge): void;

package/package.json

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