@raac/rpc 2.0.0-beta.0 → 2.0.0-beta.10

package/dist/utils/rpcError.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RpcError = void 0;
+exports.toRpcError = toRpcError;
+const findContract_1 = require("../contracts/findContract");
+const artifacts_1 = require("./artifacts");
+const errorDecoder_1 = require("./errorDecoder");
+/**
+ * The one error type every `rpc` function throws. Replaces the ~5 inconsistent
+ * catch-block shapes in the codebase today (plain `new Error(\`Failed to…\`)`
+ * rewraps, ad hoc decoder string concatenation, raw rethrows, no handling at
+ * all) with one structure a consumer can actually branch on: skip
+ * `USER_REJECTED` without a toast, tag Sentry with `code`/`contract`/`errorName`
+ * instead of a free-text string.
+ */
+class RpcError extends Error {
+    code;
+    action;
+    contract;
+    errorName;
+    selector;
+    args;
+    cause;
+    constructor(params) {
+        super(params.message);
+        this.name = "RpcError";
+        this.code = params.code;
+        this.action = params.action;
+        this.contract = params.contract;
+        this.errorName = params.errorName;
+        this.selector = params.selector;
+        this.args = params.args;
+        this.cause = params.cause;
+        // Restores the prototype chain lost when transpiling `extends Error`.
+        Object.setPrototypeOf(this, RpcError.prototype);
+    }
+}
+exports.RpcError = RpcError;
+// Ships once `scripts/generateErrorCatalogue.ts` has run; absent until then,
+// same "optional, gracefully missing" treatment as any other generated file.
+let CATALOGUE = {};
+try {
+    CATALOGUE = require("../generated/errors.json");
+}
+catch {
+    // No catalogue yet — messages fall back to the raw error message below.
+}
+const REJECTION_CODES = new Set(["ACTION_REJECTED", 4001, "4001"]);
+function isUserRejection(error) {
+    const codes = [error?.code, error?.info?.error?.code, error?.error?.code, error?.cause?.code];
+    return codes.some((code) => REJECTION_CODES.has(code));
+}
+const NETWORK_CODES = new Set(["NETWORK_ERROR", "TIMEOUT", "SERVER_ERROR"]);
+const SELECTOR = /^0x[0-9a-fA-F]{8}$/;
+const SIGNATURE_IN_MESSAGE = /Encoded error signature "(0x[0-9a-fA-F]{8})"/;
+/**
+ * The revert selector when a client decoded the revert itself and threw only
+ * the selector. thirdweb does this: its send path decodes the revert data with
+ * viem against the contract's ABI, which it lacks behind the ethers adapter, so
+ * it throws viem's `AbiErrorSignatureNotFoundError` (selector on `.signature`
+ * and in the message) and drops the data.
+ */
+function selectorWithoutData(error) {
+    let current = error;
+    for (let depth = 0; current && typeof current === "object" && depth < 5; depth++) {
+        if (typeof current.signature === "string" && SELECTOR.test(current.signature))
+            return current.signature.toLowerCase();
+        const match = typeof current.message === "string" ? current.message.match(SIGNATURE_IN_MESSAGE) : null;
+        if (match)
+            return match[1].toLowerCase();
+        current = current.cause;
+    }
+    return undefined;
+}
+/**
+ * Builds an {@link RpcError} from whatever ethers, a wallet, or the network
+ * threw. Every `rpc` function's catch block calls this instead of hand-rolling
+ * its own rewrap.
+ *
+ * @param action - What was being attempted, e.g. "lendingPool.deposit".
+ * @param error - The error caught.
+ * @param resolve - The chain and, when known, the address that was called —
+ *   lets the error be decoded against that contract's own ABI instead of a
+ *   selector-only guess, and names the contract on the result.
+ */
+function toRpcError(action, error, resolve) {
+    const err = error;
+    if (isUserRejection(err)) {
+        return new RpcError({
+            code: "USER_REJECTED",
+            action,
+            message: "Rejected in wallet.",
+            cause: error,
+        });
+    }
+    let contract;
+    let abi;
+    let contractType;
+    if (resolve?.address) {
+        const info = (0, findContract_1.findContract)(resolve.chainId, resolve.address);
+        if (info) {
+            contract = { id: info.id, name: info.label, address: info.address };
+            if (info.abi) {
+                abi = (0, artifacts_1.getABI)(info.abi);
+                contractType = info.abi;
+            }
+        }
+    }
+    const data = err?.data ?? err?.error?.data ?? err?.info?.error?.data;
+    const selector = typeof data === "string" && /^0x[0-9a-fA-F]{8}/.test(data) ? data.slice(0, 10).toLowerCase() : selectorWithoutData(err);
+    let errorName;
+    let args;
+    // ethers already decoded this against the ABI it used to make the call —
+    // free and more precise than re-decoding, when it's there.
+    if (err?.revert?.name) {
+        errorName = err.revert.name;
+        const inputs = err.revert.fragment?.inputs;
+        if (Array.isArray(err.revert.args) && Array.isArray(inputs)) {
+            args = {};
+            inputs.forEach((input, i) => {
+                args[input.name || String(i)] = err.revert.args[i];
+            });
+        }
+    }
+    if (!errorName) {
+        // A revert bubbled up from a nested call (e.g. crvUSD's
+        // ERC20InsufficientAllowance through LendingPool) isn't in the called
+        // contract's ABI, so fall back to every known one.
+        const decoded = (abi && (0, errorDecoder_1.decodeRevertWithAbi)(abi, data)) || (0, errorDecoder_1.decodeRevertWithAllAbis)(data);
+        if (decoded) {
+            errorName = decoded.name;
+            args = decoded.args;
+        }
+    }
+    if (!errorName && selector) {
+        errorName = (0, errorDecoder_1.errorNameForSelector)(selector, abi) ?? undefined;
+    }
+    let code;
+    if (errorName || selector || err?.code === "CALL_EXCEPTION") {
+        code = "CONTRACT_REVERT";
+    }
+    else if (err?.code === "INSUFFICIENT_FUNDS") {
+        code = "INSUFFICIENT_FUNDS";
+    }
+    else if (NETWORK_CODES.has(err?.code)) {
+        code = "NETWORK";
+    }
+    else {
+        code = "UNKNOWN";
+    }
+    let message;
+    const catalogueKey = contractType && selector ? `${contractType}:${selector}` : undefined;
+    const catalogueEntry = catalogueKey ? CATALOGUE[catalogueKey] : undefined;
+    if (catalogueEntry)
+        message = catalogueEntry.message;
+    if (!message)
+        message = err?.shortMessage ?? err?.message ?? String(err ?? "Unknown error");
+    return new RpcError({ code, action, message, contract, errorName, selector, args, cause: error });
+}

package/dist/wallet/assets/approveAsset.js

@@ -2,7 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const contracts_1 = require("../../utils/contracts");
-const artifacts_1 = require("../../utils/artifacts");
+const rpcError_1 = require("../../utils/rpcError");
+// `approve` is the same on every ERC20, so this doesn't need the asset's full
+// ABI - some asset keys (e.g. pmUSD) resolve to an address but ship an empty
+// compiled artifact, which made `getABI(assetId)` return `[]` and approving
+// under them fail with "tokenContract.approve is not a function".
+const ERC20_APPROVE_ABI = ["function approve(address spender, uint256 amount) returns (bool)"];
 /**
  * Approves `spender` to pull an asset from the signer.
  * @param chainId The chain id.
@@ -16,22 +21,15 @@ async function approveAsset(chainId, assetId, spender, amount, signer) {
     if (!signer) {
         throw new Error("Wallet not connected");
     }
+    const tokenAddress = (0, contracts_1.getContractAddress)(chainId, assetId);
     try {
-        const tokenAddress = (0, contracts_1.getContractAddress)(chainId, assetId);
-        // @ts-ignore
-        const abi = (0, artifacts_1.getABI)(assetId);
-        const tokenContract = new ethers_1.ethers.Contract(tokenAddress, abi, signer);
-        const tx = await tokenContract.approve(spender, amount, {
-            nonce: await signer.getNonce(),
-        });
-        console.log(`Approval transaction sent for ${assetId}:`, tx.hash);
+        const tokenContract = new ethers_1.ethers.Contract(tokenAddress, ERC20_APPROVE_ABI, signer);
+        const tx = await tokenContract.approve(spender, amount);
         const receipt = await tx.wait();
-        console.log(`Approved ${amount} ${assetId} for ${spender} successfully:`, receipt.transactionHash);
         return receipt;
     }
     catch (error) {
-        console.error(`Approval error for ${assetId}:`, error);
-        throw new Error(`Token approval failed for ${assetId}: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("wallet.approveAsset", error, { chainId, address: tokenAddress });
     }
 }
 exports.default = approveAsset;

package/dist/wallet/assets/burnAsset.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const contracts_1 = require("../../utils/contracts");
 const artifacts_1 = require("../../utils/artifacts");
+const rpcError_1 = require("../../utils/rpcError");
 /**
  * Burns an asset from the signer.
  * @param chainId The chain id.
@@ -12,19 +13,19 @@ const artifacts_1 = require("../../utils/artifacts");
  * @returns The transaction receipt.
  */
 async function burnAsset(chainId, assetId, amount, signer) {
+    if (!signer) {
+        throw new Error("Wallet not connected");
+    }
+    const { assets } = (0, contracts_1.getConfig)(chainId);
+    const asset = Object.values(assets).find(
+    // @ts-ignore
+    (asset) => asset.id.toLowerCase() === assetId.toLowerCase());
+    if (!asset) {
+        throw new Error(`Asset ${assetId} not found on chain ${chainId}`);
+    }
+    // @ts-ignore
+    const contractAddress = asset.contract;
     try {
-        if (!signer) {
-            throw new Error("Wallet not connected");
-        }
-        const { assets } = (0, contracts_1.getConfig)(chainId);
-        const asset = Object.values(assets).find(
-        // @ts-ignore
-        (asset) => asset.id.toLowerCase() === assetId.toLowerCase());
-        if (!asset) {
-            throw new Error(`Asset ${assetId} not found on chain ${chainId}`);
-        }
-        // @ts-ignore
-        const contractAddress = asset.contract;
         // @ts-ignore
         const abi = (0, artifacts_1.getABI)(assetId);
         const contract = new ethers_1.ethers.Contract(contractAddress, abi, signer);
@@ -34,14 +35,11 @@ async function burnAsset(chainId, assetId, amount, signer) {
         const tx = await contract.burn(amount, {
             nonce: +(await signer.getNonce()),
         });
-        console.log(`Burning transaction sent for ${assetId}:`, tx.hash);
         const receipt = await tx.wait();
-        console.log(`Burned ${amount} ${assetId} successfully:`, receipt.transactionHash);
         return receipt;
     }
     catch (error) {
-        console.error(`Error burning asset ${assetId}:`, error);
-        throw new Error(`Burning failed for ${assetId}: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("wallet.burnAsset", error, { chainId, address: contractAddress });
     }
 }
 exports.default = burnAsset;

package/dist/wallet/assets/getAllowance.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const contracts_1 = require("../../utils/contracts");
 const amount_1 = require("../../utils/amount");
+const rpcError_1 = require("../../utils/rpcError");
 /**
  * Reads how much of an asset `spender` may pull from `owner`.
  * @param chainId The chain id.
@@ -14,6 +15,7 @@ const amount_1 = require("../../utils/amount");
  * @throws If the read fails.
  */
 async function getAllowance(chainId, assetId, owner, spender, provider) {
+    let contractAddress;
     try {
         if (assetId === "eth") {
             return (0, amount_1.toAmount)(ethers_1.ethers.MaxUint256, amount_1.WAD_DECIMALS, "ETH");
@@ -21,15 +23,13 @@ async function getAllowance(chainId, assetId, owner, spender, provider) {
         const ALLOWANCE_ABI = [
             "function allowance(address,address) view returns (uint256)",
         ];
-        const contractAddress = (0, contracts_1.getContractAddress)(chainId, assetId);
+        contractAddress = (0, contracts_1.getContractAddress)(chainId, assetId);
         const contract = new ethers_1.ethers.Contract(contractAddress, ALLOWANCE_ABI, provider);
         const allowance = await contract.allowance(owner, spender);
         return (0, amount_1.toTokenAmount)(chainId, assetId, allowance);
     }
     catch (error) {
-        console.error(`Error getting allowance for asset ${assetId}:`, error);
-        console.log({ assetId, owner, spender });
-        throw error;
+        throw (0, rpcError_1.toRpcError)("wallet.getAllowance", error, { chainId, address: contractAddress });
     }
 }
 exports.default = getAllowance;

package/dist/wallet/assets/getAsset.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const contracts_1 = require("../../utils/contracts");
 const getBalance_1 = __importDefault(require("./getBalance"));
+const rpcError_1 = require("../../utils/rpcError");
 /**
  * Reads a configured asset's config entry together with a wallet's balance of it.
  * @param chainId The chain id.
@@ -22,8 +23,7 @@ async function getAsset(chainId, assetId, address, provider) {
         return { ...asset, balance };
     }
     catch (error) {
-        console.log(`Error getting balance: ${error}`);
-        throw error;
+        throw (0, rpcError_1.toRpcError)("wallet.getAsset", error, { chainId });
     }
 }
 exports.default = getAsset;

package/dist/wallet/assets/getBalance.js

@@ -4,6 +4,7 @@ const ethers_1 = require("ethers");
 const contracts_1 = require("../../utils/contracts");
 const amount_1 = require("../../utils/amount");
 const _helpers_1 = require("../../assets/_helpers");
+const rpcError_1 = require("../../utils/rpcError");
 /**
  * Reads a wallet's balance of a configured asset or native ETH.
  * @param chainId The chain id.
@@ -15,20 +16,20 @@ const _helpers_1 = require("../../assets/_helpers");
  */
 async function getBalance(chainId, assetId, address, provider) {
     const BALANCE_OF_ABI = ["function balanceOf(address) view returns (uint256)"];
+    let contractAddress;
     try {
         if (assetId === "eth") {
             const balance = await provider.getBalance(address);
             return (0, amount_1.toAmount)(balance, amount_1.WAD_DECIMALS, "ETH");
         }
         (0, _helpers_1.assertAssetDeployed)(chainId, assetId);
-        const contractAddress = (0, contracts_1.getContractAddress)(chainId, assetId);
+        contractAddress = (0, contracts_1.getContractAddress)(chainId, assetId);
         const contract = new ethers_1.ethers.Contract(contractAddress, BALANCE_OF_ABI, provider);
         const balance = await contract.balanceOf(address);
         return (0, amount_1.toTokenAmount)(chainId, assetId, balance);
     }
     catch (error) {
-        console.error(`Error getting balance for asset ${assetId}:`, error);
-        throw error;
+        throw (0, rpcError_1.toRpcError)("wallet.getBalance", error, { chainId, address: contractAddress });
     }
 }
 exports.default = getBalance;

package/dist/wallet/assets/mintAsset.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const contracts_1 = require("../../utils/contracts");
 const artifacts_1 = require("../../utils/artifacts");
+const rpcError_1 = require("../../utils/rpcError");
 /**
  * Mints an asset to `address`.
  * @param chainId The chain id.
@@ -13,20 +14,19 @@ const artifacts_1 = require("../../utils/artifacts");
  * @returns The transaction receipt.
  */
 async function mintAsset(chainId, assetId, amount, address, signer) {
+    if (!signer) {
+        throw new Error("Wallet not connected");
+    }
+    const { assets } = (0, contracts_1.getConfig)(chainId);
+    const asset = Object.values(assets).find(
+    // @ts-ignore
+    (asset) => asset.id.toLowerCase() === assetId.toLowerCase());
+    if (!asset) {
+        throw new Error(`Asset ${assetId} not found on chain ${chainId}`);
+    }
+    // @ts-ignore
+    const contractAddress = asset.contract;
     try {
-        if (!signer) {
-            throw new Error("Wallet not connected");
-        }
-        const { assets } = (0, contracts_1.getConfig)(chainId);
-        console.log("assets", assets);
-        const asset = Object.values(assets).find(
-        // @ts-ignore
-        (asset) => asset.id.toLowerCase() === assetId.toLowerCase());
-        if (!asset) {
-            throw new Error(`Asset ${assetId} not found on chain ${chainId}`);
-        }
-        // @ts-ignore
-        const contractAddress = asset.contract;
         let contract;
         // @ts-ignore
         const abi = (0, artifacts_1.getABI)(assetId);
@@ -38,14 +38,11 @@ async function mintAsset(chainId, assetId, amount, address, signer) {
             // maxFeePerGas,
             nonce: +(await signer.getNonce()),
         });
-        console.log(`Minting transaction sent for ${assetId}:`, tx.hash);
         const receipt = await tx.wait();
-        console.log(`Minted ${amount} ${assetId} successfully:`, receipt.hash);
         return receipt;
     }
     catch (error) {
-        console.error(`Error minting asset ${assetId}:`, error);
-        throw new Error(`Minting failed for ${assetId}: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("wallet.mintAsset", error, { chainId, address: contractAddress });
     }
 }
 exports.default = mintAsset;

package/dist/wallet/assets/transferAsset.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const contracts_1 = require("../../utils/contracts");
 const artifacts_1 = require("../../utils/artifacts");
+const rpcError_1 = require("../../utils/rpcError");
 /**
  * Transfers an asset or native ETH from the signer.
  * @param chainId The chain id.
@@ -14,10 +15,11 @@ const artifacts_1 = require("../../utils/artifacts");
  * @returns The transaction receipt.
  */
 async function transferAsset(chainId, assetId, amount, fromAddress, toAddress, signer) {
+    if (!signer) {
+        throw new Error("Wallet not connected");
+    }
+    let contractAddress;
     try {
-        if (!signer) {
-            throw new Error("Wallet not connected");
-        }
         if (assetId.toLowerCase() === "eth") {
             // Handle ETH transfer
             const tx = await signer.sendTransaction({
@@ -25,9 +27,7 @@ async function transferAsset(chainId, assetId, amount, fromAddress, toAddress, s
                 value: amount,
                 nonce: await signer.getNonce(),
             });
-            console.log(`ETH transfer transaction sent:`, tx.hash);
             const receipt = await tx.wait();
-            console.log(`Transferred ${amount} ETH from ${fromAddress} to ${toAddress} successfully:`, (await receipt?.getTransaction())?.hash);
             return receipt;
         }
         else {
@@ -40,7 +40,7 @@ async function transferAsset(chainId, assetId, amount, fromAddress, toAddress, s
                 throw new Error(`Asset ${assetId} not found on chain ${chainId}`);
             }
             // @ts-ignore
-            const contractAddress = asset.contract;
+            contractAddress = asset.contract;
             // @ts-ignore
             const abi = (0, artifacts_1.getABI)(assetId);
             const contract = new ethers_1.ethers.Contract(contractAddress, abi, signer);
@@ -50,15 +50,12 @@ async function transferAsset(chainId, assetId, amount, fromAddress, toAddress, s
             const tx = await contract.transfer(toAddress, amount, {
                 nonce: await signer.getNonce(),
             });
-            console.log(`Transfer transaction sent for ${assetId}:`, tx.hash);
             const receipt = await tx.wait();
-            console.log(`Transferred ${amount} ${assetId} from ${fromAddress} to ${toAddress} successfully:`, receipt.transactionHash);
             return receipt;
         }
     }
     catch (error) {
-        console.error(`Error transferring asset ${assetId}:`, error);
-        throw new Error(`Transfer failed for ${assetId}: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("wallet.transferAsset", error, { chainId, address: contractAddress });
     }
 }
 exports.default = transferAsset;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@raac/rpc",
-	"version": "2.0.0-beta.0",
+	"version": "2.0.0-beta.10",
 	"description": "RPC Library for RAAC",
 	"main": "dist/index.js",
 	"types": "dist/types/index.d.ts",
@@ -9,13 +9,13 @@
 	],
 	"scripts": {
 		"dev": "ts-node-dev --transpile-only --env-file=.env scripts/index.ts",
-		"build": "npm run generate:errors && tsc && cp -r typechain-types dist/types && cp -r generated dist/generated",
+		"build": "tsc && cp -r typechain-types dist/types && cp -r generated dist/generated",
 		"build:watch": "tsc --watch",
 		"test": "echo \"Error: no test specified\" && exit 1",
 		"sync": "bash setup.sh",
 		"clean": "rm -rf dist",
 		"prebuild": "npm run clean",
-		"generate:errors": "ts-node scripts/generateErrorMap.ts"
+		"generate:catalogue": "node --env-file=.env -r ts-node/register/transpile-only scripts/generateErrorCatalogue.ts"
 	},
 	"keywords": [
 		"RAAC",
@@ -32,6 +32,7 @@
 		"ethers5": "npm:ethers@5.8.0"
 	},
 	"devDependencies": {
+		"@anthropic-ai/sdk": "^0.127.0",
 		"eslint": "9.39.1",
 		"ts-node": "10.9.2",
 		"ts-node-dev": "2.0.0",