otomato-sdk 1.3.2 → 1.3.5

package/dist/src/models/Workflow.js

@@ -42,16 +42,27 @@ export class Workflow {
     }
     create() {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield apiServices.post('/workflows', this.toJSON());
-            this.id = response.id; // Assign the returned ID to the workflow instance
-            // Assign IDs to the nodes based on the response
-            response.nodes.forEach((nodeResponse) => {
-                const node = this.nodes.find(n => n.getRef() === nodeResponse.ref);
-                if (node) {
-                    node.setId(nodeResponse.id);
+            var _a;
+            try {
+                const response = yield apiServices.post('/workflows', this.toJSON());
+                if (response.status === 201) {
+                    this.id = response.data.id; // Assign the returned ID to the workflow instance
+                    // Assign IDs to the nodes based on the response
+                    response.data.nodes.forEach((nodeResponse) => {
+                        const node = this.nodes.find(n => n.getRef() === nodeResponse.ref);
+                        if (node) {
+                            node.setId(nodeResponse.id);
+                        }
+                    });
+                    return { success: true };
                 }
-            });
-            return response;
+                else {
+                    return { success: false, error: ((_a = response.data) === null || _a === void 0 ? void 0 : _a.error) || 'Unknown error' };
+                }
+            }
+            catch (error) {
+                return { success: false, error: error.message || 'Unknown error' };
+            }
         });
     }
     load(workflowId) {
@@ -64,4 +75,24 @@ export class Workflow {
             return this;
         });
     }
+    run() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            if (!this.id) {
+                throw new Error('The workflow needs to be published first');
+            }
+            try {
+                const response = yield apiServices.post(`/workflows/${this.id}/run`, this.toJSON());
+                if (response.status === 204) {
+                    return { success: true };
+                }
+                else {
+                    return { success: false, error: ((_a = response.data) === null || _a === void 0 ? void 0 : _a.error) || 'Unknown error' };
+                }
+            }
+            catch (error) {
+                return { success: false, error: error.message || 'Unknown error' };
+            }
+        });
+    }
 }

package/dist/src/services/ApiService.js

@@ -7,7 +7,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-// networkService.ts
 import axios from 'axios';
 const API_CONFIG = {
     BASE_URL: 'https://staging-api.otomato.xyz/api',
@@ -22,17 +21,14 @@ const axiosInstance = axios.create({
 class ApiServices {
     constructor() {
         this.auth = null;
-        // You can add other methods (get, put, delete) similarly
     }
     setAuth(auth) {
         this.auth = auth;
     }
     post(url, data) {
         return __awaiter(this, void 0, void 0, function* () {
-            console.log(JSON.stringify(data));
             const headers = this.auth ? { 'Authorization': this.auth } : {};
-            const response = yield axiosInstance.post(url, data, { headers });
-            return response.data;
+            return yield axiosInstance.post(url, data, { headers });
         });
     }
     get(url) {
@@ -42,5 +38,31 @@ class ApiServices {
             return response.data;
         });
     }
+    generateLoginPayload(address, chainId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = { 'Content-Type': 'application/json' };
+            const response = yield axiosInstance.post('/auth/generate-payload', { address, chainId }, { headers });
+            return response.data;
+        });
+    }
+    getToken(loginPayload, signature) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = { 'Content-Type': 'application/json' };
+            const body = {
+                payload: loginPayload,
+                signature,
+            };
+            const response = yield axiosInstance.post('/auth/token', body, { headers });
+            const token = response.data.token;
+            return { token };
+        });
+    }
+    verifyToken(token) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const headers = { 'Content-Type': 'application/json' };
+            const response = yield axiosInstance.post('/auth/verify-token', { token }, { headers });
+            return response.data;
+        });
+    }
 }
 export const apiServices = new ApiServices();

package/dist/src/utils/helpers.js

@@ -0,0 +1,19 @@
+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 { ethers } from 'ethers';
+import { getToken } from '../constants/tokens.js';
+export function convertToTokenUnits(amount, chainId, contractAddress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const token = yield getToken(chainId, contractAddress);
+        const decimals = token.decimals;
+        const adjustedAmount = ethers.parseUnits(amount.toString(), decimals);
+        return adjustedAmount;
+    });
+}

package/dist/src/utils/typeValidator.js

@@ -6,21 +6,21 @@ export function validateType(expectedType, value) {
             return typeof value === 'boolean';
         case 'chainId':
         case 'integer':
-            return Number.isInteger(value);
+            return Number.isInteger(value) || typeof value === 'bigint';
         case 'int8':
         case 'int16':
         case 'int32':
         case 'int64':
         case 'int128':
         case 'int256':
-            return Number.isInteger(value) && isIntInRange(value, parseInt(expectedType.replace('int', '')));
+            return (Number.isInteger(value) || typeof value === 'bigint') && isIntInRange(value, parseInt(expectedType.replace('int', '')));
         case 'uint8':
         case 'uint16':
         case 'uint32':
         case 'uint64':
         case 'uint128':
         case 'uint256':
-            return Number.isInteger(value) && isUintInRange(value, parseInt(expectedType.replace('uint', '')));
+            return (Number.isInteger(value) || typeof value === 'bigint') && isUintInRange(value, parseInt(expectedType.replace('uint', '')));
         case 'erc20':
         case 'nftCollection':
         case 'address':
@@ -45,14 +45,40 @@ export function validateType(expectedType, value) {
             return false;
     }
 }
+export function typeIsNumber(type) {
+    switch (type) {
+        case 'integer':
+        case 'float':
+        case 'fixed':
+        case 'ufixed':
+        case 'chainId':
+        case 'int8':
+        case 'int16':
+        case 'int32':
+        case 'int64':
+        case 'int128':
+        case 'int256':
+        case 'uint8':
+        case 'uint16':
+        case 'uint32':
+        case 'uint64':
+        case 'uint128':
+        case 'uint256':
+            return true;
+        default:
+            return false;
+    }
+}
 function isIntInRange(value, bits) {
-    const min = -(Math.pow(2, (bits - 1)));
-    const max = (Math.pow(2, (bits - 1))) - 1;
-    return value >= min && value <= max;
+    const min = BigInt(-(Math.pow(2, (bits - 1))));
+    const max = BigInt((Math.pow(2, (bits - 1))) - 1);
+    const bigIntValue = BigInt(value);
+    return bigIntValue >= min && bigIntValue <= max;
 }
 function isUintInRange(value, bits) {
-    const max = (Math.pow(2, bits)) - 1;
-    return value >= 0 && value <= max;
+    const max = BigInt((Math.pow(2, bits)) - 1);
+    const bigIntValue = BigInt(value);
+    return bigIntValue >= 0 && bigIntValue <= max;
 }
 export function isAddress(value) {
     return ethers.isAddress(value);

package/dist/test/action.spec.js

@@ -1,13 +1,22 @@
+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 { expect } from 'chai';
-import { Action, ACTIONS, getToken, CHAINS } from '../src/index';
+import { Action, ACTIONS, getTokenFromSymbol, CHAINS } from '../src/index';
 const DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
 describe('Action Class', () => {
     it('should create a transfer action without parameters', () => {
         const transferAction = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
         const params = transferAction.getParameters();
         expect(params.chainId).to.be.null;
-        expect(params['abiParams.value']).to.be.null;
-        expect(params['abiParams.to']).to.be.null;
+        expect(params.abi.parameters.value).to.be.null;
+        expect(params.abi.parameters.to).to.be.null;
         expect(params.contractAddress).to.be.null;
     });
     it('should create a transfer action and set parameters correctly', () => {
@@ -15,29 +24,34 @@ describe('Action Class', () => {
         transferAction.setChainId(CHAINS.ETHEREUM);
         transferAction.setParams("value", 1000);
         transferAction.setParams("to", DEFAULT_ADDRESS);
-        transferAction.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        transferAction.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
         const params = transferAction.getParameters();
         expect(params.chainId).to.equal(CHAINS.ETHEREUM);
-        expect(params['abiParams.value']).to.equal(1000);
-        expect(params['abiParams.to']).to.equal(DEFAULT_ADDRESS);
-        expect(params.contractAddress).to.equal(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        expect(params.abi.parameters.value).to.equal(1000);
+        expect(params.abi.parameters.to).to.equal(DEFAULT_ADDRESS);
+        expect(params.contractAddress).to.equal(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
     });
     it('should be able to export an action as json', () => {
         const transferAction = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
         transferAction.setChainId(CHAINS.ETHEREUM);
         transferAction.setParams("value", 1000);
         transferAction.setParams("to", DEFAULT_ADDRESS);
-        transferAction.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        transferAction.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
         const json = transferAction.toJSON();
         expect(json).to.deep.equal({
             blockId: ACTIONS.TOKENS.ERC20.TRANSFER.blockId,
             ref: transferAction.getRef(),
             type: 'action',
+            id: null,
             parameters: {
                 chainId: CHAINS.ETHEREUM,
-                'abiParams.value': 1000,
-                'abiParams.to': DEFAULT_ADDRESS,
-                contractAddress: getToken(CHAINS.ETHEREUM, 'USDC').contractAddress
+                abi: {
+                    parameters: {
+                        to: DEFAULT_ADDRESS,
+                        value: 1000
+                    }
+                },
+                contractAddress: getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress
             }
         });
     });
@@ -74,4 +88,59 @@ describe('Action Class', () => {
       const smsAction = new Action(ACTIONS.NOTIFICATIONS.SMS);
       expect(() => smsAction.setParams("phoneNumber", "invalid_phone_number")).to.throw('Invalid type for parameter phoneNumber. Expected phone_number.');
     });*/
+    it('should create an action from JSON correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _a;
+        const json = {
+            "id": "755671a7-adac-4aeb-a759-73c00dd397bc",
+            "ref": "n-2",
+            "blockId": 100002,
+            "type": "action",
+            "position": {
+                "x": 0,
+                "y": -10
+            },
+            "parameters": {
+                "message": "ETH is at 3550 :pepe_joy:",
+                "webhook": "https://hooks.slack.com/services/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"
+            }
+        };
+        const action = yield Action.fromJSON(json);
+        expect(action.id).to.equal("755671a7-adac-4aeb-a759-73c00dd397bc");
+        expect(action.getRef()).to.equal("n-2");
+        expect(action.blockId).to.equal(100002);
+        expect(action.getParameters().message).to.equal("ETH is at 3550 :pepe_joy:");
+        expect(action.getParameters().webhook).to.equal("https://hooks.slack.com/services/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");
+        expect((_a = action.getParentInfo()) === null || _a === void 0 ? void 0 : _a.name).to.equal("SLACK");
+        expect(action.toJSON()).to.deep.equal(json);
+    }));
+    it('should create an action with abi parameters from JSON correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+        var _b;
+        const json = {
+            "id": "d6e6884f-cd8f-4c96-b36c-e5539b3599fc",
+            "ref": "n-3",
+            "blockId": 100004,
+            "type": "action",
+            "parameters": {
+                "abi": {
+                    "parameters": {
+                        "to": "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6",
+                        "value": 1000
+                    }
+                },
+                "chainId": 1,
+                "contractAddress": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
+            }
+        };
+        const action = yield Action.fromJSON(json);
+        console.log(action);
+        expect(action.id).to.equal("d6e6884f-cd8f-4c96-b36c-e5539b3599fc");
+        expect(action.getRef()).to.equal("n-3");
+        expect(action.blockId).to.equal(100004);
+        expect(action.getParameters().chainId).to.equal(1);
+        expect(action.getParameters().contractAddress).to.equal("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48");
+        expect(action.getParameters().abi.parameters.to).to.equal("0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+        expect(action.getParameters().abi.parameters.value).to.equal(1000);
+        expect((_b = action.getParentInfo()) === null || _b === void 0 ? void 0 : _b.name).to.equal("ERC20");
+        expect(action.toJSON()).to.deep.equal(json);
+    }));
 });

package/dist/test/automation.spec.js

@@ -2,18 +2,18 @@ import { expect } from 'chai';
 import { Workflow } from '../src/models/Workflow.js';
 import { Trigger } from '../src/models/Trigger.js';
 import { Action } from '../src/models/Action.js';
-import { TRIGGERS, ACTIONS, getToken, CHAINS } from '../src/index.js';
+import { TRIGGERS, ACTIONS, getTokenFromSymbol, CHAINS } from '../src/index.js';
 describe('Workflow Class', () => {
     it('should create a workflow with a trigger and actions', () => {
         const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
         trigger.setChainId(CHAINS.ETHEREUM);
-        trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        trigger.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
         trigger.setPosition(0, 0);
         const action1 = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
         action1.setChainId(CHAINS.ETHEREUM);
         action1.setParams("value", 1000);
         action1.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
-        action1.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        action1.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
         action1.setPosition(1, 0);
         const action2 = new Action(ACTIONS.NOTIFICATIONS.SLACK.SEND_MESSAGE);
         action2.setParams("webhook", "https://webhook.url");
@@ -23,6 +23,7 @@ describe('Workflow Class', () => {
         const json = workflow.toJSON();
         expect(json).to.deep.equal({
             name: "Test Workflow",
+            id: null,
             nodes: [trigger.toJSON(), action1.toJSON(), action2.toJSON()],
             edges: []
         });
@@ -30,7 +31,7 @@ describe('Workflow Class', () => {
     it('should set the name of the workflow', () => {
         const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
         trigger.setChainId(CHAINS.ETHEREUM);
-        trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        trigger.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
         trigger.setPosition(0, 0);
         const workflow = new Workflow("Initial Name", [trigger]);
         workflow.setName("Updated Name");
@@ -39,11 +40,11 @@ describe('Workflow Class', () => {
     it('should add a trigger to the workflow', () => {
         const initialTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
         initialTrigger.setChainId(CHAINS.ETHEREUM);
-        initialTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        initialTrigger.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
         initialTrigger.setPosition(0, 0);
         const newTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
         newTrigger.setChainId(CHAINS.ETHEREUM);
-        newTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        newTrigger.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
         newTrigger.setPosition(1, 0);
         const workflow = new Workflow("Test Workflow", [initialTrigger]);
         workflow.addNode(newTrigger);
@@ -52,13 +53,13 @@ describe('Workflow Class', () => {
     it('should add actions to the workflow', () => {
         const trigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
         trigger.setChainId(CHAINS.ETHEREUM);
-        trigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        trigger.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
         trigger.setPosition(0, 0);
         const action1 = new Action(ACTIONS.TOKENS.ERC20.TRANSFER);
         action1.setChainId(CHAINS.ETHEREUM);
         action1.setParams("value", 1000);
         action1.setParams("to", "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
-        action1.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+        action1.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
         action1.setPosition(1, 0);
         const action2 = new Action(ACTIONS.NOTIFICATIONS.SLACK.SEND_MESSAGE);
         action2.setParams("webhook", "https://webhook.url");

package/dist/test/helpers.spec.js

@@ -0,0 +1,23 @@
+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 { expect } from 'chai';
+import { convertToTokenUnits, getTokenFromSymbol, CHAINS } from '../src/index.js';
+describe('convertToTokenUnits', () => {
+    it('should return 10^6 for 1 USDC', () => __awaiter(void 0, void 0, void 0, function* () {
+        const usdcContractAddr = getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress;
+        const result = yield convertToTokenUnits(1, CHAINS.ETHEREUM, usdcContractAddr);
+        expect(result).to.equal(BigInt(Math.pow(10, 6)));
+    }));
+    it('should return 10^18 for 1 MODE', () => __awaiter(void 0, void 0, void 0, function* () {
+        const modeContractAddr = getTokenFromSymbol(CHAINS.MODE, 'MODE').contractAddress;
+        const result = yield convertToTokenUnits(1, CHAINS.MODE, modeContractAddr);
+        expect(result).to.equal(BigInt(Math.pow(10, 18)));
+    }));
+});

package/dist/test/node.spec.js

@@ -1,29 +1,27 @@
 import { expect } from 'chai';
-import { Node } from '../src/index'; // Adjust the import path according to your project structure
+import { Action } from '../src/index'; // Adjust the import path according to your project structure
 const DEFAULT_PARAMETERS = [
     { key: 'chainId', type: 'integer', description: 'Chain ID', value: null },
     { key: 'contractAddress', type: 'address', description: 'Contract Address', value: null }
 ];
 describe('Node Class', () => {
     it('should create a node without coordinates', () => {
-        const node = new Node({
+        const node = new Action({
             blockId: 1,
             name: 'Test Node',
             description: 'A node for testing',
             parameters: DEFAULT_PARAMETERS,
-            class: 'testClass',
             image: 'a',
         });
         expect(node.position).to.be.undefined;
     });
     it('should create a node with coordinates', () => {
         var _a, _b;
-        const node = new Node({
+        const node = new Action({
             blockId: 2,
             name: 'Test Node with Coordinates',
             description: 'A node for testing with coordinates',
             parameters: DEFAULT_PARAMETERS,
-            class: 'testClass',
             position: { x: 100, y: 200 },
             image: 'a',
         });
@@ -32,12 +30,11 @@ describe('Node Class', () => {
     });
     it('should set and get coordinates correctly', () => {
         var _a, _b;
-        const node = new Node({
+        const node = new Action({
             blockId: 3,
             name: 'Test Node for Coordinates',
             description: 'A node for testing coordinate setting',
             parameters: DEFAULT_PARAMETERS,
-            class: 'testClass',
             image: 'a',
         });
         node.setPosition(300, 400);
@@ -45,12 +42,11 @@ describe('Node Class', () => {
         expect((_b = node.position) === null || _b === void 0 ? void 0 : _b.y).to.equal(400);
     });
     it('should create a node and set parameters correctly', () => {
-        const node = new Node({
+        const node = new Action({
             blockId: 4,
             name: 'Test Node for Parameters',
             description: 'A node for testing parameter setting',
             parameters: DEFAULT_PARAMETERS,
-            class: 'testClass',
             image: 'a',
         });
         node.setChainId(1);
@@ -60,12 +56,11 @@ describe('Node Class', () => {
         expect(params.contractAddress).to.equal("0x0000000000000000000000000000000000000000");
     });
     it('should be able to export a node as json without coordinates', () => {
-        const node = new Node({
+        const node = new Action({
             blockId: 5,
             name: 'Test Node for JSON',
             description: 'A node for testing JSON export',
             parameters: DEFAULT_PARAMETERS,
-            class: 'testClass',
             image: 'a',
         });
         node.setChainId(1);
@@ -73,8 +68,9 @@ describe('Node Class', () => {
         const json = node.toJSON();
         expect(json).to.deep.equal({
             blockId: 5,
+            id: null,
             ref: node.getRef(),
-            type: 'testClass',
+            type: 'action',
             parameters: {
                 chainId: 1,
                 contractAddress: "0x0000000000000000000000000000000000000000"
@@ -82,12 +78,11 @@ describe('Node Class', () => {
         });
     });
     it('should be able to export a node as json with coordinates', () => {
-        const node = new Node({
+        const node = new Action({
             blockId: 6,
             name: 'Test Node for JSON with Coordinates',
             description: 'A node for testing JSON export with coordinates',
             parameters: DEFAULT_PARAMETERS,
-            class: 'testClass',
             position: { x: 1, y: 2 },
             image: 'a',
         });
@@ -95,8 +90,9 @@ describe('Node Class', () => {
         node.setContractAddress("0x0000000000000000000000000000000000000000");
         const json = node.toJSON();
         expect(json).to.deep.equal({
-            type: 'testClass',
+            type: 'action',
             blockId: 6,
+            id: null,
             ref: node.getRef(),
             parameters: {
                 chainId: 1,
@@ -106,23 +102,21 @@ describe('Node Class', () => {
         });
     });
     it('should throw an error for invalid parameter type', () => {
-        const node = new Node({
+        const node = new Action({
             blockId: 7,
             name: 'Test Node for Invalid Parameter Type',
             description: 'A node for testing invalid parameter type',
             parameters: DEFAULT_PARAMETERS,
-            class: 'testClass',
             image: 'a',
         });
         expect(() => node.setParams("chainId", "invalid")).to.throw('Invalid type for parameter chainId. Expected integer.');
     });
     it('should throw an error for invalid address', () => {
-        const node = new Node({
+        const node = new Action({
             blockId: 8,
             name: 'Test Node for Invalid Address',
             description: 'A node for testing invalid address',
             parameters: DEFAULT_PARAMETERS,
-            class: 'testClass',
             image: 'a',
         });
         expect(() => node.setParams("contractAddress", "invalid_address")).to.throw('Invalid type for parameter contractAddress. Expected address.');