@raac/rpc 1.1.0-beta.53 → 1.1.0-beta.55

package/dist/RPCLibrary.js

@@ -120,6 +120,7 @@ const vaultOpened_1 = __importDefault(require("./pools/lendingPool/vaultOpened")
 const getWithdrawRequestInfo_2 = require("./pools/stabilityPool/getWithdrawRequestInfo");
 const requestWithdraw_2 = require("./pools/stabilityPool/requestWithdraw");
 const artifacts_1 = require("./utils/artifacts");
+const errorDecoder_1 = require("./utils/errorDecoder");
 class RPCLibrary {
     signer;
     isConnected;
@@ -139,6 +140,7 @@ class RPCLibrary {
     checkAllowance;
     getChainsConfig;
     setChainsConfig;
+    errors;
     constructor(privateKey) {
         this.signer = null;
         this.isConnected = false;
@@ -282,6 +284,13 @@ class RPCLibrary {
             createZeno: createZeno_1.default,
             getZenos: getZenos_1.default,
         };
+        this.errors = {
+            decodeErrorName: errorDecoder_1.decodeErrorName,
+            getErrorInfo: errorDecoder_1.getErrorInfo,
+            attachDecodedError: errorDecoder_1.attachDecodedError,
+            decodeErrorMessage: errorDecoder_1.decodeErrorMessage,
+            attachDecodedErrorMessage: errorDecoder_1.attachDecodedErrorMessage,
+        };
     }
     async getWallet(privateKey, provider) {
         // @ts-ignore

package/dist/pools/lendingPool/depositToLendingPool.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const _helpers_1 = require("./_helpers");
+const errorDecoder_1 = require("../../utils/errorDecoder");
 // checked
 async function depositToLendingPool(chainId, amount, signer) {
     if (!signer) {
@@ -22,7 +23,8 @@ async function depositToLendingPool(chainId, amount, signer) {
     }
     catch (error) {
         console.error(`Lending Pool Deposit error:`, error);
-        throw new Error(`Lending Pool Deposit failed: ${error.message}`);
+        const message = (0, errorDecoder_1.attachDecodedError)("Lending Pool Deposit failed", error);
+        throw new Error(`${message}: ${error.message}`);
     }
 }
 exports.default = depositToLendingPool;

package/dist/scripts/generateErrorMap.js

@@ -0,0 +1,180 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ethers_1 = require("ethers");
+// Custom error messages based on error names
+const ERROR_MESSAGES = {
+    // Access Control
+    'AccessControlBadConfirmation': 'Invalid access control confirmation',
+    'AccessControlUnauthorizedAccount': 'Account does not have required permissions',
+    'AccessDenied': 'Access denied - insufficient permissions',
+    // Adapter Errors
+    'AdapterAlreadySupported': 'This adapter is already supported',
+    'AdapterNotSupported': 'This adapter is not supported',
+    // Address Errors
+    'AddressCannotBeZero': 'Address cannot be zero',
+    'AddressEmptyCode': 'Target address has no code',
+    'AddressInsufficientBalance': 'Insufficient balance for operation',
+    // Amount Errors
+    'AmountDifferentThanRequested': 'Amount differs from requested amount',
+    'ApprovalFailed': 'Token approval failed',
+    // Compliance
+    'BlacklistedAddress': 'Address is blacklisted',
+    // Pool Errors
+    'BorrowCapReached': 'Borrow cap has been reached',
+    'BorrowThresholdTooHigh': 'Borrow threshold is too high',
+    'CannotBorrowUnderLiquidation': 'Cannot borrow while under liquidation',
+    'CannotDepositWhenUnderLiquidation': 'Cannot deposit while under liquidation',
+    'CannotRepayUnderLiquidationWithoutInsurance': 'Cannot repay under liquidation without insurance',
+    'CannotWithdrawInSameBlock': 'Cannot withdraw in the same block',
+    'CannotWithdrawUnderLiquidation': 'Cannot withdraw while under liquidation',
+    'CapExceedSupply': 'Cap exceeds available supply',
+    'CapZero': 'Cap cannot be zero',
+    'DebtNotZero': 'Debt must be zero for this operation',
+    'SupplyCapReached': 'Supply cap has been reached',
+    // Pause Errors
+    'EnforcedPause': 'Contract is paused',
+    'ExpectedPause': 'Contract should be paused',
+    // General Errors
+    'FailedInnerCall': 'Internal call failed',
+    'GracePeriodExpired': 'Grace period has expired',
+    'InsufficientAllowance': 'Insufficient allowance for operation',
+    'InsufficientBalance': 'Insufficient balance for operation',
+    'InvalidAmount': 'Invalid amount provided',
+    'InvalidCollateralRatio': 'Invalid collateral ratio',
+    'InvalidHealthFactor': 'Invalid health factor',
+    'InvalidLiquidationThreshold': 'Invalid liquidation threshold',
+    'InvalidParameter': 'Invalid parameter provided',
+    'InvalidPrice': 'Invalid price provided',
+    'InvalidToken': 'Invalid token address',
+    'LiquidationNotAllowed': 'Liquidation is not allowed',
+    'NoLiquidationAvailable': 'No liquidation available',
+    'NotEnoughLiquidity': 'Not enough liquidity available',
+    'OperationNotAllowed': 'Operation is not allowed',
+    'Overflow': 'Arithmetic overflow occurred',
+    'Paused': 'Contract is paused',
+    'ReentrancyGuardReentrantCall': 'Reentrant call detected',
+    'ReserveAlreadyInitialized': 'Reserve is already initialized',
+    'ReserveNotActive': 'Reserve is not active',
+    'ReserveNotInitialized': 'Reserve is not initialized',
+    'SafeERC20FailedOperation': 'SafeERC20 operation failed',
+    'TransferFailed': 'Token transfer failed',
+    'Unauthorized': 'Unauthorized operation',
+    'Underflow': 'Arithmetic underflow occurred',
+    'VaultNotOpen': 'Vault is not open',
+    'WithdrawalNotAllowed': 'Withdrawal is not allowed',
+    // Custom contract-specific errors
+    'InvalidOraclePrice': 'Invalid oracle price received',
+    'PriceStale': 'Oracle price is stale',
+    'InvalidRandomSeed': 'Invalid random seed provided',
+    'RandomSeedNotReady': 'Random seed is not ready',
+    'NFTNotAvailable': 'NFT is not available',
+    'InvalidNFTId': 'Invalid NFT ID provided',
+    'NFTAlreadyDeposited': 'NFT is already deposited',
+    'NFTNotDeposited': 'NFT is not deposited',
+    'InvalidVaultPosition': 'Invalid vault position',
+    'PositionNotOpen': 'Position is not open',
+    'InvalidCollateral': 'Invalid collateral provided',
+    'CollateralNotSupported': 'Collateral is not supported',
+    'InvalidDebtToken': 'Invalid debt token',
+    'DebtTokenNotSupported': 'Debt token is not supported',
+    'InvalidLiquidationProxy': 'Invalid liquidation proxy',
+    'InvalidVaultProxy': 'Invalid vault proxy',
+    'InvalidComplianceRegistry': 'Invalid compliance registry',
+    'InvalidPrimeRate': 'Invalid prime rate',
+    'InvalidAdmin': 'Invalid admin address',
+    'InvalidReserveAsset': 'Invalid reserve asset',
+    'InvalidRToken': 'Invalid R token',
+    'InvalidDebtTokenAddress': 'Invalid debt token address',
+    'InvalidLiquidationProxyAddress': 'Invalid liquidation proxy address',
+    'InvalidVaultProxyAddress': 'Invalid vault proxy address',
+    'InvalidComplianceRegistryAddress': 'Invalid compliance registry address',
+    'InvalidInitialPrimeRate': 'Invalid initial prime rate',
+    'InvalidAdminAddress': 'Invalid admin address',
+};
+function walkDir(dir) {
+    const files = [];
+    const items = fs_1.default.readdirSync(dir, { withFileTypes: true });
+    for (const item of items) {
+        const fullPath = path_1.default.join(dir, item.name);
+        if (item.isDirectory()) {
+            files.push(...walkDir(fullPath));
+        }
+        else if (item.name.endsWith('.json')) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function generateErrorMap() {
+    const errorMap = {};
+    const artifactsDir = path_1.default.join(process.cwd(), 'artifacts');
+    if (!fs_1.default.existsSync(artifactsDir)) {
+        console.error('Artifacts directory not found');
+        process.exit(1);
+    }
+    const jsonFiles = walkDir(artifactsDir);
+    for (const filePath of jsonFiles) {
+        try {
+            const content = fs_1.default.readFileSync(filePath, 'utf8');
+            const json = JSON.parse(content);
+            if (!json.abi || !Array.isArray(json.abi))
+                continue;
+            const contractName = json.contractName || path_1.default.basename(filePath, '.json');
+            for (const item of json.abi) {
+                if (item.type !== 'error')
+                    continue;
+                const inputs = item.inputs || [];
+                const signature = `${item.name}(${inputs.map((input) => input.type).join(',')})`;
+                const selector = (0, ethers_1.id)(signature).slice(0, 10).toLowerCase();
+                // Skip if already processed (first occurrence wins)
+                if (errorMap[selector])
+                    continue;
+                const customMessage = ERROR_MESSAGES[item.name] ||
+                    `${item.name.replace(/([A-Z])/g, ' $1').trim()} error occurred`;
+                errorMap[selector] = {
+                    name: item.name,
+                    signature,
+                    message: customMessage,
+                    contract: contractName,
+                    inputs: inputs.map((input) => ({
+                        name: input.name || '',
+                        type: input.type,
+                        internalType: input.internalType || input.type,
+                    })),
+                };
+            }
+        }
+        catch (error) {
+            console.warn(`Failed to process ${filePath}:`, error);
+        }
+    }
+    return errorMap;
+}
+function main() {
+    console.log('🔍 Scanning ABIs for error definitions...');
+    const errorMap = generateErrorMap();
+    const outputPath = path_1.default.join(process.cwd(), 'generated', 'errorMap.json');
+    // Ensure generated directory exists
+    const generatedDir = path_1.default.dirname(outputPath);
+    if (!fs_1.default.existsSync(generatedDir)) {
+        fs_1.default.mkdirSync(generatedDir, { recursive: true });
+    }
+    // Write the error map
+    fs_1.default.writeFileSync(outputPath, JSON.stringify(errorMap, null, 2));
+    console.log(`✅ Generated error map with ${Object.keys(errorMap).length} errors`);
+    console.log(`📁 Output: ${outputPath}`);
+    // Show some examples
+    const examples = Object.entries(errorMap).slice(0, 5);
+    console.log('\n📋 Examples:');
+    for (const [selector, info] of examples) {
+        console.log(`  ${selector} → ${info.name}: ${info.message}`);
+    }
+}
+if (require.main === module) {
+    main();
+}

package/dist/scripts/index.js

@@ -33,9 +33,13 @@ async function createWallet(mnemonic, provider) {
     }
 }
 async function setup() {
+    const rpc = new RPCLibrary_1.default();
+    const error = rpc.errors.getErrorInfo("0xa9b65aba");
+    console.log(error);
+    return;
     const provider = await getProvider();
     const signer = await createWallet(TEST_MNEMONIC, provider);
-    const rpc = new RPCLibrary_1.default();
+    // const rpc = new RPCLibrary();
     rpc.address = signer.address;
     rpc.provider = provider;
     rpc.chainId = chainId;

package/dist/types/RPCLibrary.d.ts

@@ -95,6 +95,7 @@ import vaultOpened from "./pools/lendingPool/vaultOpened";
 import { getWithdrawRequestInfo as getStabilityPoolWithdrawRequestInfo } from "./pools/stabilityPool/getWithdrawRequestInfo";
 import { requestWithdraw as requestStabilityPoolWithdraw } from "./pools/stabilityPool/requestWithdraw";
 import { getABI } from "./utils/artifacts";
+import { decodeErrorName, getErrorInfo, attachDecodedError, decodeErrorMessage, attachDecodedErrorMessage } from "./utils/errorDecoder";
 declare class RPCLibrary {
     signer: Signer | null;
     isConnected: boolean;
@@ -236,6 +237,13 @@ declare class RPCLibrary {
     checkAllowance: typeof checkAllowance;
     getChainsConfig: typeof getChainsConfig;
     setChainsConfig: typeof setChainConfig;
+    errors: {
+        decodeErrorName: typeof decodeErrorName;
+        getErrorInfo: typeof getErrorInfo;
+        attachDecodedError: typeof attachDecodedError;
+        decodeErrorMessage: typeof decodeErrorMessage;
+        attachDecodedErrorMessage: typeof attachDecodedErrorMessage;
+    };
     constructor(privateKey?: string);
     getWallet(privateKey: string, provider: Provider): Promise<ethers.JsonRpcSigner | ethers.Wallet>;
     getProvider(chainId: ChainId, providerRpc?: string): Promise<ethers.BrowserProvider | ethers.JsonRpcProvider>;

package/dist/types/scripts/generateErrorMap.d.ts

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

package/dist/types/utils/errorDecoder.d.ts

@@ -0,0 +1,37 @@
+interface GeneratedErrorInfo {
+    name: string;
+    signature: string;
+    message: string;
+    contract?: string;
+    inputs?: Array<{
+        name: string;
+        type: string;
+        internalType: string;
+    }>;
+}
+/**
+ * Returns detailed information about the error encoded in the given data blob.
+ * @param data The revert data returned by the EVM (e.g., error.data).
+ */
+export declare function getErrorInfo(data?: string): GeneratedErrorInfo | null;
+/**
+ * Returns only the error name, or null if it cannot be decoded.
+ */
+export declare function decodeErrorName(data?: string): string | null;
+/**
+ * Returns the custom error message, or null if it cannot be decoded.
+ */
+export declare function decodeErrorMessage(data?: string): string | null;
+/**
+ * Builds a user-friendly error prefix with decoded error name (if available).
+ * Usage example:
+ *   const msg = attachDecodedError("Deposit failed", caughtError);
+ */
+export declare function attachDecodedError(prefix: string, error: any): string;
+/**
+ * Builds a user-friendly error message with custom error description (if available).
+ * Usage example:
+ *   const msg = attachDecodedErrorMessage("Deposit failed", caughtError);
+ */
+export declare function attachDecodedErrorMessage(prefix: string, error: any): string;
+export {};

package/dist/utils/errorDecoder.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getErrorInfo = getErrorInfo;
+exports.decodeErrorName = decodeErrorName;
+exports.decodeErrorMessage = decodeErrorMessage;
+exports.attachDecodedError = attachDecodedError;
+exports.attachDecodedErrorMessage = attachDecodedErrorMessage;
+const ethers_1 = require("ethers");
+const artifacts_1 = require("./artifacts");
+// Try to load the generated error map, fallback to runtime scanning
+let ERROR_SIGNATURE_MAP = {};
+try {
+    const generatedMap = require('../generated/errorMap.json');
+    ERROR_SIGNATURE_MAP = generatedMap;
+}
+catch (error) {
+    console.warn('Generated error map not found, falling back to runtime scanning...');
+    // Fallback to runtime scanning (original implementation)
+    (function buildErrorSignatureMap() {
+        for (const abiKey in artifacts_1.ABIS) {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore – ABIS may contain unknown items
+            const abi = artifacts_1.ABIS[abiKey];
+            if (!Array.isArray(abi))
+                continue;
+            for (const item of abi) {
+                if (item.type !== "error")
+                    continue;
+                const inputs = (item.inputs || []);
+                const signature = `${item.name}(${inputs.map((input) => input.type).join(",")})`;
+                const selector = (0, ethers_1.id)(signature).slice(0, 10).toLowerCase();
+                if (!ERROR_SIGNATURE_MAP[selector]) {
+                    ERROR_SIGNATURE_MAP[selector] = {
+                        name: item.name,
+                        signature,
+                        message: `${item.name.replace(/([A-Z])/g, ' $1').trim()} error occurred`,
+                        contract: abiKey,
+                        inputs: inputs.map((input) => ({
+                            name: input.name || '',
+                            type: input.type,
+                            internalType: input.internalType || input.type,
+                        })),
+                    };
+                }
+            }
+        }
+    })();
+}
+/**
+ * Returns detailed information about the error encoded in the given data blob.
+ * @param data The revert data returned by the EVM (e.g., error.data).
+ */
+function getErrorInfo(data) {
+    if (!data || typeof data !== "string")
+        return null;
+    let selector;
+    if (data.startsWith("0x")) {
+        selector = data.slice(0, 10).toLowerCase();
+    }
+    else {
+        // look for first 4-byte hex inside the string (e.g., error message)
+        const match = data.match(/0x[0-9a-fA-F]{8}/);
+        if (match)
+            selector = match[0].toLowerCase();
+    }
+    if (!selector)
+        return null;
+    return ERROR_SIGNATURE_MAP[selector] ?? null;
+}
+/**
+ * Returns only the error name, or null if it cannot be decoded.
+ */
+function decodeErrorName(data) {
+    const info = getErrorInfo(data);
+    return info?.name ?? null;
+}
+/**
+ * Returns the custom error message, or null if it cannot be decoded.
+ */
+function decodeErrorMessage(data) {
+    const info = getErrorInfo(data);
+    return info?.message ?? null;
+}
+/**
+ * Builds a user-friendly error prefix with decoded error name (if available).
+ * Usage example:
+ *   const msg = attachDecodedError("Deposit failed", caughtError);
+ */
+function attachDecodedError(prefix, error) {
+    // ethers@6 nests the original error under error.error
+    // viem/ethcall surface it directly on error.data
+    const data = (error && ((error.data ?? error.error?.data) ||
+        // viem error format: error.shortMessage
+        undefined));
+    // If data not found, attempt to extract selector from message like
+    // "Encoded error signature \"0xa9b65aba\" not found on ABI"
+    let selector;
+    if (data && data.startsWith("0x")) {
+        selector = data.slice(0, 10).toLowerCase();
+    }
+    else if (typeof error?.message === "string") {
+        const SIGNATURE_REGEX = /Encoded error signature \"(0x[0-9a-fA-F]{8})\"/;
+        const match = error.message.match(SIGNATURE_REGEX);
+        if (match)
+            selector = match[1].toLowerCase();
+    }
+    if (!selector)
+        return prefix; // unable to determine
+    const decodedName = ERROR_SIGNATURE_MAP[selector]?.name ?? null;
+    // console.debug("Decoded", selector, decodedName);
+    return decodedName ? `${prefix} (${decodedName})` : prefix;
+}
+/**
+ * Builds a user-friendly error message with custom error description (if available).
+ * Usage example:
+ *   const msg = attachDecodedErrorMessage("Deposit failed", caughtError);
+ */
+function attachDecodedErrorMessage(prefix, error) {
+    const data = (error && ((error.data ?? error.error?.data) ||
+        undefined));
+    let selector;
+    if (data && data.startsWith("0x")) {
+        selector = data.slice(0, 10).toLowerCase();
+    }
+    else if (typeof error?.message === "string") {
+        const SIGNATURE_REGEX = /Encoded error signature \"(0x[0-9a-fA-F]{8})\"/;
+        const match = error.message.match(SIGNATURE_REGEX);
+        if (match)
+            selector = match[1].toLowerCase();
+    }
+    if (!selector)
+        return prefix;
+    const errorInfo = ERROR_SIGNATURE_MAP[selector];
+    if (!errorInfo)
+        return prefix;
+    return `${prefix}: ${errorInfo.message}`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@raac/rpc",
-	"version": "1.1.0-beta.53",
+	"version": "1.1.0-beta.55",
 	"description": "RPC Library for RAAC ",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",
@@ -9,12 +9,13 @@
 	],
 	"scripts": {
 		"dev": "ts-node-dev --transpile-only --env-file=.env scripts/index.ts",
-		"build": "tsc && cp -r typechain-types dist/types",
+		"build": "npm run generate:errors && tsc && cp -r typechain-types dist/types",
 		"build:watch": "tsc --watch",
 		"test": "echo \"Error: no test specified\" && exit 1",
 		"sync": "bash setup.sh",
 		"clean": "rm -rf dist",
-		"prebuild": "npm run clean"
+		"prebuild": "npm run clean",
+		"generate:errors": "ts-node scripts/generateErrorMap.ts"
 	},
 	"keywords": [
 		"RAAC",