otomato-sdk 1.3.2 → 1.3.5

package/test/action.spec.ts

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { Action, ACTIONS, getToken, CHAINS } from '../src/index';
+import { Action, ACTIONS, getTokenFromSymbol, CHAINS } from '../src/index';
 
 const DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
 
@@ -10,8 +10,8 @@ describe('Action Class', () => {
     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;
   });
 
@@ -20,13 +20,13 @@ 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', () => {
@@ -34,18 +34,23 @@ 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 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
       }
     });
   });
@@ -89,4 +94,63 @@ 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', async () => {
+    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 = await 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(action.getParentInfo()?.name).to.equal("SLACK");
+    expect(action.toJSON()).to.deep.equal(json);
+  });
+
+  it('should create an action with abi parameters from JSON correctly', async () => {
+    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 = await 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(action.getParentInfo()?.name).to.equal("ERC20");
+    expect(action.toJSON()).to.deep.equal(json);
+  });
 });

package/test/automation.spec.ts

@@ -2,20 +2,20 @@ 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);
@@ -28,6 +28,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: []
     });
@@ -36,7 +37,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]);
@@ -48,12 +49,12 @@ 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]);
@@ -65,14 +66,14 @@ 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);

package/test/helpers.spec.ts

@@ -0,0 +1,16 @@
+import { expect } from 'chai';
+import { convertToTokenUnits, getTokenFromSymbol, CHAINS } from '../src/index.js';
+
+describe('convertToTokenUnits', () => {
+  it('should return 10^6 for 1 USDC', async () => {
+    const usdcContractAddr = getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress;
+    const result = await convertToTokenUnits(1, CHAINS.ETHEREUM, usdcContractAddr);
+    expect(result).to.equal(BigInt(10 ** 6));
+  });
+
+  it('should return 10^18 for 1 MODE', async () => {
+    const modeContractAddr = getTokenFromSymbol(CHAINS.MODE, 'MODE').contractAddress;
+    const result = await convertToTokenUnits(1, CHAINS.MODE, modeContractAddr);
+    expect(result).to.equal(BigInt(10 ** 18));
+  });
+});

package/test/node.spec.ts

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { Node, Parameter } from '../src/index'; // Adjust the import path according to your project structure
+import { Action, Node, Parameter } from '../src/index'; // Adjust the import path according to your project structure
 
 const DEFAULT_PARAMETERS: Parameter[] = [
   { key: 'chainId', type: 'integer', description: 'Chain ID', value: null },
@@ -7,14 +7,13 @@ const DEFAULT_PARAMETERS: Parameter[] = [
 ];
 
 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',
     });
 
@@ -22,13 +21,12 @@ describe('Node Class', () => {
   });
 
   it('should create a node with coordinates', () => {
-    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},
+      position: { x: 100, y: 200 },
       image: 'a',
     });
 
@@ -37,12 +35,11 @@ describe('Node Class', () => {
   });
 
   it('should set and get coordinates correctly', () => {
-    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',
     });
 
@@ -52,12 +49,11 @@ describe('Node Class', () => {
   });
 
   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',
     });
 
@@ -70,12 +66,11 @@ describe('Node Class', () => {
   });
 
   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',
     });
 
@@ -85,8 +80,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"
@@ -95,13 +91,12 @@ 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},
+      position: { x: 1, y: 2 },
       image: 'a',
     });
 
@@ -110,36 +105,35 @@ describe('Node Class', () => {
 
     const json = node.toJSON();
     expect(json).to.deep.equal({
-      type: 'testClass',
+      type: 'action',
       blockId: 6,
+      id: null,
       ref: node.getRef(),
       parameters: {
         chainId: 1,
         contractAddress: "0x0000000000000000000000000000000000000000"
       },
-      position: {x: 1, y: 2}
+      position: { x: 1, y: 2 }
     });
   });
 
   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.');

package/test/trigger.spec.ts

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { Trigger, TRIGGERS, getToken, CHAINS } from '../src/index';
+import { Trigger, TRIGGERS, getTokenFromSymbol, CHAINS } from '../src/index';
 
 const DEFAULT_ADDRESS = "0x0000000000000000000000000000000000000000";
 
@@ -10,8 +10,8 @@ describe('Trigger Class', () => {
     const params = transferTrigger.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.equal(null);
+    expect(params.abi.parameters.to).to.equal(null);
     expect(params.contractAddress).to.be.null;
   });
 
@@ -20,13 +20,13 @@ describe('Trigger Class', () => {
     transferTrigger.setChainId(CHAINS.ETHEREUM);
     transferTrigger.setParams("value", 1000);
     transferTrigger.setParams("to", DEFAULT_ADDRESS);
-    transferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    transferTrigger.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
 
     const params = transferTrigger.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 a trigger as json', () => {
@@ -34,20 +34,25 @@ describe('Trigger Class', () => {
     transferTrigger.setChainId(CHAINS.ETHEREUM);
     transferTrigger.setParams("value", 1000);
     transferTrigger.setParams("to", DEFAULT_ADDRESS);
-    transferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    transferTrigger.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
 
     const json = transferTrigger.toJSON();
-    console.log(json);
+
     expect(json).to.deep.equal({
       blockId: TRIGGERS.TOKENS.ERC20.TRANSFER.blockId,
       ref: transferTrigger.getRef(),
+      id: null,
       type: 'trigger',
       parameters: {
         chainId: CHAINS.ETHEREUM,
-        'abiParams.value': 1000,
-        'abiParams.to': DEFAULT_ADDRESS,
-        'abiParams.from': null,
-        contractAddress: getToken(CHAINS.ETHEREUM, 'USDC').contractAddress
+        abi: {
+          parameters: {
+            value: 1000,
+            to: DEFAULT_ADDRESS,
+            from: null
+          }
+        },
+        contractAddress: getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress
       }
     });
   });
@@ -56,16 +61,14 @@ describe('Trigger Class', () => {
     const balanceTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.BALANCE);
     balanceTrigger.setChainId(CHAINS.ETHEREUM);
     balanceTrigger.setParams("account", DEFAULT_ADDRESS);
-    balanceTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    balanceTrigger.setContractAddress(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
     balanceTrigger.setCondition("gte");
     balanceTrigger.setComparisonValue(45000);
-    balanceTrigger.setInterval(5000);
 
     const params = balanceTrigger.getParameters();
     expect(params.chainId).to.equal(CHAINS.ETHEREUM);
-    expect(params['abiParams.account']).to.equal(DEFAULT_ADDRESS);
-    expect(params.contractAddress).to.equal(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
-    console.log(balanceTrigger.toJSON());
+    expect(params.abi.parameters.account).to.equal(DEFAULT_ADDRESS);
+    expect(params.contractAddress).to.equal(getTokenFromSymbol(CHAINS.ETHEREUM, 'USDC').contractAddress);
     expect(balanceTrigger.toJSON().parameters.condition).to.equal("gte");
     expect(balanceTrigger.toJSON().parameters.comparisonValue).to.equal(45000);
     expect(balanceTrigger.toJSON().parameters.interval).to.equal(5000);
@@ -76,7 +79,6 @@ describe('Trigger Class', () => {
 
     expect(() => transferTrigger.setCondition(">")).to.throw('Condition setting is not applicable for subscription based triggers.');
     expect(() => transferTrigger.setComparisonValue(45000)).to.throw('Comparison value setting is not applicable for subscription based triggers.');
-    expect(() => transferTrigger.setInterval(5000)).to.throw('Interval setting is not applicable for subscription based triggers.');
   });
 
   it('should throw an error for invalid parameter type', () => {
@@ -88,4 +90,72 @@ describe('Trigger Class', () => {
     const transferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
     expect(() => transferTrigger.setParams("to", "invalid_address")).to.throw('Invalid type for parameter abiParams.to. Expected address.');
   });
+
+  it('should create a trigger from JSON correctly', async () => {
+    const json = {
+      "id": "5c87bcd2-8771-417f-aab6-c23998caa9ae",
+      "ref": "n-1",
+      "blockId": 10,
+      "type": "trigger",
+      "position": {
+        "x": 0,
+        "y": 0
+      },
+      "parameters": {
+        "chainId": 34443,
+        "currency": "USD",
+        "interval": 5000,
+        "condition": "gte",
+        "comparisonValue": 3550,
+        "contractAddress": "0x4200000000000000000000000000000000000006"
+      }
+    };
+
+    const trigger = await Trigger.fromJSON(json);
+
+    expect(trigger.id).to.equal("5c87bcd2-8771-417f-aab6-c23998caa9ae");
+    expect(trigger.getRef()).to.equal("n-1");
+    expect(trigger.blockId).to.equal(10);
+    expect(trigger.getParameters().chainId).to.equal(34443);
+    expect(trigger.getParameters().currency).to.equal("USD");
+    expect(trigger.getParameters().condition).to.equal("gte");
+    expect(trigger.getParameters().comparisonValue).to.equal(3550);
+    expect(trigger.getParameters().contractAddress).to.equal("0x4200000000000000000000000000000000000006");
+    expect(trigger.getParentInfo()?.name).to.equal("ON_CHAIN_PRICE_MOVEMENT");
+    expect(trigger.toJSON()).to.deep.equal(json);
+  });
+
+  it('should create a trigger from JSON correctly - 2', async () => {
+    const json = {
+      "id": null,
+      "ref": "n-1",
+      "blockId": 1,
+      "type": "trigger",
+      "parameters": {
+        "chainId": 1,
+        "abi": {
+          "parameters": {
+            "from": null,
+            "value": "1000000n",
+            "to": "0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6"
+          }
+        },
+        "contractAddress": "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"
+      }
+    };
+
+    const trigger = await Trigger.fromJSON(json);
+
+    expect(trigger.id).to.be.null;
+    expect(trigger.getRef()).to.equal("n-1");
+    expect(trigger.blockId).to.equal(1);
+    expect(trigger.getParameters().chainId).to.equal(1);
+    expect(trigger.getParameters().abi.parameters.from).to.be.null;
+    expect(trigger.getParameters().abi.parameters.value).to.equal(BigInt(1000000));
+    expect(trigger.getParameters().abi.parameters.to).to.equal("0xe1432599B51d9BE1b5A27E2A2FB8e5dF684749C6");
+    expect(trigger.getParameters().contractAddress).to.equal("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48");
+    expect(trigger.getParentInfo()?.name).to.equal("ERC20");
+    expect(trigger.toJSON()).to.deep.equal(json);
+  });
+
 });