@raac/rpc 1.2.0-beta.9 → 2.0.0-beta.0

package/dist/types/contracts/tokens/veRAAC/getCheckpoint.d.ts

@@ -1,8 +1,10 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 export interface Checkpoint {
     fromBlock: number;
-    value: string;
+    /** Voting power at `fromBlock`, in veRAAC base units. */
+    value: TokenAmount;
 }
 /**
  * Gets the user's voting power checkpoints (block-based).
@@ -11,6 +13,6 @@ export interface Checkpoint {
  * @param chainId - The chain/network to use.
  * @param address - The address to query.
  * @param provider - Optional ethers.js Provider instance.
- * @returns Array of checkpoints with block number and voting power value.
+ * @returns Array of checkpoints with block number and voting power value; `value` uses the `veraac` asset decimals from the chain config.
  */
 export declare const getCheckpoint: (chainId: ChainId, address: string, provider?: Provider) => Promise<Checkpoint[]>;

package/dist/types/contracts/tokens/veRAAC/getClaimable.d.ts

@@ -1,5 +1,6 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 /**
  * Returns the claimable rewards for a specific user and reward token.
  *
@@ -8,6 +9,6 @@ import { ChainId } from "../../../configs/chains";
  * @param rewardTokenAddress - The address of the reward token.
  * @param maxDistributions - Maximum number of distributions to process.
  * @param provider - Optional ethers.js Provider instance.
- * @returns The claimable rewards formatted in ether units.
+ * @returns The claimable rewards in base units of the reward token, with decimals and symbol from the token registry (18 decimals and no symbol if the token is not listed).
  */
-export declare const getClaimable: (chainId: ChainId, userAddress: string, rewardTokenAddress: string, maxDistributions: number, provider?: Provider) => Promise<string>;
+export declare const getClaimable: (chainId: ChainId, userAddress: string, rewardTokenAddress: string, maxDistributions: number, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/tokens/veRAAC/getClaimed.d.ts

@@ -1,5 +1,6 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 /**
  * Returns the claimed rewards for a specific user and reward token.
  *
@@ -7,6 +8,6 @@ import { ChainId } from "../../../configs/chains";
  * @param userAddress - The address of the user.
  * @param rewardTokenAddress - The address of the reward token.
  * @param provider - Optional ethers.js Provider instance.
- * @returns The claimed rewards formatted in ether units.
+ * @returns The claimed rewards in base units of the reward token, with decimals and symbol from the token registry (18 decimals and no symbol if the token is not listed).
  */
-export declare const getClaimed: (chainId: ChainId, userAddress: string, rewardTokenAddress: string, provider?: Provider) => Promise<string>;
+export declare const getClaimed: (chainId: ChainId, userAddress: string, rewardTokenAddress: string, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/tokens/veRAAC/getEarned.d.ts

@@ -1,5 +1,6 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 /**
  * Returns the earned rewards (total of claimed + claimable) for a user.
  *
@@ -8,6 +9,6 @@ import { ChainId } from "../../../configs/chains";
  * @param rewardTokenAddress - The address of the reward token.
  * @param maxDistributions - Maximum number of distributions to process.
  * @param provider - Optional ethers.js Provider instance.
- * @returns The total earned rewards formatted in ether units.
+ * @returns The total earned rewards in base units of the reward token, with decimals and symbol from the token registry (18 decimals and no symbol if the token is not listed).
  */
-export declare const getEarned: (chainId: ChainId, userAddress: string, rewardTokenAddress: string, maxDistributions: number, provider?: Provider) => Promise<string>;
+export declare const getEarned: (chainId: ChainId, userAddress: string, rewardTokenAddress: string, maxDistributions: number, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/tokens/veRAAC/getGlobalLockInfo.d.ts

@@ -1,7 +1,9 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 export interface GlobalLockInfo {
-    totalLocked: string;
+    /** Total RAAC locked across all users, in RAAC base units. */
+    totalLocked: TokenAmount;
     maxLockEpochs: number;
     epochDuration: number;
 }
@@ -10,6 +12,6 @@ export interface GlobalLockInfo {
  *
  * @param chainId - The chain/network to use.
  * @param provider - Optional ethers.js Provider instance.
- * @returns Global lock info including totalLocked, maxLockEpochs, and epochDuration.
+ * @returns Global lock info including totalLocked (RAAC, `raactoken` asset decimals from the chain config), maxLockEpochs, and epochDuration (seconds).
  */
 export declare const getGlobalLockInfo: (chainId: ChainId, provider?: Provider) => Promise<GlobalLockInfo>;

package/dist/types/contracts/tokens/veRAAC/getLockedBalance.d.ts

@@ -1,11 +1,12 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 /**
  * Gets the locked balance of an account in the veRAAC contract.
  *
  * @param chainId - The chain/network to use.
  * @param address - The address to check the locked balance for.
  * @param provider - Optional ethers.js Provider instance.
- * @returns The locked balance of the account formatted in ether units.
+ * @returns The RAAC locked by the account, in RAAC base units, with the `raactoken` asset decimals from the chain config.
  */
-export declare const getLockedBalance: (chainId: ChainId, address: string, provider?: Provider) => Promise<string>;
+export declare const getLockedBalance: (chainId: ChainId, address: string, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/tokens/veRAAC/getLocks.d.ts

@@ -1,7 +1,10 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 export interface LockedBalance {
-    amount: string;
+    /** RAAC locked in this position, in RAAC base units. */
+    amount: TokenAmount;
+    /** Unlock timestamp in seconds. */
     unlockTime: number;
 }
 /**
@@ -9,6 +12,6 @@ export interface LockedBalance {
  * @param chainId - The chain/network to use.
  * @param address - The address to check locks for.
  * @param provider - Optional ethers.js Provider instance.
- * @returns Array of active locks with amount and unlock time.
+ * @returns Array of active locks with amount (RAAC, `raactoken` asset decimals from the chain config) and unlock time.
  */
 export declare const getLocks: (chainId: ChainId, address: string, provider?: Provider) => Promise<LockedBalance[]>;

package/dist/types/contracts/tokens/veRAAC/getMinLockAmount.d.ts

@@ -0,0 +1,15 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
+/**
+ * Gets the smallest RAAC lock veRAAC will accept.
+ *
+ * Consumers that schedule unlocks need this: the liquid locker refuses to leave a remainder
+ * below this threshold in a bucket, taking the whole bucket instead, so an unlock request can
+ * be rounded up by as much as this amount.
+ *
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The minimum lock amount in RAAC base units, with the `raactoken` asset decimals from the chain config.
+ */
+export declare const getMinLockAmount: (chainId: ChainId, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/tokens/veRAAC/getRagequitRequest.d.ts

@@ -1,10 +1,15 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 export interface RagequitRequest {
-    amount: string;
-    grossAmount: string;
-    fixedPenaltyAmount: string;
-    variablePenaltyAmount: string;
+    /** Net RAAC the user receives after all penalties, in RAAC base units. */
+    amount: TokenAmount;
+    /** Total locked RAAC being exited, in RAAC base units. */
+    grossAmount: TokenAmount;
+    /** Fixed RAAC penalty, in RAAC base units. */
+    fixedPenaltyAmount: TokenAmount;
+    /** Time-weighted variable RAAC penalty, in RAAC base units. */
+    variablePenaltyAmount: TokenAmount;
     readyAt: number;
 }
 /**
@@ -13,6 +18,6 @@ export interface RagequitRequest {
  * @param chainId - The chain/network to use.
  * @param address - The address to query.
  * @param provider - Optional ethers.js Provider instance.
- * @returns The ragequit request data, or null values if none pending.
+ * @returns The ragequit request; amounts use the `raactoken` asset decimals from the chain config and are zero when none is pending.
  */
 export declare const getRagequitRequest: (chainId: ChainId, address: string, provider?: Provider) => Promise<RagequitRequest>;

package/dist/types/contracts/tokens/veRAAC/getRawBalanceOf.d.ts

@@ -1,11 +1,12 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 /**
  * Gets the raw ERC20 balance (minted veRAAC, before decay).
  *
  * @param chainId - The chain/network to use.
  * @param address - The address to query.
  * @param provider - Optional ethers.js Provider instance.
- * @returns The raw balance formatted in ether units.
+ * @returns The raw balance in veRAAC base units, with the `veraac` asset decimals from the chain config.
  */
-export declare const getRawBalanceOf: (chainId: ChainId, address: string, provider?: Provider) => Promise<string>;
+export declare const getRawBalanceOf: (chainId: ChainId, address: string, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/tokens/veRAAC/getRawTotalSupply.d.ts

@@ -1,10 +1,11 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 /**
  * Gets the raw total supply (minted veRAAC, before decay).
  *
  * @param chainId - The chain/network to use.
  * @param provider - Optional ethers.js Provider instance.
- * @returns The raw total supply formatted in ether units.
+ * @returns The raw total supply in veRAAC base units, with the `veraac` asset decimals from the chain config.
  */
-export declare const getRawTotalSupply: (chainId: ChainId, provider?: Provider) => Promise<string>;
+export declare const getRawTotalSupply: (chainId: ChainId, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/tokens/veRAAC/getTotalSupply.d.ts

@@ -1,10 +1,12 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 /**
+ * Gets the current total veRAAC voting power of a veRAAC contract.
  *
- * @param {string} contractAddress
- * @param {number} chainId
- * @param {ethers.JsonRpcProvider} [provider]
- * @returns {Promise<string>}
+ * @param chainId - The chain/network to use; only needed when no provider is given.
+ * @param contractAddress - The veRAAC contract address.
+ * @param provider - An ethers.js Provider instance.
+ * @returns The total supply in veRAAC base units, with decimals and symbol from the token registry (18 decimals when the chain or token is not configured).
  */
-export declare const getTotalSupply: (chainId: ChainId, contractAddress: string, provider: Provider) => Promise<string>;
+export declare const getTotalSupply: (chainId: ChainId, contractAddress: string, provider: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/tokens/veRAAC/getTotalSupplyAt.d.ts

@@ -1,11 +1,12 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 /**
  * Gets the total supply of veRAAC tokens at a specific block.
  *
  * @param chainId - The chain/network to use.
  * @param blockNumber - The block number to check the total supply at.
  * @param provider - Optional ethers.js Provider instance.
- * @returns The total supply at the specified block formatted in ether units.
+ * @returns The total supply at the specified block in veRAAC base units, with the `veraac` asset decimals from the chain config.
  */
-export declare const getTotalSupplyAt: (chainId: ChainId, blockNumber: number | bigint, provider?: Provider) => Promise<string>;
+export declare const getTotalSupplyAt: (chainId: ChainId, blockNumber: number | bigint, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/tokens/veRAAC/getTotalSupplyAtTime.d.ts

@@ -1,11 +1,12 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 /**
  * Gets the total voting power across all accounts at a specific timestamp.
  *
  * @param chainId - The chain/network to use.
  * @param timestamp - The timestamp to check the total supply at (in seconds).
  * @param provider - Optional ethers.js Provider instance.
- * @returns The total voting power at the specified timestamp formatted in ether units.
+ * @returns The total voting power at the specified timestamp in veRAAC base units, with the `veraac` asset decimals from the chain config.
  */
-export declare const getTotalSupplyAtTime: (chainId: ChainId, timestamp: number | bigint, provider?: Provider) => Promise<string>;
+export declare const getTotalSupplyAtTime: (chainId: ChainId, timestamp: number | bigint, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/tokens/veRAAC/getUserPointHistory.d.ts

@@ -1,11 +1,15 @@
 import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 export interface UserPoint {
-    bias: string;
-    totalLocked: string;
+    /** Voting power recorded at this point, in veRAAC base units (same scale as the locked RAAC). */
+    bias: TokenAmount;
+    /** RAAC locked at this point, in RAAC base units. */
+    totalLocked: TokenAmount;
     ts: number;
     blk: number;
-    accExpiredLocks: string;
+    /** Cumulative RAAC from expired locks, in RAAC base units. */
+    accExpiredLocks: TokenAmount;
 }
 /**
  * Gets the user's point history from the veRAAC contract.
@@ -15,6 +19,6 @@ export interface UserPoint {
  * @param chainId - The chain/network to use.
  * @param address - The address to query.
  * @param provider - Optional ethers.js Provider instance.
- * @returns Array of user point history entries.
+ * @returns Array of user point history entries; `bias` uses the `veraac` asset decimals, `totalLocked` and `accExpiredLocks` the `raactoken` asset decimals, from the chain config.
  */
 export declare const getUserPointHistory: (chainId: ChainId, address: string, provider?: Provider) => Promise<UserPoint[]>;

package/dist/types/contracts/tokens/veRAAC/increase.d.ts

@@ -5,9 +5,9 @@ import { ChainId } from "../../../configs/chains";
  * Adds more RAAC tokens to an existing lock position without changing the unlock time.
  *
  * @param chainId - The chain/network to use.
- * @param amountToAdd - Amount of additional RAAC tokens to add to the lock.
+ * @param amountToAdd - Additional RAAC to add to the lock, in RAAC base units (18 decimals).
  * @param epochEnd - The epoch end time of the existing lock to increase.
  * @param signer - An ethers.js Signer instance (must be connected to wallet).
  * @returns Transaction receipt after the increase is made.
  */
-export declare const increase: (chainId: ChainId, amountToAdd: string | number | bigint, epochEnd: number, signer: Signer) => Promise<ethers.ContractTransactionResponse>;
+export declare const increase: (chainId: ChainId, amountToAdd: bigint, epochEnd: number, signer: Signer) => Promise<ethers.ContractTransactionResponse>;

package/dist/types/contracts/tokens/veRAAC/increaseWithApproval.d.ts

@@ -1,13 +1,13 @@
-import { ethers, Signer } from "ethers";
+import { Signer } from "ethers";
 import { ChainId } from "../../../configs/chains";
 /**
  * Increases the amount of tokens in an existing lock, auto-approving the veRAAC
  * contract first if the current allowance is insufficient.
  *
  * @param chainId - The chain/network to use.
- * @param amountToAdd - Additional RAAC amount to add to the existing lock (decimal string).
+ * @param amountToAdd - Additional RAAC to add to the existing lock, in RAAC base units (18 decimals).
  * @param epochEnd - The epoch end time of the existing lock to increase.
  * @param signer - An ethers.js Signer (must be connected to wallet).
  * @returns Transaction receipt of the increase tx.
  */
-export declare const increaseWithApproval: (chainId: ChainId, amountToAdd: string, epochEnd: number, signer: Signer) => Promise<ethers.ContractTransactionResponse>;
+export declare const increaseWithApproval: (chainId: ChainId, amountToAdd: bigint, epochEnd: number, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/tokens/veRAAC/index.d.ts

@@ -5,7 +5,7 @@ export { getLocks, type LockedBalance } from "./getLocks";
 export { getGlobalLockInfo, type GlobalLockInfo } from "./getGlobalLockInfo";
 export { getMaxLockEnd } from "./getMaxLockEnd";
 export { getMinLockEnd } from "./getMinLockEnd";
-export { getEffectiveLockEnd } from "./getEffectiveLockEnd";
+export { getMinLockAmount } from "./getMinLockAmount";
 export { getBalanceAt } from "./getBalanceAt";
 export { getBalanceAtTime } from "./getBalanceAtTime";
 export { getTotalSupplyAt } from "./getTotalSupplyAt";

package/dist/types/contracts/tokens/veRAAC/lock.d.ts

@@ -4,9 +4,9 @@ import { ChainId } from "../../../configs/chains";
  * Locks RAAC tokens for a specified duration to receive veRAAC voting power.
  *
  * @param chainId - The chain/network to use.
- * @param amount - The amount of RAAC tokens to lock.
+ * @param amount - The amount of RAAC to lock, in RAAC base units (18 decimals).
  * @param epochs - Number of epochs to lock tokens for (1 epoch = 7 days).
  * @param signer - An ethers.js Signer instance (must be connected to wallet).
  * @returns Transaction receipt after the lock is made.
  */
-export declare const lock: (chainId: ChainId, amount: string | number | bigint, epochs: number, signer: Signer) => Promise<ethers.ContractTransactionResponse>;
+export declare const lock: (chainId: ChainId, amount: bigint, epochs: number, signer: Signer) => Promise<ethers.ContractTransactionResponse>;

package/dist/types/contracts/tokens/veRAAC/lockWithApproval.d.ts

@@ -1,4 +1,4 @@
-import { ethers, Signer } from "ethers";
+import { Signer } from "ethers";
 import { ChainId } from "../../../configs/chains";
 /**
  * Locks RAAC tokens, auto-approving the veRAAC contract first if the current
@@ -6,9 +6,9 @@ import { ChainId } from "../../../configs/chains";
  * orchestrate the approve+lock dance themselves.
  *
  * @param chainId - The chain/network to use.
- * @param amount - The amount of RAAC tokens to lock (decimal string).
+ * @param amount - The amount of RAAC to lock, in RAAC base units (18 decimals).
  * @param epochs - Number of epochs to lock tokens for.
  * @param signer - An ethers.js Signer (must be connected to wallet).
  * @returns Transaction receipt of the lock tx.
  */
-export declare const lockWithApproval: (chainId: ChainId, amount: string, epochs: number, signer: Signer) => Promise<ethers.ContractTransactionResponse>;
+export declare const lockWithApproval: (chainId: ChainId, amount: bigint, epochs: number, signer: Signer) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/tokens/xPM/getBalance.d.ts

@@ -1,2 +1,12 @@
+import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
-export declare const getBalance: (chainId: ChainId, address: string) => Promise<string>;
+import { TokenAmount } from "../../../utils/amount";
+/**
+ * Gets the xPM balance of an account.
+ *
+ * @param chainId - The chain/network to use.
+ * @param address - The account to query.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The balance in xPM base units, with the `xpm` asset decimals from the chain config.
+ */
+export declare const getBalance: (chainId: ChainId, address: string, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/tokens/xPM/getTotalSupply.d.ts

@@ -1,7 +1,11 @@
+import { Provider } from "ethers";
 import { ChainId } from "../../../configs/chains";
+import { TokenAmount } from "../../../utils/amount";
 /**
+ * Gets the xPM total supply.
  *
- * @param {number} chainId
- * @returns {Promise<string>}
+ * @param chainId - The chain/network to use.
+ * @param provider - Optional ethers.js Provider instance.
+ * @returns The total supply in xPM base units, with the `xpm` asset decimals from the chain config.
  */
-export declare const getTotalSupply: (chainId: ChainId) => Promise<string>;
+export declare const getTotalSupply: (chainId: ChainId, provider?: Provider) => Promise<TokenAmount>;

package/dist/types/contracts/zap/aladdin/zap.d.ts

@@ -4,5 +4,13 @@ import { ChainId } from "../../../configs/chains";
  * Run the configured route for `fromToken → toToken`, assuming `fromToken` is already
  * sitting in the zap contract (or msg.value covers ETH). Use `zapFrom` if the caller
  * is the holder of the input token instead.
+ * @param chainId The chain id.
+ * @param fromToken The input token address.
+ * @param amountIn The input amount in `fromToken` base units.
+ * @param toToken The output token address.
+ * @param minOut The minimum output in `toToken` base units.
+ * @param signer The caller.
+ * @param value ETH to send, in wei.
+ * @returns The sent transaction, after it is mined.
  */
-export declare const zap: (chainId: ChainId, fromToken: string, amountIn: string | number | bigint, toToken: string, minOut: string | number | bigint, signer: Signer, value?: string | number | bigint) => Promise<import("ethers").ContractTransactionResponse>;
+export declare const zap: (chainId: ChainId, fromToken: string, amountIn: bigint, toToken: string, minOut: bigint, signer: Signer, value?: bigint) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/zap/aladdin/zapFrom.d.ts

@@ -4,5 +4,13 @@ import { ChainId } from "../../../configs/chains";
  * Pull `amountIn` of `fromToken` from the caller into the zap, then run the configured
  * route to `toToken`. Caller must approve the zap on `fromToken` for ERC20 inputs,
  * or pass `value` for ETH input.
+ * @param chainId The chain id.
+ * @param fromToken The input token address.
+ * @param amountIn The input amount in `fromToken` base units.
+ * @param toToken The output token address.
+ * @param minOut The minimum output in `toToken` base units.
+ * @param signer The caller.
+ * @param value ETH to send, in wei.
+ * @returns The sent transaction, after it is mined.
  */
-export declare const zapFrom: (chainId: ChainId, fromToken: string, amountIn: string | number | bigint, toToken: string, minOut: string | number | bigint, signer: Signer, value?: string | number | bigint) => Promise<import("ethers").ContractTransactionResponse>;
+export declare const zapFrom: (chainId: ChainId, fromToken: string, amountIn: bigint, toToken: string, minOut: bigint, signer: Signer, value?: bigint) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/zap/aladdin/zapWithRoutes.d.ts

@@ -4,8 +4,17 @@ import { ChainId } from "../../../configs/chains";
  * Run an explicit list of packed-uint256 routes from `fromToken` to `toToken`.
  * Routes are validated client-side first; pass `skipValidation: true` only if you
  * really know what you're doing.
+ * @param chainId The chain id.
+ * @param fromToken The input token address.
+ * @param amountIn The input amount in `fromToken` base units.
+ * @param toToken The output token address.
+ * @param routes The packed uint256 routes.
+ * @param minOut The minimum output in `toToken` base units.
+ * @param signer The caller.
+ * @param options `value` is the ETH to send, in wei; `skipValidation` skips client-side route checks.
+ * @returns The sent transaction, after it is mined.
  */
-export declare const zapWithRoutes: (chainId: ChainId, fromToken: string, amountIn: string | number | bigint, toToken: string, routes: (string | bigint | number)[], minOut: string | number | bigint, signer: Signer, options?: {
-    value?: string | number | bigint;
+export declare const zapWithRoutes: (chainId: ChainId, fromToken: string, amountIn: bigint, toToken: string, routes: (string | bigint | number)[], minOut: bigint, signer: Signer, options?: {
+    value?: bigint;
     skipValidation?: boolean;
 }) => Promise<import("ethers").ContractTransactionResponse>;

package/dist/types/contracts/zeno/createAuction.d.ts

@@ -1,4 +1,17 @@
 import { Signer } from "ethers";
 import { ChainId } from "../../configs/chains/index";
+/**
+ * Creates a ZENO auction through the AuctionFactory.
+ * @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 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.
+ */
 declare function createAuction(chainId: ChainId, zenoAddress: string, usdcAddress: string, businessAddress: string, auctionStartTime: bigint, auctionEndTime: bigint, startingPrice: bigint, reservePrice: bigint, totalZenoAllocated: bigint, signer: Signer): Promise<void>;
 export default createAuction;

package/dist/types/contracts/zeno/getAuctions.d.ts

@@ -1,4 +1,41 @@
 import { Signer } from "ethers";
 import { ChainId } from "../../configs/chains/index";
-declare function getAuctions(chainId: ChainId, signer: Signer): Promise<any[]>;
+import { TokenAmount } from "../../utils/amount";
+/** A ZENO auction, with its amounts in base units. */
+export interface AuctionDetails {
+    /** The auction contract address. */
+    auctionAddress: string;
+    /** The ZENO bond token sold. */
+    zenoAddress: string;
+    /** The issuer receiving the proceeds. */
+    businessAddress: string;
+    /** UNIX timestamp (seconds) the auction starts. */
+    auctionStartTime: bigint;
+    /** UNIX timestamp (seconds) the auction ends. */
+    auctionEndTime: bigint;
+    /** Dutch auction starting price, in payment token base units per whole ZENO. */
+    startingPrice: TokenAmount;
+    /** Dutch auction reserve price, in payment token base units per whole ZENO. */
+    reservePrice: TokenAmount;
+    /** Current Dutch auction price, in payment token base units per whole ZENO. */
+    price: TokenAmount;
+    /** ZENO offered, in ZENO base units. */
+    totalZENOAllocated: TokenAmount;
+    /** ZENO still unsold, in ZENO base units. */
+    totalZENORemaining: TokenAmount;
+    /** UNIX timestamp (seconds) of the last bid. */
+    lastBidTime: bigint;
+    /** The address of the last bidder. */
+    lastBidder: string;
+    /** The last bid, in payment token base units. */
+    lastBidAmount: TokenAmount;
+}
+/**
+ * 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.
+ */
+declare function getAuctions(chainId: ChainId, signer: Signer): Promise<AuctionDetails[]>;
 export default getAuctions;

package/dist/types/index.d.ts

@@ -1,2 +1,3 @@
 import RPCLibrary from "./RPCLibrary";
+export * from "./utils/amount";
 export default RPCLibrary;

package/dist/types/methods/approveToken.d.ts

@@ -1,5 +1,14 @@
 import { Signer } from "ethers";
 import { ChainId } from "../configs/chains/index";
 import { ContractType } from "../utils/artifacts";
-declare const approveToken: (chainId: ChainId, tokenSymbol: ContractType, spender: string, amount: string, signer: Signer) => Promise<any>;
+/**
+ * Approves `spender` to pull a token from the signer.
+ * @param chainId The chain id.
+ * @param tokenSymbol The token key in the chain config.
+ * @param spender The address to approve.
+ * @param amount The allowance in the token's base units. Pass `ethers.MaxUint256` for an unlimited approval.
+ * @param signer The token owner.
+ * @returns The transaction receipt.
+ */
+declare const approveToken: (chainId: ChainId, tokenSymbol: ContractType, spender: string, amount: bigint, signer: Signer) => Promise<any>;
 export default approveToken;

package/dist/types/methods/commons/checkAllowance.d.ts

@@ -1,6 +1,16 @@
 import { Provider } from "ethers";
 import { ContractType } from "../../utils/artifacts";
 import { ChainId } from "../../configs/chains/index";
-declare const checkAllowance: (chainId: ChainId, tokenId: ContractType, address: string, spenderAddress: string, provider: Provider) => Promise<bigint>;
+import { TokenAmount } from "../../utils/amount";
+/**
+ * Reads how much of a token `spenderAddress` may pull from `address`.
+ * @param chainId The chain id.
+ * @param tokenId The token key in the chain config.
+ * @param address The token owner.
+ * @param spenderAddress The approved spender.
+ * @param provider The provider to read with.
+ * @returns The allowance in base units with the token's decimals.
+ */
+declare const checkAllowance: (chainId: ChainId, tokenId: ContractType, address: string, spenderAddress: string, provider: Provider) => Promise<TokenAmount>;
 export default checkAllowance;
 export { checkAllowance };

package/dist/types/methods/getAssetBalance.d.ts

@@ -1,6 +1,15 @@
 import { Signer } from "ethers";
 import { ChainId } from "../configs/chains/index";
 import { AssetType } from "../utils/artifacts";
-declare const getAssetBalance: (chainId: ChainId, address: string, assetId: AssetType, signer: Signer) => Promise<string>;
+import { TokenAmount } from "../utils/amount";
+/**
+ * Reads a wallet's balance of a configured asset or native ETH.
+ * @param chainId The chain id.
+ * @param address The wallet address.
+ * @param assetId The asset key in the chain config, or `"eth"` for native ETH.
+ * @param signer A connected signer whose provider is used for the read.
+ * @returns The balance in base units with the asset's decimals (18 and `"ETH"` for native ETH).
+ */
+declare const getAssetBalance: (chainId: ChainId, address: string, assetId: AssetType, signer: Signer) => Promise<TokenAmount>;
 export default getAssetBalance;
 export { getAssetBalance };

package/dist/types/minter/_helpers.d.ts

@@ -1,4 +1,12 @@
 import { Provider, Signer } from "ethers";
 import { ChainId } from "../configs/chains";
 import { RAACMinter } from "../typechain-types";
+import { TokenAmount } from "../utils/amount";
 export declare function getMinterContract(chainId: ChainId, runner?: Provider | Signer): Promise<RAACMinter>;
+/**
+ * Builds a RAAC `TokenAmount` from the registry (`raactoken` decimals and symbol).
+ * @param chainId The chain id.
+ * @param value The raw RAAC amount.
+ * @returns The amount.
+ */
+export declare function toRaacAmount(chainId: ChainId, value: bigint): TokenAmount;

package/dist/types/minter/calculateScheduledMintableAmount.d.ts

@@ -1,8 +1,10 @@
 import { Provider } from "ethers";
 import { ChainId } from "../configs/chains";
+import { TokenAmount } from "../utils/amount";
 /**
  * Returns the total RAAC scheduled to be mintable between two timestamps,
  * applying the geometric weekly emission reduction (see EmissionSchedule.sol).
  * Both `startPeriod` and `endPeriod` are absolute UNIX timestamps in seconds.
+ * @returns The RAAC amount, with the registry `raactoken` decimals and symbol.
  */
-export declare const calculateScheduledMintableAmount: (chainId: ChainId, startPeriod: number | bigint, endPeriod: number | bigint, provider?: Provider) => Promise<bigint>;
+export declare const calculateScheduledMintableAmount: (chainId: ChainId, startPeriod: number | bigint, endPeriod: number | bigint, provider?: Provider) => Promise<TokenAmount>;