@raac/rpc 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/contracts/yearn/vault/previewDeposit.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewDeposit = void 0;
+const amount_1 = require("../../../utils/amount");
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Shares a deposit of `assets` would mint now.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param assets - Vault asset amount, in its base units.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The shares, in base units.
+ */
+const previewDeposit = async (chainId, vaultAddressOrId, assets, provider) => {
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, provider);
+    try {
+        return (0, amount_1.toTokenAmount)(chainId, entry.contract, await contract.previewDeposit(assets));
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.previewDeposit", error, { chainId, address: entry.contract });
+    }
+};
+exports.previewDeposit = previewDeposit;

package/dist/contracts/yearn/vault/previewMint.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewMint = void 0;
+const amount_1 = require("../../../utils/amount");
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Assets a mint of `shares` would pull now.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param shares - Share amount, in base units.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The vault asset amount, in its base units.
+ */
+const previewMint = async (chainId, vaultAddressOrId, shares, provider) => {
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, provider);
+    try {
+        return (0, amount_1.toTokenAmount)(chainId, entry.asset, await contract.previewMint(shares));
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.previewMint", error, { chainId, address: entry.contract });
+    }
+};
+exports.previewMint = previewMint;

package/dist/contracts/yearn/vault/previewRedeem.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewRedeem = void 0;
+const amount_1 = require("../../../utils/amount");
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Assets a redemption of `shares` would pay out now.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param shares - Share amount, in base units.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The vault asset amount, in its base units.
+ */
+const previewRedeem = async (chainId, vaultAddressOrId, shares, provider) => {
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, provider);
+    try {
+        return (0, amount_1.toTokenAmount)(chainId, entry.asset, await contract.previewRedeem(shares));
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.previewRedeem", error, { chainId, address: entry.contract });
+    }
+};
+exports.previewRedeem = previewRedeem;

package/dist/contracts/yearn/vault/previewWithdraw.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.previewWithdraw = void 0;
+const amount_1 = require("../../../utils/amount");
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Shares a withdrawal of `assets` would burn now.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param assets - Vault asset amount, in its base units.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The shares, in base units.
+ */
+const previewWithdraw = async (chainId, vaultAddressOrId, assets, provider) => {
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, provider);
+    try {
+        return (0, amount_1.toTokenAmount)(chainId, entry.contract, await contract.previewWithdraw(assets));
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.previewWithdraw", error, { chainId, address: entry.contract });
+    }
+};
+exports.previewWithdraw = previewWithdraw;

package/dist/contracts/yearn/vault/processReport.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processReport = void 0;
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Reports a strategy, or with no `strategy` the vault itself. A self-report books any vault asset sent to the vault
+ * since the last report as profit and streams it to depositors over `profitMaxUnlockTime`; this is how rewards
+ * reach a vault without strategies. The signer needs the vault's REPORTING_MANAGER role.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param strategy - The strategy to report; defaults to the vault (self-report).
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+const processReport = async (chainId, vaultAddressOrId, strategy, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, signer);
+    try {
+        const tx = await contract.process_report(strategy ?? entry.contract);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.processReport", error, { chainId, address: entry.contract });
+    }
+};
+exports.processReport = processReport;

package/dist/contracts/yearn/vault/redeem.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redeem = void 0;
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Redeems `shares` for the vault asset (see `previewRedeem`). Use this, with the user's full share balance, to
+ * exit completely. Uses Yearn's default max loss of 100%, which only matters for a vault with strategies.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param shares - Share amount, in base units.
+ * @param receiver - Who receives the assets.
+ * @param owner - Whose shares are burnt; the signer, or an owner that approved the signer for the shares.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+const redeem = async (chainId, vaultAddressOrId, shares, receiver, owner, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, signer);
+    try {
+        const tx = await contract.redeem(shares, receiver, owner);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.redeem", error, { chainId, address: entry.contract });
+    }
+};
+exports.redeem = redeem;

package/dist/contracts/yearn/vault/withdraw.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withdraw = void 0;
+const rpcError_1 = require("../../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Withdraws exactly `assets` of the vault asset, burning the shares they cost (see `previewWithdraw`). Uses
+ * Yearn's default max loss of 0.
+ *
+ * @param chainId - The chain/network to use.
+ * @param vaultAddressOrId - The vault's key in the chain config's `yearn` section, or its address.
+ * @param assets - Vault asset amount, in its base units.
+ * @param receiver - Who receives the assets.
+ * @param owner - Whose shares are burnt; the signer, or an owner that approved the signer for the shares.
+ * @param signer - The signer sending the transaction.
+ * @returns The mined transaction receipt.
+ */
+const withdraw = async (chainId, vaultAddressOrId, assets, receiver, owner, signer) => {
+    if (!signer)
+        throw new Error("Signer is required");
+    const { entry, contract } = (0, _helpers_1.getYearnVaultContract)(chainId, vaultAddressOrId, signer);
+    try {
+        const tx = await contract.withdraw(assets, receiver, owner);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("yearn.withdraw", error, { chainId, address: entry.contract });
+    }
+};
+exports.withdraw = withdraw;

package/dist/contracts/zap/aladdin/inspectCurvePool.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectCurvePool = void 0;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../../configs/chains"));
+const rpcError_1 = require("../../../utils/rpcError");
+const resolveTokenInfo_1 = require("../../resolveTokenInfo");
+const _types_1 = require("./_types");
+/**
+ * The zap's Curve swap calls by pool type (TokenZapLogic.swap), for pools indexed by plain `coins(i)`. The base, A, Y,
+ * meta and factory meta pools all swap through the same 4-argument int128 `exchange`, so they share CurveBasePool here.
+ */
+const SWAP_SIGNATURES = [
+    [_types_1.AladdinPoolType.CurveCryptoPool, "exchange(uint256,uint256,uint256,uint256)"],
+    [_types_1.AladdinPoolType.CurveFactoryPlainPool, "exchange(int128,int128,uint256,uint256,address)"],
+    [_types_1.AladdinPoolType.CurveTriCryptoPool, "exchange(uint256,uint256,uint256,uint256,bool)"],
+    [_types_1.AladdinPoolType.CurveBasePool, "exchange(int128,int128,uint256,uint256)"],
+];
+const MAX_COINS = 8;
+/**
+ * Reads a Curve pool that may not be in the chain config, so a zap route can be built through it: its coins in index
+ * order with their symbols, and which zap pool types it can swap as. The types come from the swap function selectors in
+ * its deployed bytecode, which Vyper and Solidity dispatchers embed; a match means the call exists, not that the pool
+ * behaves as that type in every other way.
+ *
+ * @param chainId - The chain/network to use.
+ * @param pool - The pool address.
+ * @param provider - Optional ethers.js Provider instance.
+ * @throws If the address has no code or no `coins(0)`.
+ */
+const inspectCurvePool = async (chainId, pool, provider) => {
+    if (!provider)
+        provider = new ethers_1.ethers.JsonRpcProvider(chains_1.default[chainId].rpcs[0]);
+    const address = ethers_1.ethers.getAddress(pool);
+    try {
+        const code = await provider.getCode(address);
+        if (code === "0x")
+            throw new Error(`${address} has no contract code`);
+        // Newer pools index coins with uint256, older ones with int128.
+        const byUint = new ethers_1.ethers.Contract(address, ["function coins(uint256) view returns (address)"], provider);
+        const byInt = new ethers_1.ethers.Contract(address, ["function coins(int128) view returns (address)"], provider);
+        const coinAt = (i) => byUint.coins(i).catch(() => byInt.coins(i)).catch(() => null);
+        const addresses = [];
+        for (let i = 0; i < MAX_COINS; i++) {
+            const coin = await coinAt(i);
+            if (!coin || coin === ethers_1.ethers.ZeroAddress)
+                break;
+            addresses.push(ethers_1.ethers.getAddress(coin));
+        }
+        if (!addresses.length)
+            throw new Error(`${address} has no coins(0); it is not a Curve pool this can read`);
+        const coins = await Promise.all(addresses.map(async (coin) => {
+            const { symbol, decimals } = await (0, resolveTokenInfo_1.resolveTokenInfo)(chainId, coin, provider);
+            return { address: coin, symbol: symbol ?? "?", decimals };
+        }));
+        const poolTypes = SWAP_SIGNATURES.filter(([, sig]) => code.toLowerCase().includes(ethers_1.ethers.id(sig).slice(2, 10))).map(([type]) => type);
+        return { pool: address, coins, poolTypes };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zap.aladdin.inspectCurvePool", error, { chainId, address });
+    }
+};
+exports.inspectCurvePool = inspectCurvePool;

package/dist/contracts/zeno/_helpers.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERC20_ABI = void 0;
+exports.getZenoContract = getZenoContract;
+exports.getAuctionContract = getAuctionContract;
+exports.toZenoAmount = toZenoAmount;
+exports.addressOrNull = addressOrNull;
+const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../configs/chains"));
+const artifacts_1 = require("../../utils/artifacts");
+const amount_1 = require("../../utils/amount");
+/** The one ERC20 call the zeno methods make: the underlying held by a ZENO. */
+exports.ERC20_ABI = ["function balanceOf(address) view returns (uint256)"];
+/** A ZENO bond. Bonds are created by the factory, so the address is passed in rather than read from the config. */
+function getZenoContract(chainId, zeno, runner) {
+    if (!runner) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        runner = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    return new ethers_1.ethers.Contract(zeno, (0, artifacts_1.getABI)("zeno"), runner);
+}
+/** A ZENO auction. Auctions are created by the factory, so the address is passed in rather than read from the config. */
+function getAuctionContract(chainId, auction, runner) {
+    if (!runner) {
+        const rpc = chains_1.default[chainId].rpcs[0];
+        runner = new ethers_1.ethers.JsonRpcProvider(rpc);
+    }
+    return new ethers_1.ethers.Contract(auction, (0, artifacts_1.getABI)("auction"), runner);
+}
+/**
+ * A ZENO amount. ZENO takes its decimals from its underlying, so they come from the underlying's registry entry; a
+ * ZENO address itself is never in the registry. Falls back to 18 decimals when the underlying is not listed.
+ */
+function toZenoAmount(chainId, underlying, value, symbol) {
+    return (0, amount_1.toAmount)(value, (0, amount_1.getTokenInfo)(chainId, underlying)?.decimals ?? amount_1.WAD_DECIMALS, symbol);
+}
+/** `ZENO.auction()` and other unset address fields read as the zero address; this maps that to null. */
+function addressOrNull(address) {
+    return address === ethers_1.ethers.ZeroAddress ? null : address;
+}

package/dist/contracts/zeno/buy.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Buys ZENO: spends exactly `paymentAmount` of the payment token, sent to the issuer, at the price of the block it is
+ * mined in. Needs a payment token allowance for the auction (`wallet.assets.approveAsset`). Reverts while paused,
+ * outside the auction window, when the ZENO out would exceed what is left, or when it is below `minZenoOut`.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param paymentAmount Payment token to spend, in base units.
+ * @param minZenoOut The least ZENO to accept, in ZENO base units; `quoteBuy` sizes it.
+ * @param signer The buyer, who receives the ZENO.
+ * @returns The transaction receipt; its `ZENOPurchased` log carries the ZENO minted and the price paid.
+ */
+async function buy(chainId, auction, paymentAmount, minZenoOut, signer) {
+    if (!signer)
+        throw new Error("Signer is required");
+    try {
+        const tx = await (0, _helpers_1.getAuctionContract)(chainId, auction, signer).buy(paymentAmount, minZenoOut);
+        return await tx.wait();
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.buy", error, { chainId, address: auction });
+    }
+}
+exports.default = buy;

package/dist/contracts/zeno/createAuction.js

@@ -1,38 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FundingMode = void 0;
 const ethers_1 = require("ethers");
 const contracts_1 = require("../../utils/contracts");
 const artifacts_1 = require("../../utils/artifacts");
+const rpcError_1 = require("../../utils/rpcError");
+/** How an auction's ZENO is backed by the underlying asset. Mirrors `IAuction.FundingMode`. */
+var FundingMode;
+(function (FundingMode) {
+    /** The ZENO must already hold underlying for the full allocation. */
+    FundingMode[FundingMode["Prefilled"] = 0] = "Prefilled";
+    /** The issuer tops up the underlying before maturity. */
+    FundingMode[FundingMode["Float"] = 1] = "Float";
+})(FundingMode || (exports.FundingMode = FundingMode = {}));
 /**
- * Creates a ZENO auction through the AuctionFactory.
+ * Creates a ZENO auction through the AuctionFactory. Only the factory owner can call this.
  * @param chainId The chain id.
  * @param zenoAddress The ZENO bond token sold.
- * @param usdcAddress The payment token bidders pay with.
- * @param businessAddress The issuer receiving the proceeds.
+ * @param tokenAddress The payment token bidders pay with.
+ * @param issuer The issuer receiving the proceeds.
  * @param auctionStartTime UNIX timestamp (seconds) the auction starts.
  * @param auctionEndTime UNIX timestamp (seconds) the auction ends.
  * @param startingPrice The Dutch auction starting price, in payment token base units per whole ZENO.
  * @param reservePrice The Dutch auction reserve price, in payment token base units per whole ZENO.
  * @param totalZenoAllocated The ZENO offered, in ZENO base units.
- * @param signer The signer sending the transaction.
+ * @param fundingMode How the ZENO is backed; `Prefilled` requires the ZENO to hold underlying for the full allocation.
+ * @param initialOwner The owner of the new auction.
+ * @param signer The factory owner.
+ * @returns The address of the new auction.
  */
-async function createAuction(chainId, zenoAddress, usdcAddress, businessAddress, auctionStartTime, auctionEndTime, startingPrice, reservePrice, totalZenoAllocated, signer) {
+async function createAuction(chainId, zenoAddress, tokenAddress, issuer, auctionStartTime, auctionEndTime, startingPrice, reservePrice, totalZenoAllocated, fundingMode, initialOwner, signer) {
     if (!signer) {
         throw new Error("Wallet not connected");
     }
+    const auctionFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "auctionfactory");
     try {
-        const auctionFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "auctionfactory");
-        const auctionFactoryABI = (0, artifacts_1.getABI)("auctionfactory");
-        const auctionFactoryContract = new ethers_1.ethers.Contract(auctionFactoryAddress, auctionFactoryABI, signer);
-        const tx = await auctionFactoryContract.createAuction(zenoAddress, usdcAddress, businessAddress, auctionStartTime, auctionEndTime, startingPrice, reservePrice, totalZenoAllocated);
-        await tx.wait();
-        const auctionsCount = await auctionFactoryContract.getAuctionCount();
-        const auctionAddress = await auctionFactoryContract.getAuction(auctionsCount - BigInt(1));
-        console.log(`Zeno auction created at address: ${auctionAddress}`);
+        const auctionFactoryContract = new ethers_1.ethers.Contract(auctionFactoryAddress, (0, artifacts_1.getABI)("auctionfactory"), signer);
+        const tx = await auctionFactoryContract.createAuction(zenoAddress, tokenAddress, issuer, auctionStartTime, auctionEndTime, startingPrice, reservePrice, totalZenoAllocated, fundingMode, initialOwner);
+        const receipt = await tx.wait();
+        for (const log of receipt.logs) {
+            const parsed = auctionFactoryContract.interface.parseLog(log);
+            if (parsed?.name === "AuctionCreated") {
+                return parsed.args.auctionAddress;
+            }
+        }
+        throw new Error("AuctionCreated event not found in receipt");
     }
     catch (error) {
-        console.error("Error creating zeno auction:", error);
-        throw new Error(`Failed to create zeno auction: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("zeno.createAuction", error, { chainId, address: auctionFactoryAddress });
     }
 }
 exports.default = createAuction;

package/dist/contracts/zeno/createZeno.js

@@ -3,24 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
 const contracts_1 = require("../../utils/contracts");
 const artifacts_1 = require("../../utils/artifacts");
-async function createZeno(chainId, usdcAddress, maturityDate, signer) {
+const rpcError_1 = require("../../utils/rpcError");
+/**
+ * Creates a ZENO bond through the ZENOFactory. Only the factory owner can call this.
+ * @param chainId The chain id.
+ * @param tokenAddress The underlying asset the bond redeems for.
+ * @param maturityDate UNIX timestamp (seconds) the bond matures. Must be in the future.
+ * @param initialOwner The owner of the new bond, typically the auction or a multisig.
+ * @param signer The factory owner.
+ * @returns The address of the new ZENO bond.
+ */
+async function createZeno(chainId, tokenAddress, maturityDate, initialOwner, signer) {
     if (!signer) {
         throw new Error("Wallet not connected");
     }
+    const zenoFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "zenofactory");
     try {
-        const zenoFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "zenofactory");
-        const zenoFactoryABI = (0, artifacts_1.getABI)("zenofactory");
-        const zenoFactoryContract = new ethers_1.ethers.Contract(zenoFactoryAddress, zenoFactoryABI, signer);
-        const tx = await zenoFactoryContract.createZENOContract(usdcAddress, maturityDate);
-        await tx.wait();
-        const zenosCount = await zenoFactoryContract.getZENOCount();
-        const zenoAddress = await zenoFactoryContract.getZENO(zenosCount - BigInt(1));
-        console.log(`Zeno created at address: ${zenoAddress}`);
-        return zenoAddress;
+        const zenoFactoryContract = new ethers_1.ethers.Contract(zenoFactoryAddress, (0, artifacts_1.getABI)("zenofactory"), signer);
+        const tx = await zenoFactoryContract.createZENOContract(tokenAddress, maturityDate, initialOwner);
+        const receipt = await tx.wait();
+        for (const log of receipt.logs) {
+            const parsed = zenoFactoryContract.interface.parseLog(log);
+            if (parsed?.name === "ZENOCreated") {
+                return parsed.args.zenoAddress;
+            }
+        }
+        throw new Error("ZENOCreated event not found in receipt");
     }
     catch (error) {
-        console.error("Error creating zeno:", error);
-        throw new Error(`Failed to create zeno: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("zeno.createZeno", error, { chainId, address: zenoFactoryAddress });
     }
 }
 exports.default = createZeno;

package/dist/contracts/zeno/getAuctionState.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const amount_1 = require("../../utils/amount");
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
+/**
+ * Reads one auction's terms and live state.
+ * @param chainId The chain id.
+ * @param auction The auction address.
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns The auction's state.
+ */
+async function getAuctionState(chainId, auction, provider) {
+    try {
+        const contract = (0, _helpers_1.getAuctionContract)(chainId, auction, provider);
+        const [details, paymentToken, paused, ended] = await Promise.all([
+            contract.getDetails(),
+            contract.token(),
+            contract.paused(),
+            contract.checkAuctionEnded(),
+        ]);
+        const underlying = await (0, _helpers_1.getZenoContract)(chainId, details.zenoAddress, contract.runner).underlyingAsset();
+        return {
+            auction: details.auctionAddress,
+            zeno: details.zenoAddress,
+            paymentToken,
+            issuer: details.issuer,
+            fundingMode: Number(details.fundingMode),
+            startTime: details.auctionStartTime,
+            endTime: details.auctionEndTime,
+            startingPrice: (0, amount_1.toTokenAmount)(chainId, paymentToken, details.startingPrice),
+            reservePrice: (0, amount_1.toTokenAmount)(chainId, paymentToken, details.reservePrice),
+            isFixedPrice: details.startingPrice === details.reservePrice,
+            price: (0, amount_1.toTokenAmount)(chainId, paymentToken, details.price),
+            totalAllocated: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalZENOAllocated),
+            totalRemaining: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalZENORemaining),
+            paused,
+            ended,
+        };
+    }
+    catch (error) {
+        throw (0, rpcError_1.toRpcError)("zeno.getAuctionState", error, { chainId, address: auction });
+    }
+}
+exports.default = getAuctionState;

package/dist/contracts/zeno/getAuctions.js

@@ -1,51 +1,56 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const ethers_1 = require("ethers");
+const chains_1 = __importDefault(require("../../configs/chains"));
 const contracts_1 = require("../../utils/contracts");
 const artifacts_1 = require("../../utils/artifacts");
 const amount_1 = require("../../utils/amount");
+const rpcError_1 = require("../../utils/rpcError");
+const _helpers_1 = require("./_helpers");
 /**
  * Lists every auction created by the AuctionFactory.
  * @param chainId The chain id.
- * @param signer The signer to read with.
- * @returns One record per auction. Price and bid amounts use the auction's payment token, ZENO amounts the ZENO
- * token; decimals and symbols come from the chain config registry and fall back to 18 when the token is not listed.
+ * @param provider The provider to read with. Defaults to the chain's first configured RPC.
+ * @returns One record per auction. Price amounts use the auction's payment token, ZENO amounts the ZENO's underlying,
+ * whose decimals ZENO shares; decimals and symbols come from the chain config registry and fall back to 18 when the
+ * token is not listed.
  */
-async function getAuctions(chainId, signer) {
-    if (!signer) {
-        throw new Error("Wallet not connected");
+async function getAuctions(chainId, provider) {
+    if (!provider) {
+        provider = new ethers_1.ethers.JsonRpcProvider(chains_1.default[chainId].rpcs[0]);
     }
+    const auctionFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "auctionfactory");
     try {
-        const auctionFactoryAddress = (0, contracts_1.getContractAddress)(chainId, "auctionfactory");
-        const auctionFactoryABI = (0, artifacts_1.getABI)("auctionfactory");
-        const auctionFactoryContract = new ethers_1.ethers.Contract(auctionFactoryAddress, auctionFactoryABI, signer);
-        const auctionsCount = await auctionFactoryContract.getAuctionCount();
-        const auctions = [];
-        for (let i = 0; i < auctionsCount; i++) {
-            const auction = await auctionFactoryContract.getAuctionDetails(i);
-            const auctionContract = new ethers_1.ethers.Contract(auction.auctionAddress, (0, artifacts_1.getABI)("auction"), signer);
-            const paymentToken = await auctionContract.token();
-            auctions.push({
-                auctionAddress: auction.auctionAddress,
-                zenoAddress: auction.zenoAddress,
-                businessAddress: auction.businessAddress,
-                auctionStartTime: auction.auctionStartTime,
-                auctionEndTime: auction.auctionEndTime,
-                startingPrice: (0, amount_1.toTokenAmount)(chainId, paymentToken, auction.startingPrice),
-                reservePrice: (0, amount_1.toTokenAmount)(chainId, paymentToken, auction.reservePrice),
-                price: (0, amount_1.toTokenAmount)(chainId, paymentToken, auction.price),
-                totalZENOAllocated: (0, amount_1.toTokenAmount)(chainId, auction.zenoAddress, auction.totalZENOAllocated),
-                totalZENORemaining: (0, amount_1.toTokenAmount)(chainId, auction.zenoAddress, auction.totalZENORemaining),
-                lastBidTime: auction.lastBidTime,
-                lastBidder: auction.lastBidder,
-                lastBidAmount: (0, amount_1.toTokenAmount)(chainId, paymentToken, auction.lastBidAmount),
-            });
-        }
-        return auctions;
+        const auctionFactoryContract = new ethers_1.ethers.Contract(auctionFactoryAddress, (0, artifacts_1.getABI)("auctionfactory"), provider);
+        const auctionAddresses = await auctionFactoryContract.getAuctions();
+        return await Promise.all(auctionAddresses.map(async (address) => {
+            const auctionContract = new ethers_1.ethers.Contract(address, (0, artifacts_1.getABI)("auction"), provider);
+            const [details, tokenAddress] = await Promise.all([
+                auctionContract.getDetails(),
+                auctionContract.token(),
+            ]);
+            const underlying = await (0, _helpers_1.getZenoContract)(chainId, details.zenoAddress, provider).underlyingAsset();
+            return {
+                auctionAddress: details.auctionAddress,
+                zenoAddress: details.zenoAddress,
+                tokenAddress,
+                issuer: details.issuer,
+                auctionStartTime: details.auctionStartTime,
+                auctionEndTime: details.auctionEndTime,
+                startingPrice: (0, amount_1.toTokenAmount)(chainId, tokenAddress, details.startingPrice),
+                reservePrice: (0, amount_1.toTokenAmount)(chainId, tokenAddress, details.reservePrice),
+                price: (0, amount_1.toTokenAmount)(chainId, tokenAddress, details.price),
+                totalZENOAllocated: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalZENOAllocated),
+                totalZENORemaining: (0, _helpers_1.toZenoAmount)(chainId, underlying, details.totalZENORemaining),
+                fundingMode: Number(details.fundingMode),
+            };
+        }));
     }
     catch (error) {
-        console.error("Error getting auctions:", error);
-        throw new Error(`Failed to get auctions: ${error.message}`);
+        throw (0, rpcError_1.toRpcError)("zeno.getAuctions", error, { chainId, address: auctionFactoryAddress });
     }
 }
 exports.default = getAuctions;