otomato-sdk 1.3.3 → 1.3.5

package/README.md

@@ -22,13 +22,13 @@ npm install otomato-sdk
 Here's how to create a trigger using the Otomato SDK:
 
 ```typescript
-import { Trigger, TRIGGERS, CHAINS, getToken } from 'otomato-sdk';
+import { Trigger, TRIGGERS, CHAINS, getTokenFromSymbol } from 'otomato-sdk';
 
 const transferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
 transferTrigger.setChainId(CHAINS.ETHEREUM);
 transferTrigger.setParams("value", 1000);
 transferTrigger.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
-transferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+transferTrigger.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
 
 console.log(transferTrigger.toJSON());
 ```

package/dist/examples/create-action.js

@@ -1,21 +1,21 @@
-import { ACTIONS, getToken, CHAINS, Action } from '../src/index.js';
+import { ACTIONS, getTokenFromSymbol, CHAINS, Action } from '../src/index.js';
 const createAction = () => {
     // Create an ERC20 transfer action
     const transferAction = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
     transferAction.setChainId(CHAINS.ETHEREUM);
     transferAction.setParams("value", 1000);
     transferAction.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
-    transferAction.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
-    console.log(transferAction.toJSON());
+    transferAction.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    console.log(JSON.stringify(transferAction.toJSON()));
     // Create an SMS notification action
     const smsAction = new Action(ACTIONS.NOTIFICATIONS.DISCORD.SEND_MESSAGE);
-    smsAction.setParams("phoneNumber", "+1234567890");
-    smsAction.setParams("text", "This is a test message");
+    smsAction.setParams("webhook", "https://url");
+    smsAction.setParams("message", "This is a test message");
     console.log(smsAction.toJSON());
     // Create a Slack notification action
     const slackAction = new Action(ACTIONS.NOTIFICATIONS.SLACK.SEND_MESSAGE);
     slackAction.setParams("webhook", "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX");
-    slackAction.setParams("text", "This is a test message");
+    slackAction.setParams("message", "This is a test message");
     console.log(slackAction.toJSON());
 };
 createAction();

package/dist/examples/create-trigger-list.js

@@ -1,4 +1,4 @@
-import { TRIGGERS, getToken, TOKENS, CHAINS, Trigger } from '../src/index.js';
+import { TRIGGERS, getTokenFromSymbol, TOKENS, CHAINS, Trigger } from '../src/index.js';
 const generateDefaultTriggers = () => {
     const triggersList = [];
     const createDefaultTrigger = (trigger) => {
@@ -8,7 +8,7 @@ const generateDefaultTriggers = () => {
             triggerInstance.setChainId(CHAINS.ETHEREUM);
         }
         if (trigger.parameters.some((p) => p.key === "contractAddress")) {
-            triggerInstance.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+            triggerInstance.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
         }
         if (trigger.parameters.some((p) => p.key === "condition")) {
             triggerInstance.setCondition('>');
@@ -16,9 +16,6 @@ const generateDefaultTriggers = () => {
         if (trigger.parameters.some((p) => p.key === "comparisonValue")) {
             triggerInstance.setComparisonValue(1000);
         }
-        if (trigger.parameters.some((p) => p.key === "interval")) {
-            triggerInstance.setInterval(60000); // 1 minute interval
-        }
         if (trigger.parameters.some((p) => p.key === "abiParams.account")) {
             triggerInstance.setParams('account', '0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6');
         }
@@ -56,7 +53,6 @@ function generateTriggersForAllTokens(chain) {
         balanceTrigger.setContractAddress(token.contractAddress);
         balanceTrigger.setCondition(">");
         balanceTrigger.setComparisonValue(10);
-        balanceTrigger.setInterval(5000);
         triggersList.push(balanceTrigger);
     });
     return triggersList.map(t => t.toJSON());
@@ -67,14 +63,13 @@ const generateSpecificTriggers = () => {
     transferTrigger.setChainId(CHAINS.ETHEREUM);
     transferTrigger.setParams("value", 1000);
     transferTrigger.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
-    transferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    transferTrigger.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
     const balanceTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.BALANCE);
     balanceTrigger.setChainId(CHAINS.ETHEREUM);
     balanceTrigger.setParams("account", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
-    balanceTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    balanceTrigger.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
     balanceTrigger.setCondition(">");
     balanceTrigger.setComparisonValue(45000);
-    balanceTrigger.setInterval(5000);
     const spliceFiSwapTrigger = new Trigger(TRIGGERS.YIELD.SPLICE_FI.SWAP);
     spliceFiSwapTrigger.setParams("caller", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
     spliceFiSwapTrigger.setParams("market", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
@@ -133,4 +128,4 @@ const triggersList = [
     ...generateDefaultTriggers(),
     ...generateSpecificTriggers()
 ];
-console.log(JSON.stringify(triggersList));
+console.log(triggersList);

package/dist/examples/create-trigger.js

@@ -1,7 +1,21 @@
-import { TRIGGERS, getToken, CHAINS, Trigger } from '../src/index.js';
-const transferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
-transferTrigger.setChainId(CHAINS.ETHEREUM);
-// transferTrigger.setParams("value", 1000);
-transferTrigger.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
-transferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
-console.log(JSON.stringify(transferTrigger.toJSON(), null, 2));
+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 { TRIGGERS, CHAINS, Trigger, getTokenFromSymbol, convertToTokenUnits } from '../src/index.js';
+const main = () => __awaiter(void 0, void 0, void 0, function* () {
+    const transferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+    const contractAddr = getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress;
+    console.log(contractAddr);
+    transferTrigger.setChainId(CHAINS.ETHEREUM);
+    transferTrigger.setParams("value", yield convertToTokenUnits(1, CHAINS.ETHEREUM, contractAddr));
+    transferTrigger.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    transferTrigger.setContractAddress(contractAddr);
+    console.log(JSON.stringify(transferTrigger.toJSON()));
+});
+main();

package/dist/examples/create-workflow.js

@@ -7,36 +7,46 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-import { ACTIONS, Action, TRIGGERS, Trigger, Workflow, CHAINS, getToken, Edge, apiServices } from '../src/index.js';
+import { ACTIONS, Action, TRIGGERS, Trigger, Workflow, CHAINS, getTokenFromSymbol, Edge, apiServices } from '../src/index.js';
 const main = () => __awaiter(void 0, void 0, void 0, function* () {
     apiServices.setAuth("eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiIweDdjRUI4ZDgxNDdBYWE5ZEI4MUFjQkRGRTVjMzA1MERGQ2ZGMTg1MzciLCJzdWIiOiIweDg3RkU4YjRmMkZlODM3MGY2Y0M5YTk2MzQ0MmYwN0IwMmY0OTA5QTciLCJhdWQiOiJvdG9tYXRvLXRlc3QubmV0bGlmeS5hcHAiLCJleHAiOjE3MjMzODMxOTksIm5iZiI6MTcyMDc4OTM5OSwiaWF0IjoxNzIwNzkxMTk5LCJqdGkiOiIweDY4ZDkxOWEyMGZiYjIyNDUwZDZmOTFjMzM2ZTBmYjBjMmYyYTc3MmU3Zjg4NWU1ZjRmNzg1NTM2ZGIyYTY5YTAiLCJjdHgiOnt9fQ.MHgyOTM1NTM3MWYwOWM1YzllNWE3YjI4MjVkZTNjMDljZTkwMTQ3OTQwZmU1ZWRlMjM5YTk0MmFjYTQ5YTcwZWI0MGJlNmJiZDk2MDA4ZTIxMzJmNGM3ZTVlZGIzZDZiZjYyMDE4Mzc1MzUwMTRmNTc0ODM0ZDk4YWU3NDQwNDQzOTFi");
-    const usdcTransferTrigger = new Trigger({
-        blockId: TRIGGERS.TOKENS.ERC20.TRANSFER.blockId,
-        name: TRIGGERS.TOKENS.ERC20.TRANSFER.name,
-        description: TRIGGERS.TOKENS.ERC20.TRANSFER.description,
-        type: TRIGGERS.TOKENS.ERC20.TRANSFER.type,
-        parameters: TRIGGERS.TOKENS.ERC20.TRANSFER.parameters,
-        image: TRIGGERS.TOKENS.ERC20.TRANSFER.image,
-        ref: 'n-1',
-    });
-    usdcTransferTrigger.setChainId(CHAINS.ETHEREUM);
-    usdcTransferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
-    usdcTransferTrigger.setPosition(0, 0);
+    const trigger = new Trigger(TRIGGERS.PRICE_ACTION.ON_CHAIN_PRICE_MOVEMENT.PRICE_MOVEMENT_AGAINST_CURRENCY);
+    trigger.setChainId(CHAINS.MODE);
+    trigger.setComparisonValue(3000);
+    trigger.setCondition('gte');
+    trigger.setParams('currency', 'USD');
+    trigger.setContractAddress(getTokenFromSymbol(CHAINS.MODE, 'WETH').contractAddress);
+    trigger.setPosition(0, 0);
     const slackAction = new Action(ACTIONS.NOTIFICATIONS.SLACK.SEND_MESSAGE);
-    slackAction.setParams("webhook", "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX");
-    slackAction.setParams("message", "USDC has been transferred!");
+    slackAction.setParams("webhook", "https://hooks.slack.com/services/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");
+    slackAction.setParams("message", "Notification from the SDK");
     slackAction.setPosition(0, -10);
-    const workflow = new Workflow("USDC Transfer Notification", [usdcTransferTrigger, slackAction]);
+    const transferAction = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
+    transferAction.setChainId(CHAINS.ETHEREUM);
+    transferAction.setParams("value", 1000);
+    transferAction.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    transferAction.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    const workflow = new Workflow("test from SDK", [trigger, slackAction, transferAction]);
     const edge = new Edge({
-        source: usdcTransferTrigger,
+        source: trigger,
         target: slackAction,
     });
-    workflow.addEdge(edge);
-    const res = yield workflow.create();
-    console.log(res);
-    console.log(`Workflow ID: ${workflow.id}`); // This will print the ID of the created workflow
-    workflow.nodes.forEach(node => {
-        console.log(`Node ${node.getRef()} ID: ${node.id}`);
+    const edge2 = new Edge({
+        source: slackAction,
+        target: transferAction,
     });
+    workflow.addEdge(edge);
+    workflow.addEdge(edge2);
+    console.log(JSON.stringify(workflow.toJSON()));
+    const creationResult = yield workflow.create();
+    if (!creationResult.success) {
+        throw new Error("An error occurred when publishing the workflow");
+    }
+    console.log(workflow.id);
+    const runResult = yield workflow.run();
+    if (!runResult.success) {
+        throw new Error("An error occurred when running the workflow");
+    }
+    console.log(`Workflow ${workflow.id} is running`);
 });
 main();

package/dist/examples/load-workflow.js

@@ -11,6 +11,6 @@ import { Workflow, apiServices } from '../src/index.js';
 const main = () => __awaiter(void 0, void 0, void 0, function* () {
     apiServices.setAuth("eyJhbGciOiJFUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiIweDdjRUI4ZDgxNDdBYWE5ZEI4MUFjQkRGRTVjMzA1MERGQ2ZGMTg1MzciLCJzdWIiOiIweDg3RkU4YjRmMkZlODM3MGY2Y0M5YTk2MzQ0MmYwN0IwMmY0OTA5QTciLCJhdWQiOiJvdG9tYXRvLXRlc3QubmV0bGlmeS5hcHAiLCJleHAiOjE3MjMzODMxOTksIm5iZiI6MTcyMDc4OTM5OSwiaWF0IjoxNzIwNzkxMTk5LCJqdGkiOiIweDY4ZDkxOWEyMGZiYjIyNDUwZDZmOTFjMzM2ZTBmYjBjMmYyYTc3MmU3Zjg4NWU1ZjRmNzg1NTM2ZGIyYTY5YTAiLCJjdHgiOnt9fQ.MHgyOTM1NTM3MWYwOWM1YzllNWE3YjI4MjVkZTNjMDljZTkwMTQ3OTQwZmU1ZWRlMjM5YTk0MmFjYTQ5YTcwZWI0MGJlNmJiZDk2MDA4ZTIxMzJmNGM3ZTVlZGIzZDZiZjYyMDE4Mzc1MzUwMTRmNTc0ODM0ZDk4YWU3NDQwNDQzOTFi");
     const workflow = yield new Workflow().load("0b9bd533-339c-42b5-9ed3-a6a40fcfa8d3");
-    console.log(workflow);
+    console.log(JSON.stringify(workflow.nodes[1]));
 });
 main();

package/dist/examples/login.js

@@ -0,0 +1,32 @@
+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, apiServices } from '../src/index.js';
+const main = () => __awaiter(void 0, void 0, void 0, function* () {
+    const address = "0x9b1E25bBbee162A26B67B1fb00cf4d67157656F6";
+    let payload = yield apiServices.generateLoginPayload(address, CHAINS.ETHEREUM);
+    // we replace the payload to fit the signature, don't do that in your implementation
+    const signature = '0x92a3b551ff2bc2eb9a3537a0b477af14c33e649c3479c204bb0a4da95bfee89e4ae966e5d555d34c5dfcf3899910c58e936375634f5b0f58978139d25b5b54761b';
+    payload = {
+        address: '0x9b1E25bBbee162A26B67B1fb00cf4d67157656F6',
+        chain_id: '1',
+        domain: 'otomato-test.netlify.app',
+        expiration_time: '2024-07-16T16:57:34.363Z',
+        invalid_before: '2024-07-16T15:57:34.363Z',
+        issued_at: '2024-07-16T16:27:34.363Z',
+        nonce: '0x4ed46b76a2ccb458bc84bfc3f8aeb43bbc6a2b2f1ae5ee9f10c13ba6bd05f832',
+        statement: 'Please ensure that the domain above matches the URL of the current website.',
+        version: '1'
+    };
+    const { token } = yield apiServices.getToken(payload, signature);
+    const verify = yield apiServices.verifyToken(token);
+    console.log(token);
+    console.log(verify);
+});
+main();

package/dist/src/constants/Blocks.js

@@ -93,7 +93,7 @@ export const TRIGGERS = {
         "SPLICE_FI": {
             "description": "Split any yield-bearing asset into separate yield and principal components",
             "chains": [
-                43334
+                34443
             ],
             "image": "https://otomato-sdk-images.s3.eu-west-1.amazonaws.com/splicefi.png",
             "SWAP": {
@@ -244,7 +244,7 @@ export const TRIGGERS = {
         "ASTARIA": {
             "description": "Astaria is an oracle-less, intent-based, fixed-rate lending protocol supporting unlimited loan durations for any asset",
             "chains": [
-                43334
+                34443
             ],
             "image": "https://otomato-sdk-images.s3.eu-west-1.amazonaws.com/astaria.png",
             "LEND_RECALLED": {
@@ -278,7 +278,7 @@ export const TRIGGERS = {
         "ODOS": {
             "description": "Smart Order Routing across multiple blockchain protocols, 700+ Liquidity Sources and thousands of token pairs, delivering ultimate savings to users",
             "chains": [
-                43334,
+                34443,
                 1
             ],
             "image": "https://otomato-sdk-images.s3.eu-west-1.amazonaws.com/odos.jpg",
@@ -329,7 +329,7 @@ export const TRIGGERS = {
         "MODE_NAME_SERVICE": {
             "description": "Next generation of Mode Mainnet Domains",
             "chains": [
-                43334
+                34443
             ],
             "image": "https://otomato-sdk-images.s3.eu-west-1.amazonaws.com/modens.png",
             "NAME_REGISTERED": {

package/dist/src/constants/chains.js

@@ -1,5 +1,5 @@
 export const CHAINS = {
     ALL: 0,
     ETHEREUM: 1,
-    MODE: 43334,
+    MODE: 34443,
 };

package/dist/src/constants/tokens.js

@@ -7,7 +7,7 @@ export const TOKENS = {
             decimals: 6
         },
     ],
-    43334: [
+    34443: [
         {
             contractAddress: "0x0000000000000000000000000000000000000000",
             name: "ETH",
@@ -93,14 +93,24 @@ export const NFTS = {
             name: "Lil Pudgies"
         },
     ],
-    43334: [
+    34443: [
         {
             contractAddress: "0x2ad86eeec513ac16804bb05310214c3fd496835b",
             name: "Space id"
         }
     ]
 };
-export function getToken(chain, symbol) {
+export function getToken(chain, contractAddress) {
+    if (!(chain in TOKENS)) {
+        throw new Error(`Unsupported chain: ${chain}`);
+    }
+    const token = TOKENS[chain].find(token => token.contractAddress.toLowerCase() === contractAddress.toLowerCase());
+    if (!token) {
+        throw new Error(`Token with contract address ${contractAddress} not found on chain ${chain}`);
+    }
+    return token;
+}
+export function getTokenFromSymbol(chain, symbol) {
     if (!(chain in TOKENS)) {
         throw new Error(`Unsupported chain: ${chain}`);
     }

package/dist/src/index.js

@@ -12,3 +12,4 @@ export * from './models/Node.js';
 export * from './models/Edge.js';
 // Exporting services
 export * from './services/ApiService.js';
+export * from './utils/helpers.js';

package/dist/src/models/Action.js

@@ -1,6 +1,78 @@
+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 { Node } from './Node.js';
+import { ACTIONS } from '../constants/Blocks.js';
+import { typeIsNumber } from '../utils/typeValidator.js';
 export class Action extends Node {
     constructor(action) {
         super(Object.assign(Object.assign({}, action), { class: 'action' }));
     }
+    getStaticParameters() {
+        return null;
+    }
+    static fromJSON(json) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const enriched = findActionByBlockId(json.blockId);
+            const action = new Action(Object.assign(Object.assign({}, enriched.block), { ref: json.ref, position: json.position, parentInfo: enriched.parentInfo }));
+            for (const [key, value] of Object.entries(json.parameters)) {
+                switch (key) {
+                    case 'chainId':
+                        action.setChainId(value);
+                        break;
+                    case 'contractAddress':
+                        action.setContractAddress(value);
+                        break;
+                    case 'abi':
+                        const abiParameters = value.parameters;
+                        for (const abiKey in abiParameters) {
+                            const enrichedParameter = enriched.block.parameters.find((param) => param.key === `abiParams.${abiKey}`);
+                            const paramType = enrichedParameter ? enrichedParameter.type : null;
+                            if (!abiParameters[abiKey] || !paramType)
+                                continue;
+                            if (typeIsNumber(paramType) && typeof abiParameters[abiKey] === 'string' && abiParameters[abiKey].endsWith('n')) {
+                                action.setParams(abiKey, BigInt(abiParameters[abiKey].slice(0, -1)));
+                            }
+                            else {
+                                action.setParams(abiKey, abiParameters[abiKey]);
+                            }
+                        }
+                        break;
+                    case 'interval':
+                        // ignore
+                        break;
+                    default:
+                        action.setParams(key, value);
+                        break;
+                }
+            }
+            action.setId(json.id);
+            return action;
+        });
+    }
 }
+const findActionByBlockId = (blockId) => {
+    for (const category in ACTIONS) {
+        for (const service in ACTIONS[category]) {
+            for (const actionKey in ACTIONS[category][service]) {
+                if (ACTIONS[category][service][actionKey].blockId === blockId) {
+                    return {
+                        parentInfo: {
+                            name: service,
+                            description: ACTIONS[category][service].description,
+                            image: ACTIONS[category][service].image,
+                        },
+                        block: ACTIONS[category][service][actionKey],
+                    };
+                }
+            }
+        }
+    }
+    throw new Error(`Action with id ${blockId} not found`);
+};

package/dist/src/models/Node.js

@@ -1,6 +1,13 @@
-// Assuming you have the ACTIONS constant defined as you provided
+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 { validateType } from '../utils/typeValidator.js';
-import { ACTIONS, TRIGGERS } from '../constants/Blocks.js';
 let nodeCounter = 0;
 const generatedRefs = new Set();
 export class Node {
@@ -14,6 +21,7 @@ export class Node {
         this.parameters = {};
         this.keyMap = {};
         this.class = node.class;
+        this.parentInfo = node.parentInfo;
         if (node.ref) {
             this.ref = node.ref;
         }
@@ -52,6 +60,9 @@ export class Node {
     getRef() {
         return this.ref;
     }
+    getParentInfo() {
+        return this.parentInfo;
+    }
     setParameter(key, value) {
         if (key in this.parameters) {
             const param = this.parameters[key];
@@ -89,77 +100,55 @@ export class Node {
             return acc;
         }, {});
     }
+    getStaticParameters() {
+        return null;
+    }
     toJSON() {
+        const serializeBigInt = (key, value) => {
+            if (typeof value === 'bigint') {
+                return value.toString() + 'n';
+            }
+            else if (typeof value === 'object' && value !== null) {
+                // Recursively call serializeBigInt for nested objects
+                return Object.entries(value).reduce((acc, [k, v]) => {
+                    acc[k] = serializeBigInt(k, v);
+                    return acc;
+                }, {});
+            }
+            else {
+                return value;
+            }
+        };
+        const staticParameters = this.getStaticParameters() || {};
         const json = {
             id: this.id,
             ref: this.ref,
             blockId: this.blockId,
             type: this.class,
-            parameters: this.getParameters(),
+            parameters: Object.assign(Object.assign({}, this.getParameters()), staticParameters),
         };
         if (this.position) {
             json.position = this.position;
         }
-        return json;
+        return JSON.parse(JSON.stringify(json, serializeBigInt));
     }
     getSimplifiedKey(key) {
         return key.replace(/[.\[\]]/g, '_');
     }
     static fromJSON(json) {
-        let enriched = findActionByBlockId(json.blockId);
-        if (!enriched)
-            enriched = findTriggerByBlockId(json.blockId);
-        if (!enriched)
-            enriched = { name: "Unknown", description: "Unknown", image: "Unknown" };
-        const parameters = Object.keys(json.parameters).map(key => ({
-            key,
-            type: typeof json.parameters[key], // Assuming type can be derived from the value's type
-            description: '', // Add appropriate description if needed
-            value: json.parameters[key]
-        }));
-        const node = new Node({
-            blockId: json.blockId,
-            name: enriched.name,
-            description: enriched.description,
-            image: enriched.image,
-            parameters,
-            ref: json.ref,
-            position: json.position,
-            class: json.type
-        });
-        node.setId(json.id);
-        return node;
-    }
-}
-const findActionByBlockId = (blockId) => {
-    for (const category in ACTIONS) {
-        for (const service in ACTIONS[category]) {
-            for (const actionKey in ACTIONS[category][service]) {
-                if (ACTIONS[category][service][actionKey].blockId === blockId) {
-                    return {
-                        name: ACTIONS[category][service][actionKey].name,
-                        description: ACTIONS[category][service][actionKey].description,
-                        image: ACTIONS[category][service][actionKey].image,
-                    };
+        return __awaiter(this, void 0, void 0, function* () {
+            switch (json.type) {
+                case 'trigger': {
+                    const { Trigger } = yield import('./Trigger.js');
+                    return Trigger.fromJSON(json);
                 }
-            }
-        }
-    }
-    return null;
-};
-const findTriggerByBlockId = (blockId) => {
-    for (const category in TRIGGERS) {
-        for (const service in TRIGGERS[category]) {
-            for (const triggerKey in TRIGGERS[category][service]) {
-                if (TRIGGERS[category][service][triggerKey].blockId === blockId) {
-                    return {
-                        name: TRIGGERS[category][service][triggerKey].name,
-                        description: TRIGGERS[category][service][triggerKey].description,
-                        image: TRIGGERS[category][service][triggerKey].image,
-                    };
+                case 'action': {
+                    const { Action } = yield import('./Action.js');
+                    return Action.fromJSON(json);
                 }
+                default:
+                    throw new Error(`Unsupported type: ${json.type}`);
             }
-        }
+        });
     }
-    return null;
-};
+}

package/dist/src/models/Trigger.js

@@ -1,4 +1,15 @@
+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 { Node } from './Node.js';
+import { TRIGGERS } from '../constants/Blocks.js';
+import { typeIsNumber } from '../utils/typeValidator.js';
 export class Trigger extends Node {
     constructor(trigger) {
         super(Object.assign(Object.assign({}, trigger), { class: 'trigger' }));
@@ -19,10 +30,75 @@ export class Trigger extends Node {
         }
         this.setParameter('comparisonValue', value);
     }
-    setInterval(value) {
-        if (this.notAPollingTrigger()) {
-            throw new Error('Interval setting is not applicable for subscription based triggers.');
+    getStaticParameters() {
+        if (!this.notAPollingTrigger()) {
+            return { interval: 5000 };
         }
-        this.setParameter('interval', value);
+        return null;
+    }
+    static fromJSON(json) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const enriched = findTriggerByBlockId(json.blockId);
+            const trigger = new Trigger(Object.assign(Object.assign({}, enriched.block), { ref: json.ref, position: json.position, parentInfo: enriched.parentInfo }));
+            for (const [key, value] of Object.entries(json.parameters)) {
+                switch (key) {
+                    case 'chainId':
+                        trigger.setChainId(value);
+                        break;
+                    case 'contractAddress':
+                        trigger.setContractAddress(value);
+                        break;
+                    case 'condition':
+                        trigger.setCondition(value);
+                        break;
+                    case 'comparisonValue':
+                        trigger.setComparisonValue(value);
+                        break;
+                    case 'abi':
+                        const abiParameters = value.parameters;
+                        for (const abiKey in abiParameters) {
+                            const enrichedParameter = enriched.block.parameters.find((param) => param.key === `abiParams.${abiKey}`);
+                            const paramType = enrichedParameter ? enrichedParameter.type : null;
+                            if (!abiParameters[abiKey] || !paramType)
+                                continue;
+                            if (typeIsNumber(paramType) && typeof abiParameters[abiKey] === 'string' && abiParameters[abiKey].endsWith('n')) {
+                                trigger.setParams(abiKey, BigInt(abiParameters[abiKey].slice(0, -1)));
+                            }
+                            else {
+                                trigger.setParams(abiKey, abiParameters[abiKey]);
+                            }
+                        }
+                        break;
+                    case 'interval':
+                        // ignore
+                        break;
+                    default:
+                        trigger.setParams(key, value);
+                        break;
+                }
+            }
+            trigger.setId(json.id);
+            return trigger;
+        });
     }
 }
+// Assuming findTriggerByBlockId function is defined as mentioned
+const findTriggerByBlockId = (blockId) => {
+    for (const category in TRIGGERS) {
+        for (const service in TRIGGERS[category]) {
+            for (const triggerKey in TRIGGERS[category][service]) {
+                if (TRIGGERS[category][service][triggerKey].blockId === blockId) {
+                    return {
+                        parentInfo: {
+                            name: service,
+                            description: TRIGGERS[category][service].description,
+                            image: TRIGGERS[category][service].image,
+                        },
+                        block: TRIGGERS[category][service][triggerKey],
+                    };
+                }
+            }
+        }
+    }
+    throw new Error(`Trigger with id ${blockId} not found`);
+};