otomato-sdk 2.0.71 → 2.0.72

package/dist/src/constants/Blocks.js

@@ -2727,11 +2727,12 @@ export const ACTIONS = {
                     },
                     {
                         "key": "amount",
-                        "type": "uint256",
+                        "type": "float",
                         "description": "Amount to sell",
                         "mandatory": true,
                         "category": 0,
                         "erc20FormattedAmount": {
+                            "convertItsDecimal": false,
                             "contractAddress": "{{parameters.tokenIn}}",
                             "chain": "{{parameters.chainId}}"
                         }
@@ -2986,104 +2987,6 @@ export const ACTIONS = {
             "image": "https://otomato-sdk-images.s3.eu-west-1.amazonaws.com/telegram.jpeg"
         }
     },
-    "TOKENS": {
-        "TRANSFER": {
-            "description": "Transfer token",
-            "chains": [
-                34443
-            ],
-            "image": "https://otomato-sdk-images.s3.eu-west-1.amazonaws.com/Transfer.svg",
-            "TRANSFER": {
-                "name": "Transfer token",
-                "description": "Transfers an ERC20 token",
-                "type": 1,
-                "method": "function transfer(address to, uint256 value)",
-                "output": {
-                    "transactionHash": "string"
-                },
-                "parameters": [
-                    {
-                        "key": "chainId",
-                        "type": "chainId",
-                        "description": "Chain ID of the network",
-                        "mandatory": true,
-                        "category": 0
-                    },
-                    {
-                        "key": "contractAddress",
-                        "type": "erc20",
-                        "description": "The contract address of the ERC20",
-                        "mandatory": true,
-                        "category": 0
-                    },
-                    {
-                        "key": "abiParams.to",
-                        "type": "address",
-                        "description": "Address to transfer crypto to",
-                        "mandatory": true,
-                        "category": 0
-                    },
-                    {
-                        "key": "abiParams.value",
-                        "type": "uint256",
-                        "description": "Amount of crypto to transfer",
-                        "mandatory": true,
-                        "category": 0,
-                        "erc20FormattedAmount": {
-                            "contractAddress": "{{parameters.contractAddress}}",
-                            "chain": "{{parameters.chainId}}"
-                        }
-                    },
-                ],
-                "checks": [
-                    {
-                        "type": 0,
-                        "chainId": "{{parameters.chainId}}",
-                        "contractAddress": "{{parameters.contractAddress}}",
-                        "amount": "{{parameters.abi.parameters.value}}"
-                    }
-                ],
-                "examples": [
-                    {
-                        "name": "Transfer USDC",
-                        "description": "Transfer 100 USDC to vitalik.eth on Mode",
-                        "parameters": [
-                            {
-                                "key": "chainId",
-                                "value": 34443
-                            },
-                            {
-                                "key": "abiParams.value",
-                                "value": "100000000n"
-                            },
-                            {
-                                "key": "abiParams.to",
-                                "value": "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
-                            },
-                            {
-                                "key": "contractAddress",
-                                "value": "0xd988097fb8612cc24eeC14542bC03424c656005f"
-                            }
-                        ]
-                    }
-                ],
-                "permissions": {
-                    "chainId": "{{parameters.chainId}}",
-                    "approvedTargets": [
-                        "{{parameters.contractAddress}}"
-                    ],
-                    "label": [
-                        "Transfer {{tokenSymbol({{parameters.chainId}}, {{parameters.contractAddress}})}}"
-                    ],
-                    "labelNotAuthorized": [
-                        "Transfer {{otherTokenSymbol({{parameters.chainId}}, {{parameters.contractAddress}})}}"
-                    ]
-                },
-                "blockId": 100004,
-                "image": "https://otomato-sdk-images.s3.eu-west-1.amazonaws.com/Transfer.svg"
-            }
-        }
-    },
     "LENDING": {
         "IONIC": {
             "description": "#1 money market for Yield Bearing Assets on the OP Superchain",
@@ -3115,11 +3018,12 @@ export const ACTIONS = {
                     },
                     {
                         "key": "abiParams.amount",
-                        "type": "uint256",
+                        "type": "float",
                         "description": "Amount of crypto to deposit",
                         "mandatory": true,
                         "category": 0,
                         "erc20FormattedAmount": {
+                            "convertItsDecimal": false,
                             "contractAddress": "{{parameters.tokenToDeposit}}",
                             "chain": "{{parameters.chainId}}"
                         }
@@ -3219,11 +3123,12 @@ export const ACTIONS = {
                     },
                     {
                         "key": "abiParams.amount",
-                        "type": "uint256",
+                        "type": "float",
                         "description": "Amount of crypto to withdraw",
                         "mandatory": true,
                         "category": 0,
                         "erc20FormattedAmount": {
+                            "convertItsDecimal": false,
                             "contractAddress": "{{before.contractAddress}}",
                             "chain": "{{parameters.chainId}}"
                         }
@@ -3385,11 +3290,12 @@ export const ACTIONS = {
                     },
                     {
                         "key": "abiParams.amount",
-                        "type": "uint256",
+                        "type": "float",
                         "description": "Amount of crypto to repay",
                         "mandatory": true,
                         "category": 0,
                         "erc20FormattedAmount": {
+                            "convertItsDecimal": false,
                             "contractAddress": "{{parameters.tokenToRepay}}",
                             "chain": "{{parameters.chainId}}"
                         }
@@ -3518,11 +3424,12 @@ export const ACTIONS = {
                     },
                     {
                         "key": "abiParams.amount",
-                        "type": "uint256",
+                        "type": "float",
                         "description": "The amount of the asset to supply",
                         "mandatory": true,
                         "category": 0,
                         "erc20FormattedAmount": {
+                            "convertItsDecimal": false,
                             "contractAddress": "{{parameters.abi.parameters.asset}}",
                             "chain": "{{parameters.chainId}}"
                         }
@@ -3628,11 +3535,12 @@ export const ACTIONS = {
                     },
                     {
                         "key": "abiParams.amount",
-                        "type": "uint256",
+                        "type": "float",
                         "description": "The amount of the asset to withdraw. Use type(uint).max for full balance.",
                         "mandatory": true,
                         "category": 0,
                         "erc20FormattedAmount": {
+                            "convertItsDecimal": false,
                             "contractAddress": "{{parameters.abi.parameters.asset}}",
                             "chain": "{{parameters.chainId}}"
                         },
@@ -3745,11 +3653,12 @@ export const ACTIONS = {
                     },
                     {
                         "key": "abiParams.amount",
-                        "type": "uint256",
+                        "type": "float",
                         "description": "Amount of token to deposit",
                         "mandatory": true,
                         "category": 0,
                         "erc20FormattedAmount": {
+                            "convertItsDecimal": false,
                             "contractAddress": "{{parameters.tokenToDeposit}}",
                             "chain": "{{parameters.chainId}}"
                         }
@@ -3849,11 +3758,12 @@ export const ACTIONS = {
                     },
                     {
                         "key": "abiParams.amount",
-                        "type": "uint256",
+                        "type": "float",
                         "description": "Amount of token to withdraw",
                         "mandatory": true,
                         "category": 0,
                         "erc20FormattedAmount": {
+                            "convertItsDecimal": false,
                             "contractAddress": "{{parameters.tokenToWithdraw}}",
                             "chain": "{{parameters.chainId}}"
                         }
@@ -3943,11 +3853,12 @@ export const ACTIONS = {
                     },
                     {
                         "key": "abiParams.amount",
-                        "type": "uint256",
+                        "type": "float",
                         "description": "Amount of crypto to borrow",
                         "mandatory": true,
                         "category": 0,
                         "erc20FormattedAmount": {
+                            "convertItsDecimal": false,
                             "contractAddress": "{{parameters.tokenToBorrow}}",
                             "chain": "{{parameters.chainId}}"
                         }
@@ -4015,11 +3926,12 @@ export const ACTIONS = {
                     },
                     {
                         "key": "abiParams.amount",
-                        "type": "uint256",
+                        "type": "float",
                         "description": "Amount of crypto to repay",
                         "mandatory": true,
                         "category": 0,
                         "erc20FormattedAmount": {
+                            "convertItsDecimal": false,
                             "contractAddress": "{{parameters.tokenToRepay}}",
                             "chain": "{{parameters.chainId}}"
                         }
@@ -4147,11 +4059,12 @@ export const ACTIONS = {
                     },
                     {
                         "key": "abiParams.amount",
-                        "type": "uint256",
+                        "type": "float",
                         "description": "Amount of crypto to deposit",
                         "mandatory": true,
                         "category": 0,
                         "erc20FormattedAmount": {
+                            "convertItsDecimal": false,
                             "contractAddress": "{{parameters.abi.parameters.asset}}",
                             "chain": "{{parameters.chainId}}"
                         }
@@ -4234,11 +4147,12 @@ export const ACTIONS = {
                     },
                     {
                         "key": "abiParams.amount",
-                        "type": "uint256",
+                        "type": "float",
                         "description": "Amount of crypto to withdraw",
                         "mandatory": true,
                         "category": 0,
                         "erc20FormattedAmount": {
+                            "convertItsDecimal": false,
                             "contractAddress": "{{parameters.abi.parameters.asset}}",
                             "chain": "{{parameters.chainId}}"
                         }
@@ -4337,11 +4251,12 @@ export const ACTIONS = {
                     },
                     {
                         "key": "abiParams.amount",
-                        "type": "uint256",
+                        "type": "float",
                         "description": "The amount of the asset to supply",
                         "mandatory": true,
                         "category": 0,
                         "erc20FormattedAmount": {
+                            "convertItsDecimal": false,
                             "contractAddress": "{{parameters.abi.parameters.asset}}",
                             "chain": "{{parameters.chainId}}"
                         }
@@ -4447,11 +4362,12 @@ export const ACTIONS = {
                     },
                     {
                         "key": "abiParams.amount",
-                        "type": "uint256",
+                        "type": "float",
                         "description": "The amount of the asset to withdraw. Use type(uint).max for full balance.",
                         "mandatory": true,
                         "category": 0,
                         "erc20FormattedAmount": {
+                            "convertItsDecimal": false,
                             "contractAddress": "{{parameters.abi.parameters.asset}}",
                             "chain": "{{parameters.chainId}}"
                         },
@@ -4612,11 +4528,12 @@ export const ACTIONS = {
                     },
                     {
                         "key": "amount",
-                        "type": "uint256",
+                        "type": "float",
                         "description": "Amount to sell",
                         "mandatory": true,
                         "category": 0,
                         "erc20FormattedAmount": {
+                            "convertItsDecimal": false,
                             "contractAddress": "{{parameters.tokenIn}}",
                             "chain": "{{parameters.chainId}}"
                         }

package/dist/src/constants/version.js

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

package/dist/src/utils/WorkflowNodePositioner.js

@@ -3,116 +3,192 @@ export const xSpacing = 500;
 export const ySpacing = 120;
 export const ROOT_X = 400;
 export const ROOT_Y = 120;
-export function positionWorkflowNodes(workflow) {
-    try {
-        // Step 1: Find the starting nodes using identityStartingNodes function
-        const startingNodes = identityStartingNodes(workflow);
-        // Step 2: Place the starting nodes
-        let xPosition = ROOT_X;
-        startingNodes.forEach((startNode) => {
-            startNode.setPosition(xPosition, ROOT_Y);
-            xPosition += xSpacing;
-        });
-        // Step 3: Place all other nodes relative to their parents
-        const nodesToPosition = workflow.nodes.filter((node) => !startingNodes.includes(node));
-        nodesToPosition.forEach((node) => positionNode(node, workflow.edges, xSpacing, ySpacing, workflow));
+/**
+ * Helper: Returns a group key for a node based on its primary parent.
+ * If a node has multiple parents, we sort them numerically (by their ref)
+ * and choose the lowest one.
+ */
+function getGroupKey(node, edges) {
+    const parents = getParents(node, edges);
+    if (parents.length === 0)
+        return "none";
+    parents.sort((a, b) => Number(a.getRef()) - Number(b.getRef()));
+    return parents[0].getRef();
+}
+/**
+ * Step 1: Layer Assignment via Topological Ordering.
+ */
+function assignLayers(workflow) {
+    const incomingCounts = new Map();
+    for (const node of workflow.nodes) {
+        incomingCounts.set(node.getRef(), 0);
+        node.layer = 0;
     }
-    catch (e) {
-        console.error(e);
+    for (const edge of workflow.edges) {
+        const targetRef = edge.target.getRef();
+        incomingCounts.set(targetRef, (incomingCounts.get(targetRef) || 0) + 1);
     }
-}
-export function positionNode(node, edges, xSpacing, ySpacing, workflow) {
-    const parents = getParents(node, edges);
-    // todo: what if we have multiple parents?
-    const children = getChildren(parents[0], edges);
-    const sortedChildren = children.sort((a, b) => {
-        var _a, _b;
-        const edgeA = edges.find(edge => edge.source === parents[0] && edge.target === a);
-        const edgeB = edges.find(edge => edge.source === parents[0] && edge.target === b);
-        const labelA = (_a = edgeA === null || edgeA === void 0 ? void 0 : edgeA.label) !== null && _a !== void 0 ? _a : "";
-        const labelB = (_b = edgeB === null || edgeB === void 0 ? void 0 : edgeB.label) !== null && _b !== void 0 ? _b : "";
-        if (labelA === "true" && labelB !== "true")
-            return -1;
-        if (labelB === "true" && labelA !== "true")
-            return 1;
-        if (labelA === "false" && labelB !== "false")
-            return 1;
-        if (labelB === "false" && labelA !== "false")
-            return -1;
-        return 0;
-    });
-    const childrenCountOfParent = sortedChildren.length;
-    const parentX = parents.reduce((sum, parent) => { var _a, _b; return sum + ((_b = (_a = parent.position) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : ROOT_X); }, 0) / parents.length;
-    const parentY = Math.max(...parents.map(parent => { var _a, _b; return (_b = (_a = parent.position) === null || _a === void 0 ? void 0 : _a.y) !== null && _b !== void 0 ? _b : ROOT_Y; }));
-    if (childrenCountOfParent === 1) {
-        node.setPosition(parentX, parentY + ySpacing);
+    const queue = [];
+    for (const node of workflow.nodes) {
+        if (incomingCounts.get(node.getRef()) === 0) {
+            queue.push(node);
+            node.layer = 0;
+        }
     }
-    else {
-        const index = sortedChildren.indexOf(node); // Get the position of this node among its siblings
-        const totalChildren = sortedChildren.length;
-        // Compute the x position for this node
-        const offset = index - (totalChildren - 1) / 2; // Center the children around the parent
-        node.setPosition(parentX + offset * xSpacing, parentY + ySpacing);
+    while (queue.length > 0) {
+        const current = queue.shift();
+        const currentLayer = current.layer;
+        const children = getChildren(current, workflow.edges);
+        for (const child of children) {
+            child.layer = Math.max(child.layer, currentLayer + 1);
+            const childRef = child.getRef();
+            incomingCounts.set(childRef, (incomingCounts.get(childRef) || 1) - 1);
+            if (incomingCounts.get(childRef) === 0) {
+                queue.push(child);
+            }
+        }
     }
 }
-export function positionWorkflowNodesAvoidOverlap(workflow) {
-    const levels = new Map();
-    function addToLevel(node) {
-        const level = Math.round(node.position.y / ySpacing);
-        if (!levels.has(level)) {
-            levels.set(level, []);
+/**
+ * Main function that positions workflow nodes using a hierarchical layout.
+ * Nodes are grouped by their primary parent.
+ */
+export function positionWorkflowNodes(workflow) {
+    try {
+        // Step 1: Assign layers.
+        assignLayers(workflow);
+        // Group nodes by layer.
+        const layers = new Map();
+        for (const node of workflow.nodes) {
+            const layer = node.layer;
+            if (!layers.has(layer)) {
+                layers.set(layer, []);
+            }
+            layers.get(layer).push(node);
         }
-        levels.get(level).push(node);
-    }
-    // 1) Lay out nodes using existing logic
-    positionWorkflowNodes(workflow);
-    // 2) Fill the `levels` map
-    workflow.nodes.forEach((node) => {
-        if (node.position) {
-            addToLevel(node);
+        // Process each layer in order.
+        const sortedLayers = Array.from(layers.keys()).sort((a, b) => a - b);
+        for (const layer of sortedLayers) {
+            const nodesInLayer = layers.get(layer);
+            // Group nodes by primary parent.
+            const groups = new Map();
+            for (const node of nodesInLayer) {
+                const groupKey = getGroupKey(node, workflow.edges);
+                if (!groups.has(groupKey)) {
+                    groups.set(groupKey, []);
+                }
+                groups.get(groupKey).push(node);
+            }
+            // Determine the Y position for this layer.
+            const yPos = (layer * ySpacing) + ROOT_Y;
+            const groupInfos = [];
+            // Sort group keys numerically.
+            const sortedGroupKeys = Array.from(groups.keys()).sort((a, b) => Number(a) - Number(b));
+            for (const key of sortedGroupKeys) {
+                const groupNodes = groups.get(key);
+                groupNodes.sort((a, b) => Number(a.getRef()) - Number(b.getRef()));
+                let desiredCenter;
+                if (key === "none") {
+                    desiredCenter = ROOT_X;
+                }
+                else {
+                    const parent = workflow.nodes.find(n => n.getRef() === key);
+                    desiredCenter = parent && parent.position ? parent.position.x : ROOT_X;
+                }
+                const groupSize = groupNodes.length;
+                const width = (groupSize - 1) * xSpacing;
+                const desiredLeft = desiredCenter - width / 2;
+                groupInfos.push({
+                    groupKey: key,
+                    nodes: groupNodes,
+                    desiredCenter,
+                    desiredLeft,
+                    width
+                });
+            }
+            // Adjust groups so that adjacent groups do not overlap.
+            // We require that the left edge of a group is at least xSpacing to the right of the previous group's right edge.
+            groupInfos.sort((a, b) => a.desiredLeft - b.desiredLeft);
+            let prevRight = -Infinity;
+            for (const group of groupInfos) {
+                let newLeft = group.desiredLeft;
+                if (newLeft < prevRight + xSpacing) {
+                    newLeft = prevRight + xSpacing;
+                }
+                group.newLeft = newLeft;
+                prevRight = newLeft + group.width;
+            }
+            // Now assign positions for nodes in each group using the new left.
+            for (const group of groupInfos) {
+                const { nodes, newLeft } = group;
+                for (let i = 0; i < nodes.length; i++) {
+                    const nodeX = newLeft + i * xSpacing;
+                    nodes[i].setPosition(nodeX, yPos);
+                }
+            }
         }
-    });
-    // 3) Resolve horizontal overlaps and enforce parent grouping
-    levels.forEach((nodes, level) => {
-        // Group nodes by their parent
-        const parentGroups = new Map();
-        nodes.forEach((node) => {
-            const parents = getParents(node, workflow.edges);
-            if (parents.length > 0) {
-                const parent = parents[0]; // Assuming single parent for simplicity
-                if (!parentGroups.has(parent)) {
-                    parentGroups.set(parent, []);
+        // Step 3: Resolve overlaps within each group in each layer.
+        layers.forEach((nodes, layer) => {
+            const groups = new Map();
+            for (const node of nodes) {
+                const groupKey = getGroupKey(node, workflow.edges);
+                if (!groups.has(groupKey)) {
+                    groups.set(groupKey, []);
                 }
-                parentGroups.get(parent).push(node);
+                groups.get(groupKey).push(node);
             }
+            groups.forEach((groupNodes, groupKey) => {
+                let changed = true;
+                while (changed) {
+                    changed = false;
+                    groupNodes.sort((a, b) => {
+                        const diff = a.position.x - b.position.x;
+                        if (Math.abs(diff) < 1e-6) {
+                            return Number(a.getRef()) - Number(b.getRef());
+                        }
+                        return diff;
+                    });
+                    for (let i = 1; i < groupNodes.length; i++) {
+                        const prev = groupNodes[i - 1];
+                        const current = groupNodes[i];
+                        const diff = current.position.x - prev.position.x;
+                        if (diff < xSpacing) {
+                            const shift = xSpacing - diff;
+                            moveNodeAndChildren(current, shift, workflow.edges);
+                            changed = true;
+                        }
+                    }
+                }
+            });
         });
-        // Flatten the groups back into a sorted array
-        const groupedNodes = [];
-        parentGroups.forEach((group) => {
-            groupedNodes.push(...group);
+        // Step 4: Bottom-up Parent Centering.
+        // Now, we simply set each parent's x to the exact average of its children.
+        centerParentXPositions(workflow);
+        // Final sort for consistency: sort nodes in each layer by primary parent's numeric value then node ref.
+        layers.forEach((nodes, layer) => {
+            nodes.sort((a, b) => {
+                const groupA = Number(getGroupKey(a, workflow.edges));
+                const groupB = Number(getGroupKey(b, workflow.edges));
+                if (groupA !== groupB)
+                    return groupA - groupB;
+                return Number(a.getRef()) - Number(b.getRef());
+            });
         });
-        // Sort nodes by x within each group to detect overlaps
-        groupedNodes.sort((a, b) => { var _a, _b; return ((_a = a.position.x) !== null && _a !== void 0 ? _a : 0) - ((_b = b.position.x) !== null && _b !== void 0 ? _b : 0); });
-        // Shift nodes within groups to resolve overlaps
-        for (let i = 1; i < groupedNodes.length; i++) {
-            const prev = groupedNodes[i - 1];
-            const current = groupedNodes[i];
-            if (current.position.x - prev.position.x < xSpacing) {
-                const shift = xSpacing - (current.position.x - prev.position.x);
-                moveNodeAndChildren(current, shift, workflow.edges);
-            }
-        }
-    });
-    // 4) **Center each parent over its children** (the existing step)
+    }
+    catch (e) {
+        console.error(e);
+    }
+}
+export function positionWorkflowNodesAvoidOverlap(workflow) {
+    positionWorkflowNodes(workflow);
     centerParentXPositions(workflow);
 }
 /**
- * Repositions each parent node so that its X is the average of the children’s X.
- * We do a simple bottom-up pass: start with all leaves, then move upward to parents.
+ * Modified bottom-up pass to center each parent over its children.
+ * The parent's x is now set exactly to the average of its children's x positions.
  */
 function centerParentXPositions(workflow) {
     var _a, _b;
-    // Identify the “leaf” nodes
     const queue = identifyLeafNodes(workflow);
     while (queue.length > 0) {
         const child = queue.shift();
@@ -120,43 +196,32 @@ function centerParentXPositions(workflow) {
         for (const parent of parents) {
             const children = getChildren(parent, workflow.edges);
             if (children.length) {
-                // Average x of all children
-                const sumX = children.reduce((acc, c) => { var _a, _b; return acc + ((_b = (_a = c.position) === null || _a === void 0 ? void 0 : _a.x) !== null && _b !== void 0 ? _b : 0); }, 0);
-                const avgX = sumX / children.length;
-                // Move parent to that average, keep same y
+                const xs = children.map(c => c.position.x);
+                const avgX = xs.reduce((acc, x) => acc + x, 0) / xs.length;
                 parent.setPosition(avgX, (_b = (_a = parent.position) === null || _a === void 0 ? void 0 : _a.y) !== null && _b !== void 0 ? _b : 0);
             }
-            // Add this parent to the queue so we can recurse upward
             if (!queue.includes(parent)) {
                 queue.push(parent);
             }
         }
     }
 }
+/**
+ * Recursively shifts a node and all its descendants by the given amount.
+ */
 function moveNodeAndChildren(node, shift, edges) {
-    // Move the node
-    node.setPosition(node.position.x + shift, node.position.y);
-    // Propagate to children
-    edges
-        .filter((edge) => edge.source === node)
-        .forEach((edge) => {
-        moveNodeAndChildren(edge.target, shift, edges);
-    });
+    const oldX = node.position.x;
+    node.setPosition(oldX + shift, node.position.y);
+    edges.filter(edge => edge.source === node)
+        .forEach(edge => moveNodeAndChildren(edge.target, shift, edges));
 }
 export function identifyLeafNodes(workflow) {
     const nonLeafNodes = new Set(workflow.edges.map(edge => edge.source.getRef()));
     return workflow.nodes.filter(node => !nonLeafNodes.has(node.getRef()));
 }
-/**
- * Identifies starting nodes (nodes with no incoming edges).
- * A starting node is defined as one that is not a target of any edge.
- *
- * @param workflow The workflow to analyze.
- * @returns An array of nodes that have no incoming edges.
- */
 export function identityStartingNodes(workflow) {
-    const childRefs = new Set(workflow.edges.map((edge) => edge.target.getRef()));
-    return workflow.nodes.filter((node) => !childRefs.has(node.getRef()));
+    const childRefs = new Set(workflow.edges.map(edge => edge.target.getRef()));
+    return workflow.nodes.filter(node => !childRefs.has(node.getRef()));
 }
 export function getChildren(node, edges) {
     return edges.filter(edge => edge.source === node).map(edge => edge.target);
@@ -169,7 +234,7 @@ export function getEdges(node, edges) {
 }
 export function getEndNodePositions(workflow) {
     return workflow.nodes
-        .filter(node => getChildren(node, workflow.edges).length === 0) // node with no children
+        .filter(node => getChildren(node, workflow.edges).length === 0)
         .map(node => {
         var _a, _b, _c, _d;
         return ({

package/dist/types/examples/test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Example workflow:
+ *   Trigger -> Delay -> Condition
+ *      ├─(true)─> Split(3)
+ *      └─(false)-> Delay
+ */
+export declare function conditionSplitDemo(): Promise<void>;

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

@@ -1336,48 +1336,6 @@ export declare const ACTIONS: {
             image: string;
         };
     };
-    TOKENS: {
-        TRANSFER: {
-            description: string;
-            chains: number[];
-            image: string;
-            TRANSFER: {
-                name: string;
-                description: string;
-                type: number;
-                method: string;
-                output: {
-                    transactionHash: string;
-                };
-                parameters: Parameter[];
-                checks: {
-                    type: number;
-                    chainId: string;
-                    contractAddress: string;
-                    amount: string;
-                }[];
-                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;
-            };
-        };
-    };
     LENDING: {
         IONIC: {
             description: string;

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

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

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

@@ -5,17 +5,13 @@ export declare const xSpacing = 500;
 export declare const ySpacing = 120;
 export declare const ROOT_X = 400;
 export declare const ROOT_Y = 120;
+/**
+ * Main function that positions workflow nodes using a hierarchical layout.
+ * Nodes are grouped by their primary parent.
+ */
 export declare function positionWorkflowNodes(workflow: Workflow): void;
-export declare function positionNode(node: Node, edges: Edge[], xSpacing: number, ySpacing: number, workflow: Workflow): void;
 export declare function positionWorkflowNodesAvoidOverlap(workflow: Workflow): void;
 export declare function identifyLeafNodes(workflow: Workflow): Node[];
-/**
- * Identifies starting nodes (nodes with no incoming edges).
- * A starting node is defined as one that is not a target of any edge.
- *
- * @param workflow The workflow to analyze.
- * @returns An array of nodes that have no incoming edges.
- */
 export declare function identityStartingNodes(workflow: Workflow): Node[];
 export declare function getChildren(node: Node, edges: Edge[]): Node[];
 export declare function getParents(node: Node, edges: Edge[]): Node[];

package/package.json

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