otomato-sdk 1.0.1 → 1.1.0

package/dist/examples/create-action.js

@@ -0,0 +1,21 @@
+import { ACTIONS, getToken, 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());
+    // Create an SMS notification action
+    const smsAction = new Action(ACTIONS.NOTIFICATIONS.SMS);
+    smsAction.setParams("phoneNumber", "+1234567890");
+    smsAction.setParams("text", "This is a test message");
+    console.log(smsAction.toJSON());
+    // Create a Slack notification action
+    const slackAction = new Action(ACTIONS.NOTIFICATIONS.SLACK);
+    slackAction.setParams("webhook", "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX");
+    slackAction.setParams("text", "This is a test message");
+    console.log(slackAction.toJSON());
+};
+createAction();

package/dist/examples/create-automation.js

@@ -0,0 +1,24 @@
+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 { ACTIONS, Action, TRIGGERS, Trigger, Automation, CHAINS, getToken } from '../src/index.js';
+const main = () => __awaiter(void 0, void 0, void 0, function* () {
+    const usdcTransferTrigger = new Trigger(TRIGGERS.TOKENS.ERC20.TRANSFER);
+    usdcTransferTrigger.setChainId(CHAINS.ETHEREUM);
+    usdcTransferTrigger.setContractAddress(getToken(CHAINS.ETHEREUM, 'USDC').contractAddress);
+    usdcTransferTrigger.setCoordinates(0, 0);
+    const slackAction = new Action(ACTIONS.NOTIFICATIONS.SLACK);
+    slackAction.setParams("webhook", "https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX");
+    slackAction.setParams("text", "USDC has been transferred!");
+    slackAction.setCoordinates(0, -10);
+    const automation = new Automation("USDC Transfer Notification", usdcTransferTrigger, [slackAction]);
+    console.log(JSON.stringify(automation.toJSON(), null, 2));
+    yield automation.save();
+});
+main();

package/dist/src/constants/Blocks.js

@@ -0,0 +1,391 @@
+import { CHAINS } from './chains.js';
+const TRIGGER_TYPE = {
+    SUBSCRIPTION: 0,
+    POLLING: 1,
+};
+export const TRIGGERS = {
+    TOKENS: {
+        ERC20: {
+            CHAINS: [CHAINS.ALL],
+            TRANSFER: {
+                id: 1,
+                name: "Transfer token",
+                description: "Transfer an ERC-20 token",
+                type: TRIGGER_TYPE.SUBSCRIPTION,
+                parameters: [
+                    {
+                        key: "chainId",
+                        type: "chainId",
+                        description: "Chain ID of the ETH blockchain"
+                    },
+                    {
+                        key: "abiParams.value",
+                        type: "uint256",
+                        description: "Amount of crypto to transfer"
+                    },
+                    {
+                        key: "abiParams.to",
+                        type: "address",
+                        description: "Address to transfer crypto to"
+                    },
+                    {
+                        key: "contractAddress",
+                        type: "address",
+                        description: "The contract address of the ERC20"
+                    }
+                ]
+            },
+            BALANCE: {
+                id: 1000,
+                name: "ERC20 balance check",
+                description: "Fetches the balance of an ERC20 and checks it against the specified condition.",
+                type: TRIGGER_TYPE.POLLING,
+                parameters: [
+                    {
+                        key: "chainId",
+                        type: "chainId",
+                        description: "Chain ID of the ETH blockchain"
+                    },
+                    {
+                        key: "abiParams.account",
+                        type: "address",
+                        description: "Amount of crypto to transfer"
+                    },
+                    {
+                        key: "contractAddress",
+                        type: "address",
+                        description: "The contract address of the ERC20"
+                    },
+                    {
+                        key: "condition",
+                        type: "logic_operator",
+                        description: "Logic operator used for the comparison: <, >, <=, >=, ==, ..."
+                    },
+                    // todo: it should be in the same type as the output of the function
+                    {
+                        key: "comparisonValue",
+                        type: "any",
+                        description: "The value to compare to"
+                    },
+                    {
+                        key: "interval",
+                        type: "integer",
+                        description: "The waiting time between each polling"
+                    },
+                ],
+            }
+        },
+    },
+    YIELD: {
+        SPLICE_FI: {
+            CHAINS: [CHAINS.MODE],
+            SWAP: {
+                id: 2,
+                name: "Splice Finance Swap",
+                description: "Swap in Splice Finance",
+                type: TRIGGER_TYPE.SUBSCRIPTION,
+                parameters: [
+                    {
+                        key: "abiParams.caller",
+                        type: "address",
+                        description: "Caller address"
+                    },
+                    {
+                        key: "abiParams.market",
+                        type: "address",
+                        description: "Market address"
+                    },
+                    {
+                        key: "abiParams.receiver",
+                        type: "address",
+                        description: "Receiver address"
+                    },
+                    {
+                        key: "abiParams.netPtToAccount",
+                        type: "int256",
+                        description: "Net PT to account"
+                    },
+                    {
+                        key: "abiParams.netSyToAccount",
+                        type: "int256",
+                        description: "Net SY to account"
+                    }
+                ]
+            },
+            LIQUIDITY_REMOVED: {
+                id: 6,
+                name: "Liquidity Removed",
+                description: "Liquidity removed in Splice Finance",
+                type: TRIGGER_TYPE.SUBSCRIPTION,
+                parameters: [
+                    {
+                        key: "abiParams.caller",
+                        type: "address",
+                        description: "Caller address"
+                    },
+                    {
+                        key: "abiParams.market",
+                        type: "address",
+                        description: "Market address"
+                    },
+                    {
+                        key: "abiParams.receiver",
+                        type: "address",
+                        description: "Receiver address"
+                    },
+                    {
+                        key: "abiParams.netLpToRemove",
+                        type: "uint256",
+                        description: "Net LP to remove"
+                    },
+                    {
+                        key: "abiParams.netPtOut",
+                        type: "uint256",
+                        description: "Net PT out"
+                    },
+                    {
+                        key: "abiParams.netSyOut",
+                        type: "uint256",
+                        description: "Net SY out"
+                    }
+                ]
+            },
+            MARKET_CREATION: {
+                id: 7,
+                name: "Market Creation",
+                description: "Market creation in Splice Finance",
+                type: TRIGGER_TYPE.SUBSCRIPTION,
+                parameters: [
+                    {
+                        key: "abiParams.market",
+                        type: "address",
+                        description: "Market address"
+                    },
+                    {
+                        key: "abiParams.PT",
+                        type: "address",
+                        description: "PT address"
+                    },
+                    {
+                        key: "abiParams.scalarRoot",
+                        type: "int256",
+                        description: "Scalar root"
+                    },
+                    {
+                        key: "abiParams.initialAnchor",
+                        type: "int256",
+                        description: "Initial anchor"
+                    },
+                    {
+                        key: "abiParams.lnFeeRateRoot",
+                        type: "uint256",
+                        description: "LN fee rate root"
+                    }
+                ]
+            },
+            INTEREST_RATE_UPDATE: {
+                id: 9,
+                name: "Interest Rate Update",
+                description: "Interest rate update in Splice Finance",
+                type: TRIGGER_TYPE.SUBSCRIPTION,
+                parameters: [
+                    {
+                        key: "abiParams.timestamp",
+                        type: "uint256",
+                        description: "Timestamp"
+                    },
+                    {
+                        key: "abiParams.lastLnImpliedRate",
+                        type: "int256",
+                        description: "Last LN implied rate"
+                    },
+                    {
+                        key: "contractAddress",
+                        type: "address",
+                        description: "Contract address to monitor",
+                        enum: [
+                            "0xDE95511418EBD8Bd36294B11C86314DdFA50e212", // wrsETH
+                            "0x34cf9BF641bd5f34197060A3f3478a1f97f78f0a", // ezETH
+                            "0xb950A73Ea0842B0Cd06D0e369aE974799BB346f1", // MODE
+                            "0xbF14932e1A7962C77D0b31be80075936bE1A43D4" // weETH
+                        ]
+                    }
+                ]
+            }
+        }
+    },
+    LENDING: {
+        ASTARIA: {
+            CHAINS: [CHAINS.MODE],
+            LEND_RECALLED: {
+                id: 8,
+                name: "Lend Recalled",
+                description: "Lend recalled in Astaria",
+                type: TRIGGER_TYPE.SUBSCRIPTION,
+                parameters: [
+                    {
+                        key: "abiParams.loanId",
+                        type: "uint256",
+                        description: "Loan ID"
+                    },
+                    {
+                        key: "abiParams.recaller",
+                        type: "address",
+                        description: "Recaller address"
+                    },
+                    {
+                        key: "abiParams.end",
+                        type: "uint256",
+                        description: "End time"
+                    }
+                ]
+            }
+        }
+    },
+    DEXES: {
+        ODOS: {
+            CHAINS: [CHAINS.MODE, CHAINS.ETHEREUM],
+            SWAP: {
+                id: 4,
+                name: "Odos Swap",
+                description: "Swap on Odos",
+                type: TRIGGER_TYPE.SUBSCRIPTION,
+                parameters: [
+                    {
+                        key: "chainId",
+                        type: "int",
+                        description: "Chain ID of the ETH blockchain"
+                    },
+                    {
+                        key: "abiParams.sender",
+                        type: "address",
+                        description: "Sender address"
+                    },
+                    {
+                        key: "abiParams.inputAmount",
+                        type: "uint256",
+                        description: "Input amount"
+                    },
+                    {
+                        key: "abiParams.inputToken",
+                        type: "address",
+                        description: "Input token address"
+                    },
+                    {
+                        key: "abiParams.amountOut",
+                        type: "uint256",
+                        description: "Output amount"
+                    },
+                    {
+                        key: "abiParams.outputToken",
+                        type: "address",
+                        description: "Output token address"
+                    },
+                    {
+                        key: "abiParams.exchangeRate",
+                        type: "float",
+                        description: "Exchange rate"
+                    }
+                ]
+            }
+        }
+    },
+    SOCIALS: {
+        MODE_NAME_SERVICE: {
+            CHAINS: [CHAINS.MODE],
+            NAME_REGISTERED: {
+                id: 3,
+                name: "Name Registered",
+                description: "Name registered in Mode Name Service",
+                type: TRIGGER_TYPE.SUBSCRIPTION,
+                parameters: [
+                    {
+                        key: "abiParams.id",
+                        type: "uint256",
+                        description: "ID of the name registered"
+                    },
+                    {
+                        key: "abiParams.owner",
+                        type: "address",
+                        description: "Owner address"
+                    },
+                    {
+                        key: "abiParams.expires",
+                        type: "uint256",
+                        description: "Expiration time"
+                    }
+                ]
+            }
+        }
+    }
+};
+export const ACTIONS = {
+    TOKENS: {
+        ERC20: {
+            CHAINS: [CHAINS.ALL],
+            TRANSFER: {
+                id: 1,
+                name: "Transfer ERC-20 Token",
+                description: "Transfer an ERC-20 token",
+                parameters: [
+                    {
+                        key: "chainId",
+                        type: "chainId",
+                        description: "Chain ID of the blockchain"
+                    },
+                    {
+                        key: "abiParams.value",
+                        type: "uint256",
+                        description: "Amount of crypto to transfer"
+                    },
+                    {
+                        key: "abiParams.to",
+                        type: "address",
+                        description: "Address to transfer crypto to"
+                    },
+                    {
+                        key: "contractAddress",
+                        type: "address",
+                        description: "The contract address of the ERC-20 token"
+                    }
+                ]
+            },
+        },
+    },
+    NOTIFICATIONS: {
+        SMS: {
+            id: 3,
+            name: "Send SMS",
+            description: "Send an SMS notification to a specified phone number",
+            parameters: [
+                {
+                    key: "phoneNumber",
+                    type: "phone_number",
+                    description: "Phone number to send the message to"
+                },
+                {
+                    key: "text",
+                    type: "paragraph",
+                    description: "Content of the SMS message"
+                },
+            ]
+        },
+        SLACK: {
+            id: 4,
+            name: "Send Slack Message",
+            description: "Send a message to a specified Slack channel via webhook",
+            parameters: [
+                {
+                    key: "webhook",
+                    type: "url",
+                    description: "Slack channel webhook URL"
+                },
+                {
+                    key: "text",
+                    type: "paragraph",
+                    description: "Content of the Slack message"
+                },
+            ]
+        },
+    }
+};

package/dist/src/constants/tokens.js

@@ -70,6 +70,36 @@ export const TOKENS = {
         },
     ]
 };
+export const NFTS = {
+    1: [
+        {
+            contractAddress: "0x60e4d786628fea6478f785a6d7e704777c86a7c6",
+            name: "MutantApeYachtClub"
+        },
+        {
+            contractAddress: "0xbc4ca0eda7647a8ab7c2061c2e118a18a936f13d",
+            name: "BoredApeYachtClub"
+        },
+        {
+            contractAddress: "0xbd3531da5cf5857e7cfaa92426877b022e612cf8",
+            name: "Pudgy Penguins"
+        },
+        {
+            contractAddress: "0x8a90cab2b38dba80c64b7734e58ee1db38b8992e",
+            name: "Doodles"
+        },
+        {
+            contractAddress: "0x524cab2ec69124574082676e6f654a18df49a048",
+            name: "Lil Pudgies"
+        },
+    ],
+    43334: [
+        {
+            contractAddress: "0x2ad86eeec513ac16804bb05310214c3fd496835b",
+            name: "Space id"
+        }
+    ]
+};
 export function getToken(chain, symbol) {
     if (!(chain in TOKENS)) {
         throw new Error(`Unsupported chain: ${chain}`);
@@ -80,3 +110,13 @@ export function getToken(chain, symbol) {
     }
     return token;
 }
+export function getNFT(chain, name) {
+    if (!(chain in NFTS)) {
+        throw new Error(`Unsupported chain: ${chain}`);
+    }
+    const nft = NFTS[chain].find(nft => nft.name === name);
+    if (!nft) {
+        throw new Error(`NFT ${name} not found on chain ${chain}`);
+    }
+    return nft;
+}

package/dist/src/index.js

@@ -1,5 +1,5 @@
 // Exporting constants
-export * from './constants/ActionBlocks.js';
+export * from './constants/Blocks.js';
 export * from './constants/chains.js';
 export * from './constants/tokens.js';
 // Exporting models
@@ -8,6 +8,6 @@ export * from './models/Automation.js';
 export * from './models/Condition.js';
 export * from './models/Parameter.js';
 export * from './models/Trigger.js';
+export * from './models/Node.js';
 // Exporting services
 export * from './services/ApiService.js';
-export * from './services/AutomationService.js';

package/dist/src/models/Action.js

@@ -1 +1,6 @@
-export {};
+import { Node } from './Node.js';
+export class Action extends Node {
+    constructor(action) {
+        super(action);
+    }
+}

package/dist/src/models/Automation.js

@@ -1 +1,38 @@
-export {};
+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 { apiServices } from '../services/ApiService.js';
+export class Automation {
+    constructor(name, trigger, actions = []) {
+        this.name = name;
+        this.trigger = trigger;
+        this.actions = actions;
+    }
+    setName(name) {
+        this.name = name;
+    }
+    addTrigger(trigger) {
+        this.trigger = trigger;
+    }
+    addAction(action) {
+        this.actions.push(action);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            trigger: this.trigger.toJSON(),
+            actions: this.actions.map(action => action.toJSON()),
+        };
+    }
+    save() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return apiServices.post('/workflows', this.toJSON());
+        });
+    }
+}

package/dist/src/models/Node.js

@@ -0,0 +1,73 @@
+import { validateType } from '../utils/typeValidator.js';
+export class Node {
+    constructor(node) {
+        this.id = node.id;
+        this.name = node.name;
+        this.description = node.description;
+        this.parameters = {};
+        this.keyMap = {};
+        node.parameters.forEach(param => {
+            this.parameters[param.key] = Object.assign(Object.assign({}, param), { value: null });
+            const simplifiedKey = this.getSimplifiedKey(param.key);
+            this.keyMap[simplifiedKey] = param.key;
+        });
+        this.x = node.x;
+        this.y = node.y;
+    }
+    setChainId(value) {
+        this.setParameter('chainId', value);
+    }
+    setContractAddress(value) {
+        this.setParameter('contractAddress', value);
+    }
+    setParams(key, value) {
+        const fullKey = this.parameters[`abiParams.${key}`] ? `abiParams.${key}` : key;
+        this.setParameter(fullKey, value);
+    }
+    setCoordinates(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+    setParameter(key, value) {
+        if (key in this.parameters) {
+            const param = this.parameters[key];
+            if (validateType(param.type, value)) {
+                this.parameters[key].value = value;
+            }
+            else {
+                throw new Error(`Invalid type for parameter ${key}. Expected ${param.type}.`);
+            }
+        }
+        else {
+            throw new Error(`Parameter with key ${key} not found`);
+        }
+    }
+    getParameter(key) {
+        if (key in this.parameters) {
+            return this.parameters[key].value;
+        }
+        else {
+            throw new Error(`Parameter with key ${key} not found`);
+        }
+    }
+    getParameters() {
+        return Object.keys(this.parameters).reduce((acc, key) => {
+            acc[key] = this.parameters[key].value;
+            return acc;
+        }, {});
+    }
+    toJSON() {
+        const json = {
+            id: this.id,
+            parameters: this.getParameters(),
+        };
+        if (this.x !== undefined)
+            json.x = this.x;
+        if (this.y !== undefined)
+            json.y = this.y;
+        return json;
+    }
+    getSimplifiedKey(key) {
+        return key.replace(/[.\[\]]/g, '_');
+    }
+}