otomato-sdk 2.0.8 → 2.0.10

package/dist/src/constants/version.js

@@ -1,4 +1,4 @@
-export const SDK_VERSION = '2.0.8';
+export const SDK_VERSION = '2.0.10';
 export function compareVersions(v1, v2) {
     // Split the version strings into parts
     const v1Parts = v1.split('.').map(Number);

package/dist/src/index.js

@@ -22,3 +22,4 @@ export * from './services/ApiService.js';
 export * from './services/RpcServices.js';
 export * from './utils/helpers.js';
 export * from './utils/typeValidator.js';
+export * from './utils/balances/addressBalance.js';

package/dist/src/services/ApiService.js

@@ -53,10 +53,10 @@ class ApiServices {
             return yield axiosInstance.delete(url, { headers });
         });
     }
-    generateLoginPayload(address, chainId, accessCode) {
+    generateLoginPayload(address, chainId, referralCode) {
         return __awaiter(this, void 0, void 0, function* () {
             const headers = { 'Content-Type': 'application/json' };
-            const response = yield axiosInstance.post('/auth/generate-payload', { address, chainId, accessCode }, { headers });
+            const response = yield axiosInstance.post('/auth/generate-payload', { address, chainId, referralCode }, { headers });
             return response.data;
         });
     }

package/dist/src/utils/balances/addressBalance.js

@@ -0,0 +1,177 @@
+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());
+    });
+};
+// getUserProtocolBalances.ts
+import { ethers } from 'ethers';
+import { rpcServices } from '../../services/RpcServices';
+// -------------- PROTOCOLS ENUM --------------
+export const PROTOCOLS = {
+    AAVE: 'AAVE',
+    COMPOUND: 'COMPOUND',
+    IONIC: 'IONIC',
+    MOONWELL: 'MOONWELL',
+    WALLET: 'WALLET',
+};
+// Minimal ABIs
+const ERC20_ABI = [
+    'function balanceOf(address) view returns (uint256)',
+    'function decimals() view returns (uint8)',
+    'function symbol() view returns (string)',
+];
+const COMPOUNDV2_EXCHANGERATE_ABI = [
+    'function exchangeRateCurrent() view returns (uint)',
+];
+// -------------- ACTUAL MAP --------------
+const chainTokenProtocolMap = {
+    8453: {
+        // USDC on Base
+        '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913': [
+            { protocol: PROTOCOLS.AAVE, token: '0x4e65fE4DbA92790696d040ac24Aa414708F5c0AB' },
+            { protocol: PROTOCOLS.COMPOUND, token: '0xb125E6687d4313864e53df431d5425969c15Eb2F' },
+            { protocol: PROTOCOLS.IONIC, token: '0xa900A17a49Bc4D442bA7F72c39FA2108865671f0' },
+            { protocol: PROTOCOLS.MOONWELL, token: '0xEdc817A28E8B93B03976FBd4a3dDBc9f7D176c22' },
+            { protocol: PROTOCOLS.WALLET, token: '0x833589fcd6edb6e08f4c7c32d4f71b54bda02913' },
+        ],
+        // WETH on Base
+        '0x4200000000000000000000000000000000000006': [
+            { protocol: PROTOCOLS.AAVE, token: '0xd4a0e0b9149BCee3C920d2E00b5dE09138fd8bb7' },
+            { protocol: PROTOCOLS.COMPOUND, token: '0x46e6b214b524310239732D51387075E0e70970bf' },
+            { protocol: PROTOCOLS.IONIC, token: '0x49420311B518f3d0c94e897592014de53831cfA3' },
+            { protocol: PROTOCOLS.MOONWELL, token: '0x628ff693426583D9a7FB391E54366292F509D457' },
+            { protocol: PROTOCOLS.WALLET, token: '0x4200000000000000000000000000000000000006' },
+        ],
+    },
+    34443: {
+        // USDC on Mode
+        '0xd988097fb8612cc24eeC14542bC03424c656005f': [
+            { protocol: PROTOCOLS.IONIC, token: '0x2BE717340023C9e14C1Bb12cb3ecBcfd3c3fB038' },
+            { protocol: PROTOCOLS.WALLET, token: '0xd988097fb8612cc24eeC14542bC03424c656005f' },
+        ],
+        // WETH on Mode
+        '0x4200000000000000000000000000000000000006': [
+            { protocol: PROTOCOLS.IONIC, token: '0x71ef7EDa2Be775E5A7aa8afD02C45F059833e9d2' },
+            { protocol: PROTOCOLS.WALLET, token: '0x4200000000000000000000000000000000000006' },
+        ],
+    },
+};
+// -------------- EXACT getBalanceInUnderlying LOGIC --------------
+function executeReadContract(address, abi, method, params, provider) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const contract = new ethers.Contract(address, abi, provider);
+        return contract[method](...params);
+    });
+}
+/**
+ * The function that does your protocol-specific "wrapper => underlying" logic
+ * using BigInt(10) instead of 10n for older TS targets.
+ */
+function getBalanceInUnderlying(protocol, chainId, smartAccountAddress, contractAddress, balanceObj, decimals, provider) {
+    return __awaiter(this, void 0, void 0, function* () {
+        switch (protocol) {
+            case PROTOCOLS.WALLET:
+                return balanceObj.displayValue;
+            case PROTOCOLS.AAVE:
+                return balanceObj.displayValue;
+            case PROTOCOLS.COMPOUND: {
+                return balanceObj.displayValue;
+            }
+            case PROTOCOLS.IONIC:
+            case PROTOCOLS.MOONWELL: {
+                // read exchangeRateCurrent
+                const rawExRate = yield executeReadContract(contractAddress, COMPOUNDV2_EXCHANGERATE_ABI, 'exchangeRateCurrent', [], provider);
+                const exRateBN = BigInt(rawExRate.toString());
+                // For IONIC => scale = 18 - decimals + 6
+                // For MOONWELL => you used scale=18. Let's handle them with logic or keep it simple
+                let scale = 18 - decimals + 6;
+                // If MOONWELL, you said "scale=18" in your snippet
+                if (protocol === PROTOCOLS.MOONWELL) {
+                    scale = 18;
+                }
+                // Fix: BigInt(10) instead of 10n
+                const TEN = BigInt(10);
+                const divisor = TEN ** BigInt(scale);
+                const rawBalanceInAssetBN = (balanceObj.value * exRateBN) / divisor;
+                const balanceInAssetString = ethers.formatUnits(rawBalanceInAssetBN, decimals);
+                return balanceInAssetString;
+            }
+            default:
+                return balanceObj.displayValue;
+        }
+    });
+}
+// -------------- MAIN FUNCTION --------------
+export function getUserProtocolBalances(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { chainId, address, contractAddress } = params;
+        const chainMap = chainTokenProtocolMap[chainId];
+        if (!chainMap || chainId === undefined) {
+            throw new Error(`No token map for chainId=${chainId}`);
+        }
+        // If recognized => read all wrappers
+        const protocolWrappers = chainMap[contractAddress.toLowerCase()];
+        let addressesToCheck;
+        if (protocolWrappers) {
+            addressesToCheck = protocolWrappers;
+        }
+        else {
+            // fallback => just WALLET
+            addressesToCheck = [
+                {
+                    protocol: PROTOCOLS.WALLET,
+                    token: contractAddress,
+                },
+            ];
+        }
+        // Setup provider from rpcServices
+        const rpcUrl = rpcServices.getRPC(chainId);
+        const provider = new ethers.JsonRpcProvider(rpcUrl);
+        // Minimal read ABI
+        const readABI = [
+            'function balanceOf(address) view returns (uint256)',
+            'function decimals() view returns (uint8)',
+            'function symbol() view returns (string)',
+        ];
+        const results = [];
+        for (const { protocol, token } of addressesToCheck) {
+            const contract = new ethers.Contract(token, readABI, provider);
+            const [rawBalanceBN, decimals, symbol] = yield Promise.all([
+                contract.balanceOf(address),
+                contract.decimals(),
+                contract.symbol(),
+            ]);
+            const rawBalance = BigInt(rawBalanceBN.toString());
+            const displayValue = ethers.formatUnits(rawBalance, decimals);
+            // We'll guess the underlying decimals from the symbol or fallback
+            // In your snippet, you explicitly used the WALLET decimals for USDC => 6
+            let underlyingDecimals = decimals;
+            if (symbol.toLowerCase().includes('usdc')) {
+                underlyingDecimals = 6;
+            }
+            else if (symbol.toLowerCase().includes('weth') || symbol.toLowerCase().includes('eth')) {
+                underlyingDecimals = 18;
+            }
+            // Build the "balanceObj"
+            const balanceObj = {
+                value: rawBalance,
+                decimals,
+                symbol,
+                displayValue,
+            };
+            // Now do your conversion
+            const underlyingBalance = yield getBalanceInUnderlying(protocol, chainId, address, token, balanceObj, underlyingDecimals, provider);
+            results.push({
+                protocol,
+                wrapperTokenAddress: token,
+                wrapperBalance: displayValue, // raw wrapper token balance
+                underlyingBalance, // computed by getBalanceInUnderlying
+            });
+        }
+        return results;
+    });
+}

package/dist/src/utils/balances/getBalanceInUnderlying.js

@@ -0,0 +1,95 @@
+// getBalanceInUnderlying.ts
+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';
+// The protocol enumeration you already use
+export const PROTOCOLS = {
+    AAVE: 'AAVE',
+    COMPOUND: 'COMPOUND',
+    IONIC: 'IONIC',
+    MOONWELL: 'MOONWELL',
+    WALLET: 'WALLET',
+};
+// Reuse your COMPOUNDV2_EXCHANGERATE_ABI if needed
+// (exchangeRateCurrent is read-only in your snippet)
+export const COMPOUNDV2_EXCHANGERATE_ABI = [
+    'function exchangeRateCurrent() view returns (uint)',
+];
+/**
+ * A minimal "executeReadContract" helper, exactly like in your code snippet.
+ * You can import this from wherever you defined it.
+ */
+export function executeReadContract(address_1, abi_1, method_1) {
+    return __awaiter(this, arguments, void 0, function* (address, abi, method, params = [], provider) {
+        const contract = new ethers.Contract(address, abi, provider);
+        return contract[method](...params);
+    });
+}
+/**
+ * getBalanceInUnderlying:
+ * Keeps the exact logic you provided for each protocol.
+ *
+ * @param protocol - which protocol (WALLET, AAVE, COMPOUND, IONIC, MOONWELL)
+ * @param chainId - the chain you’re on (not actively used in this snippet, but kept for consistency)
+ * @param smartAccountAddress - the user’s address (passed, but your snippet only uses it for logs or COMPOUND custom calls if you expand logic)
+ * @param contractAddress - the “wrapper token” contract to read from
+ * @param balanceObj - the result from getBalanceObject (raw BigInt, decimals, displayValue, etc.)
+ * @param decimals - typically the “underlying decimals” you want to interpret. (In your code, you used the WALLET entry’s decimals for USDC.)
+ * @param provider - a JsonRpcProvider for read calls (required if you do exchangeRateCurrent).
+ *
+ * @returns a string representing the final “underlying” balance
+ */
+export function getBalanceInUnderlying(protocol, chainId, smartAccountAddress, contractAddress, balanceObj, decimals, provider) {
+    return __awaiter(this, void 0, void 0, function* () {
+        switch (protocol) {
+            // WALLET => actual USDC, 1:1 => if rawBalance = 1, then underlying = 1
+            case PROTOCOLS.WALLET: {
+                return balanceObj.displayValue;
+            }
+            // AAVE => often pegged 1:1 for typical aTokens => 1 => 1
+            case PROTOCOLS.AAVE: {
+                return balanceObj.displayValue;
+            }
+            // COMPOUND => your snippet simply logs the balanceObj and returns displayValue
+            // (If you wanted a real conversion, you could do “collateralBalanceOf” logic here)
+            case PROTOCOLS.COMPOUND: {
+                return balanceObj.displayValue;
+            }
+            // IONIC => calls “exchangeRateCurrent”, then does BigInt math
+            case PROTOCOLS.IONIC: {
+                const rawExRate = yield executeReadContract(contractAddress, COMPOUNDV2_EXCHANGERATE_ABI, 'exchangeRateCurrent', [], provider);
+                const exRateBN = BigInt(rawExRate.toString());
+                // “Suppose we do scale = 18 - decimals + 6 (typical for cTokens w/ USDC underlying).”
+                // In your snippet, “decimals” is from the WALLET token (if that’s USDC => 6).
+                const scale = 18 - decimals + 6;
+                const divisor = BigInt(10) ** BigInt(scale);
+                // cTokenBalance * exchangeRate / divisor => underlying
+                const rawBalanceInAssetBN = (balanceObj.value * exRateBN) / divisor;
+                const balanceInAssetString = ethers.formatUnits(rawBalanceInAssetBN, decimals);
+                return balanceInAssetString;
+            }
+            // MOONWELL => same logic, but you used a fixed scale=18
+            case PROTOCOLS.MOONWELL: {
+                const rawExRate = yield executeReadContract(contractAddress, COMPOUNDV2_EXCHANGERATE_ABI, 'exchangeRateCurrent', [], provider);
+                const exRateBN = BigInt(rawExRate.toString());
+                // “ALL the moonwell tokens have 8 decimals,” so you did scale=18
+                const scale = 18;
+                const divisor = BigInt(10) ** BigInt(scale);
+                const rawBalanceInAssetBN = (balanceObj.value * exRateBN) / divisor;
+                const balanceInAssetString = ethers.formatUnits(rawBalanceInAssetBN, decimals);
+                return balanceInAssetString;
+            }
+            default: {
+                // If not recognized, just return the wrapper’s displayValue
+                return balanceObj.displayValue;
+            }
+        }
+    });
+}

package/dist/src/utils/typeValidator.js

@@ -108,7 +108,7 @@ function isValidValue(value) {
     return false;
 }
 function isVariable(value) {
-    return /\{\{nodeMap\.[^.}]+\.(?:output|parameters(?:\.abi\.parameters)?)\.[^.}]+\}\}/.test(value);
+    return /\{\{(?:nodeMap\.[^.}]+\.(?:output|parameters(?:\.abi\.parameters)?)|external\.functions\.[^(}]+)\([^)]*\)\}\}/.test(value);
 }
 export function typeIsNumber(type) {
     switch (type) {

package/dist/types/examples/everyhour-ifusdc-ionic.d.ts

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

package/dist/types/examples/lending-aggregator.d.ts

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

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

@@ -1,2 +1,2 @@
-export declare const SDK_VERSION = "2.0.8";
+export declare const SDK_VERSION = "2.0.10";
 export declare function compareVersions(v1: string, v2: string): number;

package/dist/types/src/index.d.ts

@@ -19,3 +19,4 @@ export * from './services/ApiService.js';
 export * from './services/RpcServices.js';
 export * from './utils/helpers.js';
 export * from './utils/typeValidator.js';
+export * from './utils/balances/addressBalance.js';

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

@@ -6,7 +6,7 @@ declare class ApiServices {
     patch(url: string, data: any): Promise<import("axios").AxiosResponse<any, any>>;
     get(url: string): Promise<any>;
     delete(url: string): Promise<import("axios").AxiosResponse<any, any>>;
-    generateLoginPayload(address: string, chainId: number, accessCode: string): Promise<any>;
+    generateLoginPayload(address: string, chainId: number, referralCode: string): Promise<any>;
     getToken(loginPayload: any, signature: string): Promise<{
         token: any;
     }>;

package/dist/types/src/utils/balances/addressBalance.d.ts

@@ -0,0 +1,20 @@
+export declare const PROTOCOLS: {
+    readonly AAVE: "AAVE";
+    readonly COMPOUND: "COMPOUND";
+    readonly IONIC: "IONIC";
+    readonly MOONWELL: "MOONWELL";
+    readonly WALLET: "WALLET";
+};
+export type Protocol = typeof PROTOCOLS[keyof typeof PROTOCOLS];
+export interface GetUserProtocolBalancesParams {
+    chainId: number;
+    address: string;
+    contractAddress: string;
+}
+export interface ProtocolBalanceResult {
+    protocol: Protocol;
+    wrapperTokenAddress: string;
+    wrapperBalance: string;
+    underlyingBalance: string;
+}
+export declare function getUserProtocolBalances(params: GetUserProtocolBalancesParams): Promise<ProtocolBalanceResult[]>;

package/dist/types/src/utils/balances/getBalanceInUnderlying.d.ts

@@ -0,0 +1,44 @@
+import { ethers } from 'ethers';
+export declare const PROTOCOLS: {
+    readonly AAVE: "AAVE";
+    readonly COMPOUND: "COMPOUND";
+    readonly IONIC: "IONIC";
+    readonly MOONWELL: "MOONWELL";
+    readonly WALLET: "WALLET";
+};
+export declare const COMPOUNDV2_EXCHANGERATE_ABI: string[];
+/**
+ * A minimal "executeReadContract" helper, exactly like in your code snippet.
+ * You can import this from wherever you defined it.
+ */
+export declare function executeReadContract(address: string, abi: string[], method: string, params: any[] | undefined, provider: ethers.JsonRpcProvider): Promise<any>;
+/**
+ * The shape of the "balanceObj" from your code:
+ * {
+ *   value: bigint,
+ *   decimals: number,
+ *   symbol: string,
+ *   displayValue: string,
+ * }
+ */
+export interface BalanceObject {
+    value: bigint;
+    decimals: number;
+    symbol: string;
+    displayValue: string;
+}
+/**
+ * getBalanceInUnderlying:
+ * Keeps the exact logic you provided for each protocol.
+ *
+ * @param protocol - which protocol (WALLET, AAVE, COMPOUND, IONIC, MOONWELL)
+ * @param chainId - the chain you’re on (not actively used in this snippet, but kept for consistency)
+ * @param smartAccountAddress - the user’s address (passed, but your snippet only uses it for logs or COMPOUND custom calls if you expand logic)
+ * @param contractAddress - the “wrapper token” contract to read from
+ * @param balanceObj - the result from getBalanceObject (raw BigInt, decimals, displayValue, etc.)
+ * @param decimals - typically the “underlying decimals” you want to interpret. (In your code, you used the WALLET entry’s decimals for USDC.)
+ * @param provider - a JsonRpcProvider for read calls (required if you do exchangeRateCurrent).
+ *
+ * @returns a string representing the final “underlying” balance
+ */
+export declare function getBalanceInUnderlying(protocol: string, chainId: number, smartAccountAddress: string, contractAddress: string, balanceObj: BalanceObject, decimals: number, provider: ethers.JsonRpcProvider): Promise<string>;

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

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

package/package.json

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