otomato-sdk 2.0.200 → 2.0.201

package/dist/src/constants/WorkflowTemplates.js

@@ -1,4 +1,4 @@
-import { Workflow, Trigger, Action, Edge, TRIGGERS, ACTIONS, CHAINS, getTokenFromSymbol, convertToTokenUnitsFromSymbol, convertToTokenUnits } from '../index.js';
+import { Workflow, Trigger, Action, Edge, TRIGGERS, ACTIONS, CHAINS, getTokenFromSymbol, convertToTokenUnitsFromSymbol, convertToTokenUnits, WORKFLOW_LOOPING_TYPES } from '../index.js';
 export const WORKFLOW_TEMPLATES_TAGS = {
     NFTS: 'NFTs',
     SOCIALS: 'Socials',
@@ -6,7 +6,9 @@ export const WORKFLOW_TEMPLATES_TAGS = {
     ON_CHAIN_MONITORING: 'On-chain monitoring',
     YIELD: 'Yield',
     NOTIFICATIONS: 'notifications',
-    ABSTRACT: 'Abstract'
+    ABSTRACT: 'Abstract',
+    DEXES: 'Dexes',
+    LENDING: 'Lending'
 };
 const createModeTransferNotificationWorkflow = () => {
     const modeTransferTrigger = new Trigger(TRIGGERS.TOKENS.TRANSFER.TRANSFER);
@@ -192,9 +194,123 @@ const abstractGetNotifiedWhenStreamerIsLive = async () => {
     const edge = new Edge({ source: trigger, target: telegramAction });
     return new Workflow('Get notified when a given streamer goes live', [trigger, telegramAction], [edge]);
 };
+// notify me when I can unstake my stakestone
+const createStakestoneUnstakeNotificationWorkflow = async () => {
+    const trigger = new Trigger(TRIGGERS.YIELD.STAKESTONE.LATEST_ROUND_ID);
+    trigger.setParams('chainId', CHAINS.ETHEREUM);
+    trigger.setParams('contractAddress', "0x8f88ae3798e8ff3d0e0de7465a0863c9bbb577f0");
+    trigger.setCondition('neq');
+    trigger.setComparisonValue('{{history.0.value}}');
+    trigger.setPosition(400, 120);
+    const notificationAction = new Action(ACTIONS.NOTIFICATIONS.TELEGRAM.SEND_MESSAGE);
+    notificationAction.setParams("message", "You can now unstake your Stakestone position!");
+    notificationAction.setPosition(400, 240);
+    const edge = new Edge({ source: trigger, target: notificationAction });
+    return new Workflow('Get notified when you can unstake your Stakestone position', [trigger, notificationAction], [edge]);
+};
+// notify me when a given uniswap position is out of range [looping enabled - 5 times]
+const createUniswapPositionOutOfRangeNotificationWorkflow = async () => {
+    const trigger = new Trigger(TRIGGERS.DEXES.UNISWAP.IS_IN_RANGE);
+    trigger.setParams('chainId', CHAINS.ETHEREUM);
+    trigger.setCondition('eq');
+    trigger.setParams('comparisonValue', false);
+    trigger.setPosition(400, 120);
+    const notificationAction = new Action(ACTIONS.NOTIFICATIONS.TELEGRAM.SEND_MESSAGE);
+    notificationAction.setParams("message", "Your Uniswap position is out of range! You can obtain your position Id at https://app.uniswap.org/positions");
+    notificationAction.setPosition(400, 240);
+    const edge = new Edge({ source: trigger, target: notificationAction });
+    const workflow = new Workflow('Get notified when a given uniswap position is out of range', [trigger, notificationAction], [edge]);
+    workflow.setSettings({
+        loopingType: WORKFLOW_LOOPING_TYPES.POLLING,
+        period: 600000,
+        limit: 5,
+    });
+    return workflow;
+};
+// notify me when Hyperlend raise their deposit cap for stHype [looping enabled - 10 times]
+const createHyperLendDepositCapNotificationWorkflow = async () => {
+    const trigger = new Trigger(TRIGGERS.LENDING.HYPERLEND.SUPPLY_CAP);
+    trigger.setParams('chainId', CHAINS.HYPER_EVM);
+    trigger.setParams('asset', getTokenFromSymbol(CHAINS.HYPER_EVM, 'wstHYPE').contractAddress);
+    trigger.setCondition('gt');
+    trigger.setComparisonValue('{{history.0.value}}');
+    trigger.setPosition(400, 120);
+    const notificationAction = new Action(ACTIONS.NOTIFICATIONS.TELEGRAM.SEND_MESSAGE);
+    notificationAction.setParams("message", "Hyperlend has raised their deposit cap for stHype!");
+    notificationAction.setPosition(400, 240);
+    const edge = new Edge({ source: trigger, target: notificationAction });
+    const workflow = new Workflow('Get notified when Hyperlend raise their deposit cap for stHype', [trigger, notificationAction], [edge]);
+    workflow.setSettings({
+        loopingType: WORKFLOW_LOOPING_TYPES.POLLING,
+        period: 600000,
+        limit: 10,
+    });
+    return workflow;
+};
+// Save all the current yields for USDC on base (AAVE, Compound, Moonwell & top 5 USDC morpho vault) every hour [repeat 100 times, every hour]
+const createUSDCYieldsStorageWorkflow = async () => {
+    const trigger = new Trigger(TRIGGERS.CORE.EVERY_PERIOD.EVERY_PERIOD);
+    trigger.setParams('period', 3600000);
+    trigger.setParams('limit', 100);
+    trigger.setPosition(400, 120);
+    const notificationAction = new Action(ACTIONS.OTHERS.GSHEET.GSHEET);
+    notificationAction.setParams("data", [
+        ["aave", "moonwell", "compound", "Spark USDC Vault", "Moonwell Flagship USDC", "Seamless USDC Vault", "Steakhouse USDC", "Gauntlet USDC Prime"],
+        [
+            "{{external.functions.aaveLendingRate(8453,0x833589fcd6edb6e08f4c7c32d4f71b54bda02913,,)}}",
+            "{{external.functions.moonwellLendingRate(8453,0x833589fcd6edb6e08f4c7c32d4f71b54bda02913,,)}}",
+            "{{external.functions.compoundLendingRate(8453,0x833589fcd6edb6e08f4c7c32d4f71b54bda02913,,,)}}",
+            "{{external.functions.morphoLendingRate(8453,0x7BfA7C4f149E7415b73bdeDfe609237e29CBF34A)}}",
+            "{{external.functions.morphoLendingRate(8453,0xc1256Ae5FF1cf2719D4937adb3bbCCab2E00A2Ca)}}",
+            "{{external.functions.morphoLendingRate(8453,0x616a4E1db48e22028f6bbf20444Cd3b8e3273738)}}",
+            "{{external.functions.morphoLendingRate(8453,0xbeeF010f9cb27031ad51e3333f9aF9C6B1228183)}}",
+            "{{external.functions.morphoLendingRate(8453,0xeE8F4eC5672F09119b96Ab6fB59C27E1b7e44b61)}}"
+        ]
+    ]);
+    // notificationAction.setParams("mode", "append");
+    // notificationAction.setParams("role", "writer");
+    // notificationAction.setParams("sheetId", "0");
+    // notificationAction.setParams("spreadsheetId", "1NxqGqgtUQkojBOl9g7CBkbqc7bB6mBkZxHWMPsu1uQY");
+    notificationAction.setPosition(400, 240);
+    const edge = new Edge({ source: trigger, target: notificationAction });
+    return new Workflow('Save all the current yields for USDC on base (AAVE, Compound, Moonwell, Spark USDC Vault, Moonwell Flagship USDC, Seamless USDC Vault, Steakhouse USDC, Gauntlet USDC Prime) every hour', [trigger, notificationAction], [edge]);
+};
+// notify me when there are more than 50 ETH in available liquidity for instant withdrawal on Stakestone
+const createStakestoneInstantWithdrawalNotificationWorkflow = async () => {
+    const trigger = new Trigger(TRIGGERS.YIELD.STAKESTONE.STAKESTONE_VAULT_LIQUIDITY);
+    trigger.setParams('chainId', CHAINS.ETHEREUM);
+    trigger.setCondition('gt');
+    trigger.setComparisonValue('50');
+    trigger.setPosition(400, 120);
+    const notificationAction = new Action(ACTIONS.NOTIFICATIONS.TELEGRAM.SEND_MESSAGE);
+    notificationAction.setParams("message", "There are more than 50 ETH in available liquidity for instant withdrawal on Stakestone!");
+    notificationAction.setPosition(400, 240);
+    const edge = new Edge({ source: trigger, target: notificationAction });
+    return new Workflow('Get notified when there are more than 50 ETH in available liquidity for instant withdrawal on Stakestone', [trigger, notificationAction], [edge]);
+};
+// notify me when I receive USDC [looping enabled - 30 times]
+const createUSDCReceiveNotificationWorkflow = async () => {
+    const trigger = new Trigger(TRIGGERS.TOKENS.TRANSFER.TRANSFER);
+    trigger.setParams('chainId', CHAINS.BASE);
+    trigger.setParams('contractAddress', getTokenFromSymbol(CHAINS.BASE, 'USDC').contractAddress);
+    // TODO: add smart account address
+    trigger.setParams('abiParams.to', '{{smartAccountAddress}}');
+    trigger.setPosition(400, 120);
+    const notificationAction = new Action(ACTIONS.NOTIFICATIONS.TELEGRAM.SEND_MESSAGE);
+    notificationAction.setParams("message", "You received USDC!");
+    notificationAction.setPosition(400, 240);
+    const edge = new Edge({ source: trigger, target: notificationAction });
+    const workflow = new Workflow('Get notified when I receive USDC', [trigger, notificationAction], [edge]);
+    workflow.setSettings({
+        loopingType: WORKFLOW_LOOPING_TYPES.SUBSCRIPTION,
+        timeout: 31536000000,
+        limit: 30,
+    });
+    return workflow;
+};
 const createEthereumFoundationTransferNotificationWorkflow = () => {
     const ethTransferTrigger = new Trigger(TRIGGERS.TOKENS.TRANSFER.NATIVE_TRANSFER);
-    ethTransferTrigger.setChainId(CHAINS.BASE);
+    ethTransferTrigger.setChainId(CHAINS.ETHEREUM);
     ethTransferTrigger.setParams('wallet', '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe');
     ethTransferTrigger.setParams('threshold', 0.004);
     ethTransferTrigger.setPosition(400, 120);
@@ -407,4 +523,94 @@ export const WORKFLOW_TEMPLATES = [
         ],
         createWorkflow: copyTradeVitalikOdos
     },*/
+    {
+        'name': 'Get notified when you can unstake your Stakestone position',
+        'description': 'Notify me when you can unstake your Stakestone position',
+        'tags': [WORKFLOW_TEMPLATES_TAGS.YIELD, WORKFLOW_TEMPLATES_TAGS.NOTIFICATIONS],
+        'thumbnail': 'https://otomato-sdk-images.s3.eu-west-1.amazonaws.com/templates/dailyYieldUpdates.jpg',
+        'image': [
+            TRIGGERS.YIELD.STAKESTONE.STAKESTONE_VAULT_LIQUIDITY.image,
+            ACTIONS.NOTIFICATIONS.TELEGRAM.SEND_MESSAGE.image
+        ],
+        'blockIDs': [
+            TRIGGERS.YIELD.STAKESTONE.STAKESTONE_VAULT_LIQUIDITY.blockId,
+            ACTIONS.NOTIFICATIONS.TELEGRAM.SEND_MESSAGE.blockId
+        ],
+        createWorkflow: createStakestoneUnstakeNotificationWorkflow
+    },
+    {
+        'name': 'Get notified when a given uniswap position is out of range',
+        'description': 'Notify me when a given uniswap position is out of range. Get your tokenId from https://app.uniswap.org/positions',
+        'tags': [WORKFLOW_TEMPLATES_TAGS.DEXES, WORKFLOW_TEMPLATES_TAGS.NOTIFICATIONS],
+        'thumbnail': 'https://otomato-sdk-images.s3.eu-west-1.amazonaws.com/templates/dailyYieldUpdates.jpg',
+        'image': [
+            TRIGGERS.DEXES.UNISWAP.IS_IN_RANGE.image,
+            ACTIONS.NOTIFICATIONS.TELEGRAM.SEND_MESSAGE.image
+        ],
+        'blockIDs': [
+            TRIGGERS.DEXES.UNISWAP.IS_IN_RANGE.blockId,
+            ACTIONS.NOTIFICATIONS.TELEGRAM.SEND_MESSAGE.blockId
+        ],
+        createWorkflow: createUniswapPositionOutOfRangeNotificationWorkflow
+    },
+    {
+        'name': 'Get notified when Hyperlend raise their deposit cap for stHype',
+        'description': 'Notify me when Hyperlend raise their deposit cap for stHype',
+        'tags': [WORKFLOW_TEMPLATES_TAGS.LENDING, WORKFLOW_TEMPLATES_TAGS.NOTIFICATIONS],
+        'thumbnail': 'https://otomato-sdk-images.s3.eu-west-1.amazonaws.com/templates/dailyYieldUpdates.jpg',
+        'image': [
+            TRIGGERS.LENDING.HYPERLEND.SUPPLY_CAP.image,
+            ACTIONS.NOTIFICATIONS.TELEGRAM.SEND_MESSAGE.image
+        ],
+        'blockIDs': [
+            TRIGGERS.LENDING.HYPERLEND.SUPPLY_CAP.blockId,
+            ACTIONS.NOTIFICATIONS.TELEGRAM.SEND_MESSAGE.blockId
+        ],
+        createWorkflow: createHyperLendDepositCapNotificationWorkflow
+    },
+    {
+        'name': 'Get notified when there are more than 50 ETH in available liquidity for instant withdrawal on Stakestone',
+        'description': 'Notify me when there are more than 50 ETH in available liquidity for instant withdrawal on Stakestone',
+        'tags': [WORKFLOW_TEMPLATES_TAGS.YIELD, WORKFLOW_TEMPLATES_TAGS.NOTIFICATIONS],
+        'thumbnail': 'https://otomato-sdk-images.s3.eu-west-1.amazonaws.com/templates/dailyYieldUpdates.jpg',
+        'image': [
+            TRIGGERS.YIELD.STAKESTONE.STAKESTONE_VAULT_LIQUIDITY.image,
+            ACTIONS.NOTIFICATIONS.TELEGRAM.SEND_MESSAGE.image
+        ],
+        'blockIDs': [
+            TRIGGERS.YIELD.STAKESTONE.STAKESTONE_VAULT_LIQUIDITY.blockId,
+            ACTIONS.NOTIFICATIONS.TELEGRAM.SEND_MESSAGE.blockId
+        ],
+        createWorkflow: createStakestoneInstantWithdrawalNotificationWorkflow
+    },
+    {
+        'name': 'Get notified when I receive USDC',
+        'description': 'Notify me when I receive USDC',
+        'tags': [WORKFLOW_TEMPLATES_TAGS.TRADING, WORKFLOW_TEMPLATES_TAGS.NOTIFICATIONS],
+        'thumbnail': 'https://otomato-sdk-images.s3.eu-west-1.amazonaws.com/templates/dailyYieldUpdates.jpg',
+        'image': [
+            TRIGGERS.TOKENS.TRANSFER.TRANSFER.image,
+            ACTIONS.NOTIFICATIONS.TELEGRAM.SEND_MESSAGE.image
+        ],
+        'blockIDs': [
+            TRIGGERS.TOKENS.TRANSFER.TRANSFER.blockId,
+            ACTIONS.NOTIFICATIONS.TELEGRAM.SEND_MESSAGE.blockId
+        ],
+        createWorkflow: createUSDCReceiveNotificationWorkflow
+    },
+    {
+        'name': 'Save all the current yields for USDC on base (AAVE, Compound, Moonwell, Spark USDC Vault, Moonwell Flagship USDC, Seamless USDC Vault, Steakhouse USDC, Gauntlet USDC Prime) every hour',
+        'description': 'Save all the current yields for USDC on base (AAVE, Compound, Moonwell, Spark USDC Vault, Moonwell Flagship USDC, Seamless USDC Vault, Steakhouse USDC, Gauntlet USDC Prime) every hour',
+        'tags': [WORKFLOW_TEMPLATES_TAGS.YIELD, WORKFLOW_TEMPLATES_TAGS.NOTIFICATIONS],
+        'thumbnail': 'https://otomato-sdk-images.s3.eu-west-1.amazonaws.com/templates/dailyYieldUpdates.jpg',
+        'image': [
+            TRIGGERS.CORE.EVERY_PERIOD.EVERY_PERIOD.image,
+            ACTIONS.OTHERS.GSHEET.GSHEET.image
+        ],
+        'blockIDs': [
+            TRIGGERS.CORE.EVERY_PERIOD.EVERY_PERIOD.blockId,
+            ACTIONS.OTHERS.GSHEET.GSHEET.blockId
+        ],
+        createWorkflow: createUSDCYieldsStorageWorkflow
+    },
 ];

package/dist/src/constants/version.js

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

package/dist/src/utils/WorkflowNodePositioner.js

@@ -3,6 +3,7 @@ export const xSpacing = 500;
 export const ySpacing = 120;
 export const ROOT_X = 400;
 export const ROOT_Y = 120;
+export const TRIGGER_X_SPACING = 363;
 /**
  * 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)
@@ -70,64 +71,123 @@ export function positionWorkflowNodes(workflow) {
         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;
+            // Special handling for layer 0 (triggers)
+            if (layer === 0) {
+                const startingNodes = nodesInLayer.filter(node => getParents(node, workflow.edges).length === 0);
+                startingNodes.sort((a, b) => Number(a.getRef()) - Number(b.getRef())); // Consistent ordering
+                const numStartingNodes = startingNodes.length;
+                let totalWidth = 0; // Initialize totalWidth
+                if (numStartingNodes > 0) {
+                    totalWidth = (numStartingNodes - 1) * TRIGGER_X_SPACING; // Assign value to totalWidth
+                    let currentX = ROOT_X - totalWidth / 2;
+                    for (let i = 0; i < numStartingNodes; i++) {
+                        startingNodes[i].setPosition(currentX, yPos);
+                        currentX += TRIGGER_X_SPACING;
+                    }
                 }
-                else {
-                    const parent = workflow.nodes.find(n => n.getRef() === key);
-                    desiredCenter = parent && parent.position ? parent.position.x : ROOT_X;
+                // Handle non-starting nodes in layer 0 if any (should be rare for triggers)
+                const otherNodesInLayer0 = nodesInLayer.filter(node => getParents(node, workflow.edges).length > 0);
+                if (otherNodesInLayer0.length > 0) {
+                    // Fallback to default group positioning for these nodes
+                    // This part reuses the existing grouping logic but only for these specific nodes.
+                    const groups = new Map();
+                    for (const node of otherNodesInLayer0) {
+                        const groupKey = getGroupKey(node, workflow.edges);
+                        if (!groups.has(groupKey)) {
+                            groups.set(groupKey, []);
+                        }
+                        groups.get(groupKey).push(node);
+                    }
+                    // Simplified group processing for these non-starting nodes in layer 0
+                    // Calculate currentXOffset based on whether startingNodes were present or not
+                    const startingNodesOffset = numStartingNodes > 0 ? totalWidth / 2 + TRIGGER_X_SPACING : 0;
+                    let currentXOffset = ROOT_X + startingNodesOffset;
+                    // If there were no starting nodes, and we only have otherNodesInLayer0,
+                    // they should probably start near ROOT_X, not offset by totalWidth/2.
+                    // If startingNodes were there, offset by totalWidth/2 + some spacing.
+                    // If numStartingNodes is 0, totalWidth is 0, so currentXOffset starts at ROOT_X.
+                    // If numStartingNodes > 0, currentXOffset starts at ROOT_X + totalWidth/2 + TRIGGER_X_SPACING
+                    // (using TRIGGER_X_SPACING as a gap, or xSpacing could be used too)
+                    if (numStartingNodes > 0) {
+                        currentXOffset = ROOT_X + totalWidth / 2 + xSpacing; // Place them after triggers with xSpacing
+                    }
+                    else {
+                        currentXOffset = ROOT_X; // If no triggers, start these at ROOT_X
+                    }
+                    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()));
+                        for (let i = 0; i < groupNodes.length; i++) {
+                            groupNodes[i].setPosition(currentXOffset + i * xSpacing, yPos);
+                        }
+                        currentXOffset += groupNodes.length * xSpacing + xSpacing; // Add spacing between groups
+                    }
                 }
-                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;
+            else {
+                // Original logic for layers other than 0
+                // 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);
                 }
-                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);
+                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") { // Should not happen for layer > 0 if graph is connected
+                        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);
+                    }
                 }
             }
         }
         // Step 3: Resolve overlaps within each group in each layer.
+        // This step might need adjustment if TRIGGER_X_SPACING causes issues with xSpacing based overlap.
+        // For now, we assume xSpacing is the minimum desired gap after initial placement.
         layers.forEach((nodes, layer) => {
             const groups = new Map();
             for (const node of nodes) {
@@ -152,8 +212,19 @@ export function positionWorkflowNodes(workflow) {
                         const prev = groupNodes[i - 1];
                         const current = groupNodes[i];
                         const diff = current.position.x - prev.position.x;
-                        if (diff < xSpacing) {
-                            const shift = xSpacing - diff;
+                        // Determine the target spacing for overlap resolution
+                        let targetSpacing = xSpacing;
+                        if (layer === 0) {
+                            // More direct check: if all nodes currently being processed together in this group are starting nodes.
+                            const allNodesInGroupAreStartingNodes = groupNodes.every(gn => getParents(gn, workflow.edges).length === 0);
+                            if (allNodesInGroupAreStartingNodes) {
+                                // This condition implies that the group being processed should indeed be the "none" group,
+                                // consisting only of starting nodes.
+                                targetSpacing = TRIGGER_X_SPACING;
+                            }
+                        }
+                        if (diff < targetSpacing) {
+                            const shift = targetSpacing - diff;
                             moveNodeAndChildren(current, shift, workflow.edges);
                             changed = true;
                         }
@@ -161,6 +232,32 @@ export function positionWorkflowNodes(workflow) {
                 }
             });
         });
+        // Additional step: Ensure common children of multiple layer 0 triggers are centered at ROOT_X.
+        // This runs after initial layer placement and before final overlap resolution specific to children groups might occur,
+        // and crucially before parent centering which might pull triggers away.
+        for (const node of workflow.nodes) {
+            const nodeLayer = node.layer;
+            if (nodeLayer === 1) { // Check nodes in the layer immediately following triggers
+                const parents = getParents(node, workflow.edges);
+                if (parents.length > 1) { // Only if it has multiple parents
+                    const allParentsAreLayer0Triggers = parents.every(p => {
+                        const parentLayer = p.layer;
+                        const parentIsStartingNode = getParents(p, workflow.edges).length === 0;
+                        return parentLayer === 0 && parentIsStartingNode;
+                    });
+                    if (allParentsAreLayer0Triggers) {
+                        if (node.position) { // Ensure node.position exists before trying to read node.position.y
+                            node.setPosition(ROOT_X, node.position.y);
+                        }
+                        else {
+                            // This case should ideally not happen if nodes in layer 1 are already positioned by the main loop.
+                            // If it does, assign a default Y based on its layer.
+                            node.setPosition(ROOT_X, (nodeLayer * ySpacing) + ROOT_Y);
+                        }
+                    }
+                }
+            }
+        }
         // Step 4: Bottom-up Parent Centering.
         // Now, we simply set each parent's x to the exact average of its children.
         centerParentXPositions(workflow);
@@ -193,6 +290,19 @@ function centerParentXPositions(workflow) {
         const child = queue.shift();
         const parents = getParents(child, workflow.edges);
         for (const parent of parents) {
+            // Check if the parent is a layer 0 starting node.
+            // Layer information should be available on the node from the assignLayers step.
+            const parentLayer = parent.layer;
+            const parentIsStartingNode = getParents(parent, workflow.edges).length === 0;
+            if (parentLayer === 0 && parentIsStartingNode) {
+                // Do not change the X position of layer 0 starting nodes.
+                // Still add to queue if not already present, for processing its own parents if it had any (though starting nodes don't).
+                // More importantly, it ensures the loop continues correctly for other parents of the current 'child'.
+                if (!queue.includes(parent)) {
+                    queue.push(parent);
+                }
+                continue; // Skip X-position adjustment for this parent
+            }
             const children = getChildren(parent, workflow.edges);
             if (children.length) {
                 const xs = children.map(c => c.position.x);

package/dist/src/utils/helpers.js

@@ -121,4 +121,3 @@ export function formatNonZeroDecimals(value, nonZeroDecimals = 2) {
     }
     return sign + result;
 }
-console.log(formatNonZeroDecimals(0.0000000000000001)); // 0.0000000000000001

package/dist/types/examples/Core/create-workflow-with-multiple-triggers.d.ts

@@ -0,0 +1,2 @@
+import { Workflow } from '../../src/index.js';
+export declare function abstract_streamer_live_multiple_triggers(): Promise<Workflow>;

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

@@ -7,6 +7,8 @@ export declare const WORKFLOW_TEMPLATES_TAGS: {
     YIELD: string;
     NOTIFICATIONS: string;
     ABSTRACT: string;
+    DEXES: string;
+    LENDING: string;
 };
 export declare const WORKFLOW_TEMPLATES: ({
     name: string;

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

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

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

@@ -5,6 +5,7 @@ export declare const xSpacing = 500;
 export declare const ySpacing = 120;
 export declare const ROOT_X = 400;
 export declare const ROOT_Y = 120;
+export declare const TRIGGER_X_SPACING = 363;
 /**
  * Main function that positions workflow nodes using a hierarchical layout.
  * Nodes are grouped by their primary parent.

package/package.json

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