otomato-sdk 1.0.0

package/src/constants/ActionBlocks.ts

@@ -0,0 +1,324 @@
+import { Parameter } from '../models/Parameter.js';
+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: "int",
+            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"
+          }
+        ] as Parameter[]
+      },
+      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: "int",
+            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"
+          },
+        ] as Parameter[],
+      }
+    },
+  },
+  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"
+          }
+        ] as Parameter[]
+      },
+      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"
+          }
+        ] as Parameter[]
+      },
+      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"
+          }
+        ] as Parameter[]
+      },
+      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
+            ]
+          }
+        ] as Parameter[]
+      }
+    }
+  },
+  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"
+          }
+        ] as Parameter[]
+      }
+    }
+  },
+  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"
+          }
+        ] as Parameter[]
+      }
+    }
+  },
+  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"
+          }
+        ] as Parameter[]
+      }
+    }
+  }
+};

package/src/constants/chains.ts

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

package/src/constants/tokens.ts

@@ -0,0 +1,97 @@
+export interface Token {
+  contractAddress: string;
+  name: string;
+  symbol: string;
+  decimals: number;
+}
+
+export interface Tokens {
+  [key: number]: Token[];
+}
+
+export const TOKENS: Tokens = {
+  1: [
+    {
+      contractAddress: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+      name: "USDC",
+      symbol: "USDC",
+      decimals: 6
+    },
+  ],
+  43334: [
+    {
+      contractAddress: "0x0000000000000000000000000000000000000000",
+      name: "ETH",
+      symbol: "ETH",
+      decimals: 18
+    },
+    {
+      contractAddress: "0xd988097fb8612cc24eeC14542bC03424c656005f",
+      name: "USDC",
+      symbol: "USDC",
+      decimals: 6
+    },
+    {
+      contractAddress: '0xcDd475325D6F564d27247D1DddBb0DAc6fA0a5CF',
+      symbol: 'WBTC',
+      name: 'Wrapped BTC',
+      decimals: 8
+    },
+    {
+      contractAddress: '0xf0F161fDA2712DB8b566946122a5af183995e2eD',
+      symbol: 'USDT',
+      name: 'USDT',
+      decimals: 6
+    },
+    {
+      contractAddress: '0xDfc7C877a950e49D2610114102175A06C2e3167a',
+      symbol: 'MODE',
+      name: 'Mode',
+      decimals: 18
+    },
+    {
+      contractAddress: '0x71ef7EDa2Be775E5A7aa8afD02C45F059833e9d2',
+      symbol: 'ionWETH',
+      name: 'Ionic Wrapped Ether',
+      decimals: 18
+    },
+    {
+      contractAddress: '0x4200000000000000000000000000000000000006',
+      symbol: 'WETH',
+      name: 'Wrapped Ether',
+      decimals: 18
+    },
+    {
+      contractAddress: '0x59e710215d45F584f44c0FEe83DA6d43D762D857',
+      symbol: 'ionezETH',
+      name: 'Ionic Renzo Restaked ETH',
+      decimals: 18
+    },
+    {
+      contractAddress: '0x2416092f143378750bb29b79eD961ab195CcEea5',
+      symbol: 'ezETH',
+      name: 'Renzo Restaked ETH',
+      decimals: 18
+    },
+    {
+      contractAddress: '0x9c29a8eC901DBec4fFf165cD57D4f9E03D4838f7',
+      symbol: 'ironETH',
+      name: 'Ironclad ETH',
+      decimals: 18
+    },
+  ]
+};
+
+export function getToken(chain: number, symbol: string): Token {
+  if (!(chain in TOKENS)) {
+    throw new Error(`Unsupported chain: ${chain}`);
+  }
+
+  const token = TOKENS[chain].find(token => token.symbol === symbol);
+
+  if (!token) {
+    throw new Error(`Token ${symbol} not found on chain ${chain}`);
+  }
+
+  return token;
+}

package/src/index.ts

@@ -0,0 +1,15 @@
+// Exporting constants
+export * from './constants/ActionBlocks.js';
+export * from './constants/chains.js';
+export * from './constants/tokens.js';
+
+// Exporting models
+export * from './models/Action.js';
+export * from './models/Automation.js';
+export * from './models/Condition.js';
+export * from './models/Parameter.js';
+export * from './models/Trigger.js';
+
+// Exporting services
+export * from './services/ApiService.js';
+export * from './services/AutomationService.js';

package/src/models/Action.ts

@@ -0,0 +1,6 @@
+export interface Action {
+    key: string;
+    type: string;
+    description: string;
+    value: any;
+  }

package/src/models/Automation.ts

@@ -0,0 +1,6 @@
+export interface Automation {
+    key: string;
+    type: string;
+    description: string;
+    value: any;
+  }

package/src/models/Condition.ts

@@ -0,0 +1,6 @@
+export interface COndition {
+    key: string;
+    type: string;
+    description: string;
+    value: any;
+  }

package/src/models/Parameter.ts

@@ -0,0 +1,6 @@
+export interface Parameter {
+    key: string;
+    type: string;
+    description: string;
+    value: any;
+  }

package/src/models/Trigger.ts

@@ -0,0 +1,128 @@
+import { Parameter } from './Parameter.js';
+import { ethers } from 'ethers';
+
+export class Trigger {
+  id: number;
+  name: string;
+  description: string;
+  type: number;
+  parameters: { [key: string]: Parameter };
+  keyMap: { [key: string]: string };
+
+  constructor(trigger: { id: number; name: string; description: string; type: number; parameters: Parameter[] }) {
+    this.id = trigger.id;
+    this.name = trigger.name;
+    this.description = trigger.description;
+    this.type = trigger.type;
+    this.parameters = {};
+    this.keyMap = {};
+    trigger.parameters.forEach(param => {
+      this.parameters[param.key] = { ...param, value: null };
+      const simplifiedKey = this.getSimplifiedKey(param.key);
+      this.keyMap[simplifiedKey] = param.key;
+    });
+  }
+
+  setChainId(value: number): void {
+    this.setParameter('chainId', value);
+  }
+
+  setContractAddress(value: string): void {
+    this.setParameter('contractAddress', value);
+  }
+
+  setCondition(value: string): void {
+    if (this.type !== 1) {
+      throw new Error('Condition setting is not applicable for subscription based triggers.');
+    }
+    this.setParameter('condition', value);
+  }
+
+  setComparisonValue(value: number): void {
+    if (this.type !== 1) {
+      throw new Error('Comparison value setting is not applicable for subscription based triggers.');
+    }
+    this.setParameter('comparisonValue', value);
+  }
+
+  setInterval(value: number): void {
+    if (this.type !== 1) {
+      throw new Error('Interval setting is not applicable for subscription based triggers.');
+    }
+    this.setParameter('interval', value);
+  }
+
+  setParams(key: string, value: any): void {
+    const fullKey = `abiParams.${key}`;
+    if (fullKey in this.parameters) {
+      this.setParameter(fullKey, value);
+    } else {
+      throw new Error(`Parameter with simplified key ${key} not found in abiParams`);
+    }
+  }
+
+  private setParameter(key: string, value: any): void {
+    if (key in this.parameters) {
+      const param = this.parameters[key];
+      if (this.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`);
+    }
+  }
+
+  private validateType(expectedType: string, value: any): boolean {
+    switch (expectedType) {
+      case 'int':
+      case 'integer':
+      case 'uint256':
+      case 'int256':
+        return Number.isInteger(value);
+      case 'address':
+        return typeof value === 'string' && this.isAddress(value);
+      case 'float':
+        return typeof value === 'number';
+      case 'logic_operator':
+        const validOperators = new Set(['<', '>', '<=', '>=', '==']);
+        return typeof value === 'string' && validOperators.has(value);
+      case 'any':
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  private isAddress(value: string): boolean {
+    return ethers.isAddress(value);
+  }
+
+  getParameter(key: string): any {
+    if (key in this.parameters) {
+      return this.parameters[key].value;
+    } else {
+      throw new Error(`Parameter with key ${key} not found`);
+    }
+  }
+
+  getParameters(): { [key: string]: any } {
+    return Object.keys(this.parameters).reduce((acc, key) => {
+      acc[key] = this.parameters[key].value;
+      return acc;
+    }, {} as { [key: string]: any });
+  }
+
+  toJSON(): { [key: string]: any } {
+    const json: { [key: string]: any } = {
+      id: this.id,
+      parameters: this.getParameters(),
+    };
+    return json;
+  }
+
+  private getSimplifiedKey(key: string): string {
+    return key.replace(/[.\[\]]/g, '_');
+  }
+}

package/src/services/ApiService.ts

@@ -0,0 +1,6 @@
+export interface APISERVICES {
+    key: string;
+    type: string;
+    description: string;
+    value: any;
+  }

package/src/services/AutomationService.ts

@@ -0,0 +1,6 @@
+export interface AUTOSERVICES {
+    key: string;
+    type: string;
+    description: string;
+    value: any;
+  }