otomato-sdk 1.5.52 → 1.5.53

package/dist/src/constants/tokens.js

@@ -1,3 +1,13 @@
+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 rpcServices from "../services/RpcServices";
 export const TOKENS = {
     1: [
         {
@@ -233,14 +243,21 @@ export const NFTS = {
     ]
 };
 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;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!(chain in TOKENS)) {
+            throw new Error(`Unsupported chain: ${chain}`);
+        }
+        let token = TOKENS[chain].find(token => token.contractAddress.toLowerCase() === contractAddress.toLowerCase());
+        if (!token) {
+            try {
+                token = yield rpcServices.getTokenDetails(chain, contractAddress);
+            }
+            catch (e) {
+                throw new Error(`Token with contract address ${contractAddress} not found on chain ${chain}`);
+            }
+        }
+        return token;
+    });
 }
 export function getTokenFromSymbol(chain, symbol) {
     if (!(chain in TOKENS)) {

package/dist/src/models/Action.js

@@ -22,7 +22,7 @@ export class Action extends Node {
                 return null;
             const permissions = SessionKeyPermission.fromJSON(parentBlock.permissions);
             permissions.fillParameters(this.getParameters());
-            permissions.fillMethod();
+            yield permissions.fillMethod();
             // Handle 'before' code for the main action
             if (parentBlock.before) {
                 yield permissions.fillBeforeVariables(parentBlock.before, this.getParameters());
@@ -54,7 +54,7 @@ export class Action extends Node {
                         if (!batchedPermissions)
                             continue;
                         batchedPermissions.fillParameters(batch.parameters); // Pass batched action parameters
-                        batchedPermissions.fillMethod();
+                        yield batchedPermissions.fillMethod();
                         // Handle 'before' code for the batched action
                         if (batchedAction.before) {
                             yield batchedPermissions.fillBeforeVariables(batchedAction.before, batch.parameters);
@@ -74,7 +74,6 @@ export class Action extends Node {
     replaceVariables(value) {
         if (typeof value === 'string') {
             return value.replace(/\{\{parameters\.(.*?)\}\}/g, (_, key) => {
-                console.log(`Looking for ${key} parameter`);
                 return this.getParameter(key) || '';
             });
         }

package/dist/src/models/SessionKeyPermission.js

@@ -102,30 +102,43 @@ export class SessionKeyPermission {
         }
     }
     fillMethod() {
-        const executeMethod = (target) => {
-            const methodPattern = /\{\{(\w+)\(([^)]+)\)\}\}/g;
-            return target.replace(methodPattern, (match, methodName, params) => {
-                const paramList = params.split(',').map((param) => param.trim());
-                switch (methodName) {
-                    case 'tokenSymbol': {
-                        const [chainId, address] = paramList;
-                        const token = getToken(parseInt(chainId, 10), address);
-                        return token ? token.symbol : match;
-                    }
-                    case 'otherTokenSymbol': {
-                        const [chainId, address] = paramList;
-                        const symbol = getDifferentToken(parseInt(chainId, 10), address);
-                        return symbol;
+        return __awaiter(this, void 0, void 0, function* () {
+            const executeMethod = (target) => __awaiter(this, void 0, void 0, function* () {
+                const methodPattern = /\{\{(\w+)\(([^)]+)\)\}\}/g;
+                // Find all matches of the pattern in the target string
+                const matches = [...target.matchAll(methodPattern)];
+                // Process each match asynchronously
+                for (const match of matches) {
+                    const [fullMatch, methodName, params] = match;
+                    const paramList = params.split(',').map((param) => param.trim());
+                    let replacement;
+                    switch (methodName) {
+                        case 'tokenSymbol': {
+                            const [chainId, address] = paramList;
+                            const token = yield getToken(parseInt(chainId, 10), address);
+                            replacement = token ? token.symbol : fullMatch;
+                            break;
+                        }
+                        case 'otherTokenSymbol': {
+                            const [chainId, address] = paramList;
+                            const symbol = yield getDifferentToken(parseInt(chainId, 10), address);
+                            replacement = symbol;
+                            break;
+                        }
+                        // Add other methods here as needed
+                        default:
+                            replacement = fullMatch; // If no method matches, leave it unchanged
                     }
-                    // Add other methods here as needed
-                    default:
-                        return match;
+                    // Replace the matched pattern with the resolved value
+                    target = target.replace(fullMatch, replacement || fullMatch);
                 }
+                return target;
             });
-        };
-        this.approvedTargets = this.approvedTargets.map(executeMethod);
-        this.label = this.label.map(executeMethod);
-        this.labelNotAuthorized = this.labelNotAuthorized.map(executeMethod);
+            // Apply executeMethod asynchronously to approvedTargets, label, and labelNotAuthorized
+            this.approvedTargets = yield Promise.all(this.approvedTargets.map(executeMethod));
+            this.label = yield Promise.all(this.label.map(executeMethod));
+            this.labelNotAuthorized = yield Promise.all(this.labelNotAuthorized.map(executeMethod));
+        });
     }
     toJSON() {
         const containsPlaceholder = this.approvedTargets.some(target => target.includes('$'));
@@ -163,10 +176,10 @@ export class SessionKeyPermission {
     }
 }
 // Helper function to get a different token
-const getDifferentToken = (chain, contractAddress) => {
+const getDifferentToken = (chain, contractAddress) => __awaiter(void 0, void 0, void 0, function* () {
     var _a;
-    const tokenSymbol = (_a = getToken(chain, contractAddress)) === null || _a === void 0 ? void 0 : _a.symbol;
+    const tokenSymbol = (_a = (yield getToken(chain, contractAddress))) === null || _a === void 0 ? void 0 : _a.symbol;
     if (!tokenSymbol || tokenSymbol !== 'WETH')
         return 'WETH';
     return 'USDT';
-};
+});

package/dist/src/services/RpcServices.js

@@ -0,0 +1,73 @@
+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';
+class RPCServices {
+    constructor() {
+        this.rpcUrls = {}; // Store the RPC URLs
+    }
+    // Function to set RPC URLs
+    setRPCs(rpcs) {
+        this.rpcUrls = Object.assign(Object.assign({}, this.rpcUrls), rpcs);
+    }
+    setRPCsFromTMS(env) {
+        if (env.MODE_HTTPS_PROVIDER) {
+            this.rpcUrls[43334] = env.MODE_HTTPS_PROVIDER; // Chain ID 43334 is for Mode network
+        }
+        if (env.INFURA_HTTPS_PROVIDER) {
+            this.rpcUrls[1] = env.INFURA_HTTPS_PROVIDER; // Chain ID 1 is for Ethereum mainnet
+        }
+    }
+    // Function to get the RPC URL for a specific chainId
+    getRPC(chainId) {
+        const rpcUrl = this.rpcUrls[chainId];
+        if (!rpcUrl) {
+            throw new Error(`No RPC URL configured for chain ID ${chainId}`);
+        }
+        return rpcUrl;
+    }
+    // Function to fetch token details from the blockchain
+    getTokenDetails(chainId, contractAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const rpcUrl = this.getRPC(chainId); // Get the RPC URL for the chain
+            // Create a provider using ethers.js
+            const provider = new ethers.JsonRpcProvider(rpcUrl);
+            // Define the contract ABI for the read-only functions (decimals, name, symbol)
+            const erc20ABI = [
+                'function decimals() view returns (uint8)',
+                'function name() view returns (string)',
+                'function symbol() view returns (string)',
+            ];
+            // Create a contract instance
+            const contract = new ethers.Contract(contractAddress, erc20ABI, provider);
+            // Fetch the decimals, name, and symbol in parallel using Promise.all
+            try {
+                const [decimals, name, symbol] = yield Promise.all([
+                    contract.decimals(),
+                    contract.name(),
+                    contract.symbol(),
+                ]);
+                const token = {
+                    contractAddress,
+                    symbol,
+                    name,
+                    decimals,
+                    image: null,
+                };
+                return token;
+            }
+            catch (error) {
+                throw new Error(`Error fetching token details: ${error.message}`);
+            }
+        });
+    }
+}
+// Export RPC services instance
+const rpcServices = new RPCServices();
+export default rpcServices;

package/dist/types/src/constants/tokens.d.ts

@@ -18,6 +18,6 @@ export interface NFTs {
     [key: number]: NFT[];
 }
 export declare const NFTS: NFTs;
-export declare function getToken(chain: number, contractAddress: string): Token;
+export declare function getToken(chain: number, contractAddress: string): Promise<Token>;
 export declare function getTokenFromSymbol(chain: number, symbol: string): Token;
 export declare function getNFT(chain: number, name: string): NFT;

package/dist/types/src/models/SessionKeyPermission.d.ts

@@ -18,7 +18,7 @@ export declare class SessionKeyPermission {
     fillParameters(params: {
         [key: string]: any;
     }): void;
-    fillMethod(): void;
+    fillMethod(): Promise<void>;
     toJSON(): {
         [key: string]: any;
     };

package/dist/types/src/services/RpcServices.d.ts

@@ -0,0 +1,14 @@
+import { Token } from '../constants/tokens';
+declare class RPCServices {
+    private rpcUrls;
+    setRPCs(rpcs: {
+        [chainId: number]: string;
+    }): void;
+    setRPCsFromTMS(env: {
+        [key: string]: string;
+    }): void;
+    getRPC(chainId: number): string;
+    getTokenDetails(chainId: number, contractAddress: string): Promise<Token>;
+}
+declare const rpcServices: RPCServices;
+export default rpcServices;

package/dist/types/test/rpcServices.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "otomato-sdk",
-  "version": "1.5.52",
+  "version": "1.5.53",
   "description": "An SDK for building and managing automations on Otomato",
   "main": "dist/src/index.js",
   "types": "dist/types/src/index.d.ts",