@metaplex-foundation/genesis 0.12.4

package/dist/src/auction.js

@@ -0,0 +1,416 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.totalBidSol = exports.solPerToken = exports.uSolPerTokenBasis = exports.toSol = exports.toUSol = exports.getBidFillAmount = exports.isBidPartiallyFilled = exports.isBidLosing = exports.isBidWinning = exports.createMicroLamports = exports.fetchAuctionWinners = exports.calculateAuctionWinners = exports.findAuctionBids = exports.getAuctionTreeNode = exports.getAllAuctionTreeNodes = exports.lamportsToUlamports = exports.MICRO_LAMPORTS_PER_LAMPORT = void 0;
+const umi_1 = require("@metaplex-foundation/umi");
+const generated_1 = require("./generated");
+const hooked_1 = require("./hooked");
+exports.MICRO_LAMPORTS_PER_LAMPORT = 1000000;
+/**
+ * Converts lamports to micro-lamports for auction pricing.
+ *
+ * Auction bids use micro-lamports (1/1,000,000 of a lamport) for sub-lamport precision.
+ * This allows for finer granularity in token pricing.
+ *
+ * @param lamports - The amount in lamports to convert
+ * @returns The equivalent amount in micro-lamports
+ *
+ * @example
+ * ```typescript
+ * // 0.5 SOL per token = 500,000,000 lamports per token
+ * const pricePerToken = lamportsToUlamports(500_000_000);
+ *
+ * // Use in auction bid
+ * await placeAuctionBidV1(umi, {
+ *   // ... other params
+ *   pricePerToken,
+ *   // ...
+ * }).sendAndConfirm(umi);
+ * ```
+ */
+function lamportsToUlamports(lamportsInput) {
+    return BigInt(lamportsInput) * BigInt(1000000);
+}
+exports.lamportsToUlamports = lamportsToUlamports;
+/**
+ * Retrieves all nodes from an auction AVL tree.
+ *
+ * @param tree - The auction AVL tree to extract nodes from
+ * @returns An array of all auction nodes in the tree, in allocation order
+ *
+ * @example
+ * ```typescript
+ * const tree = await fetchAuctionAVLTreeV1(umi, treePda);
+ * const allNodes = getAllAuctionTreeNodes(tree);
+ * console.log(`Tree contains ${allNodes.length} nodes`);
+ * ```
+ */
+function getAllAuctionTreeNodes(tree) {
+    const nodes = [];
+    for (let i = 0; i < tree.allocator.size; i += 1) {
+        nodes.push((0, hooked_1.getAuctionNodeSerializer)().deserialize(tree.rawData, tree.rawDataOffset + i * hooked_1.AUCTION_NODE_SIZE)[0]);
+    }
+    return nodes;
+}
+exports.getAllAuctionTreeNodes = getAllAuctionTreeNodes;
+/**
+ * Retrieves a specific node from an auction AVL tree by its index.
+ *
+ * @param tree - The auction AVL tree to search in
+ * @param index - The 1-based index of the node to retrieve
+ * @returns The auction node at the specified index, or null if index is out of bounds
+ *
+ * @example
+ * ```typescript
+ * const tree = await fetchAuctionAVLTreeV1(umi, treePda);
+ * const node = getAuctionTreeNode(tree, 5);
+ * if (node) {
+ *   console.log(`Node 5 bid: ${node.bid.pricePerToken}`);
+ * }
+ * ```
+ */
+function getAuctionTreeNode(tree, index) {
+    if (index < 1 || index > tree.allocator.size) {
+        return null;
+    }
+    return (0, hooked_1.getAuctionNodeSerializer)().deserialize(tree.rawData, tree.rawDataOffset + (index - 1) * hooked_1.AUCTION_NODE_SIZE)[0];
+}
+exports.getAuctionTreeNode = getAuctionTreeNode;
+/**
+ * Finds all bids in the auction tree that meet or exceed the clearing price.
+ *
+ * Uses an in-order traversal of the AVL tree to efficiently collect qualifying bids.
+ * The function traverses from highest to lowest prices and stops when prices fall
+ * below the clearing price threshold.
+ *
+ * @param tree - The auction AVL tree containing all bids
+ * @param clearingPriceULamports - The minimum price in micro-lamports for a bid to qualify
+ * @returns Array of bids that meet or exceed the clearing price, sorted by price (highest first)
+ *
+ * @example
+ * ```typescript
+ * const tree = await fetchAuctionAVLTreeV1(umi, treePda);
+ * const clearingPrice = lamportsToMicroLamports(1_000_000); // 0.001 SOL
+ * const qualifyingBids = findAuctionBids(tree, clearingPrice);
+ * ```
+ */
+function findAuctionBids(tree, clearingPriceULamports) {
+    const bids = [];
+    // Use in-order traversal to collect winners efficiently
+    // Since AVL tree is sorted, we can traverse from highest to lowest
+    function collectBids(nodeIndex) {
+        if (nodeIndex === hooked_1.AUCTION_SENTINEL) {
+            return;
+        }
+        const [node] = (0, hooked_1.getAuctionNodeSerializer)().deserialize(tree.rawData, tree.rawDataOffset + (nodeIndex - 1) * hooked_1.AUCTION_NODE_SIZE);
+        if (!node || node.bid.priceUlamports === 0n) {
+            // Skip deleted/inactive nodes
+            return;
+        }
+        // Always traverse right subtree first (higher prices)
+        // The right subtree might have matching bids even if current node doesn't
+        collectBids(node.right);
+        if (node.bid.priceUlamports >= clearingPriceULamports) {
+            bids.push(node.bid);
+            // Traverse left subtree to find bids of the same price
+            collectBids(node.left);
+        }
+    }
+    // Start traversal from root
+    collectBids(tree.allocator.root);
+    return bids;
+}
+exports.findAuctionBids = findAuctionBids;
+/**
+ * Calculates the winning bids for an auction based on clearing price and token allocation.
+ *
+ * This function determines which bids win tokens in the auction by:
+ * 1. Finding all bids at or above the clearing price
+ * 2. Sorting them by price (highest first) and bid number (earliest first for ties)
+ * 3. Allocating tokens until the supply is exhausted
+ *
+ * @param tree - The auction AVL tree containing all bids
+ * @param clearingPriceULamports - The clearing price in micro-lamports
+ * @param tokenAllocation - The total number of tokens available for distribution
+ * @returns Array of winning bids in order of priority
+ *
+ * @example
+ * ```typescript
+ * const tree = await fetchAuctionAVLTreeV1(umi, treePda);
+ * const clearingPrice = lamportsToMicroLamports(500_000_000); // 0.5 SOL
+ * const tokenSupply = 1_000_000n;
+ * const winners = calculateAuctionWinners(tree, clearingPrice, tokenSupply);
+ * ```
+ */
+function calculateAuctionWinners(tree, clearingPriceULamports, tokenAllocation) {
+    const bids = findAuctionBids(tree, clearingPriceULamports);
+    bids.sort((a, b) => {
+        if (a.priceUlamports === b.priceUlamports) {
+            if (a.bidNumber === b.bidNumber)
+                return 0;
+            return a.bidNumber < b.bidNumber ? -1 : 1;
+        }
+        return a.priceUlamports > b.priceUlamports ? -1 : 1;
+    });
+    const winners = [];
+    let remainingTokens = tokenAllocation;
+    while (remainingTokens > 0n) {
+        const bid = bids.shift();
+        if (!bid) {
+            break;
+        }
+        winners.push(bid);
+        remainingTokens -= bid.tokenQuantity;
+    }
+    return winners;
+}
+exports.calculateAuctionWinners = calculateAuctionWinners;
+/**
+ * Fetches all winning bids from an auction bucket.
+ *
+ * This async function retrieves the auction tree associated with a bucket
+ * and calculates the winning bids based on the bucket's clearing price
+ * and token allocation.
+ *
+ * @param umi - Umi context containing RPC, programs, and eddsa for Solana interaction
+ * @param auction - The auction bucket containing clearing price and allocation info
+ * @returns Promise resolving to an array of winning bids
+ * @throws Error if the auction tree is not found
+ *
+ * @example
+ * ```typescript
+ * const auctionBucket = await fetchAuctionBucketV1(umi, bucketPda);
+ * const winners = await getAuctionWinners(umi, auctionBucket);
+ * console.log(`${winners.length} winning bids found`);
+ * ```
+ */
+async function fetchAuctionWinners(umi, auction) {
+    const treePda = (0, generated_1.findAuctionAVLTreeV1Pda)(umi, {
+        bucket: auction.publicKey,
+    });
+    const tree = await (0, generated_1.safeFetchAuctionAVLTreeV1)(umi, treePda[0]);
+    if (!tree) {
+        throw new Error('Auction tree not found');
+    }
+    // Use the clearing price from the auction bucket
+    const { clearingPriceUlamports, tokenAllocation } = auction;
+    return calculateAuctionWinners(tree, clearingPriceUlamports, tokenAllocation);
+}
+exports.fetchAuctionWinners = fetchAuctionWinners;
+/**
+ * Creates a MicroSolAmount from either a bigint or an existing MicroSolAmount.
+ *
+ * @param amount - The amount as bigint or MicroSolAmount
+ * @returns A MicroSolAmount object
+ * @internal
+ */
+function createMicroLamports(amount) {
+    return typeof amount === 'bigint' ? (0, umi_1.microLamports)(amount) : amount;
+}
+exports.createMicroLamports = createMicroLamports;
+/**
+ * Determines if a bid is winning based on the auction's clearing price and bid number.
+ *
+ * A bid is considered winning if:
+ * - Its price exceeds the clearing price, OR
+ * - Its price equals the clearing price AND its bid number is at or before the clearing price bid number
+ *
+ * @param auction - The auction bucket with clearing price and clearing price bid number
+ * @param bid - The bid to check with price per token and bid number
+ * @returns True if the bid is winning, false otherwise
+ *
+ * @example
+ * ```typescript
+ * const auction = await fetchAuctionBucketV1(umi, auctionPda);
+ * const bid = await fetchAuctionBidV1(umi, bidPda);
+ * const isWinner = isBidWinning(auction, bid); // true (price exceeds clearing)
+ * ```
+ */
+function isBidWinning(auction, bid) {
+    const priceUlamports = createMicroLamports(bid.priceUlamports);
+    const clearingPrice = createMicroLamports(auction.clearingPriceUlamports);
+    if ((0, umi_1.isGreaterThanAmount)(priceUlamports, clearingPrice)) {
+        return true;
+    }
+    if ((0, umi_1.isEqualToAmount)(priceUlamports, clearingPrice) &&
+        bid.bidNumber <= auction.clearingPriceBidNumber) {
+        return true;
+    }
+    return false;
+}
+exports.isBidWinning = isBidWinning;
+/**
+ * Determines if a bid is losing (not winning) in the auction.
+ *
+ * This is the inverse of isBidWinning - a bid is losing if it doesn't meet
+ * the criteria for winning.
+ *
+ * @param auction - The auction bucket with clearing price and clearing price bid number
+ * @param bid - The bid to check with price per token and bid number
+ * @returns True if the bid is losing, false if winning
+ *
+ * @example
+ * ```typescript
+ * const auction = await fetchAuctionBucketV1(umi, auctionPda);
+ * const bid = await fetchAuctionBidV1(umi, bidPda);
+ * const isLoser = isBidLosing(auction, bid); // true (price below clearing)
+ * ```
+ */
+function isBidLosing(auction, bid) {
+    return !isBidWinning(auction, bid);
+}
+exports.isBidLosing = isBidLosing;
+/**
+ * Determines if a bid is partially filled at the clearing price.
+ *
+ * A bid is considered partially filled when:
+ * - The bid is at the clearing price (bid number matches clearing price bid number)
+ * - The bid requests more tokens than are available at the clearing price
+ *
+ * This occurs when the auction's token supply is exhausted at the clearing price,
+ * causing the last bid at that price to receive only a portion of their requested tokens.
+ *
+ * @param auctionBucket - The auction bucket with clearing price bid number and allocation
+ * @param bid - The bid to check with bid number and requested token quantity
+ * @returns True if the bid is partially filled, false if fully filled or not at clearing price
+ *
+ * @example
+ * ```typescript
+ * const auction = await fetchAuctionBucketV1(umi, auctionPda);
+ * const bid = await fetchAuctionBidV1(umi, bidPda);
+ * const isPartial = isBidPartiallyFilled(auction, bid); // true (partial fill at clearing price)
+ * ```
+ */
+function isBidPartiallyFilled(auctionBucket, bid) {
+    if (auctionBucket.clearingPriceBidNumber === bid.bidNumber &&
+        bid.tokenQuantity > auctionBucket.clearingPriceAllocation) {
+        return true;
+    }
+    return false;
+}
+exports.isBidPartiallyFilled = isBidPartiallyFilled;
+/**
+ * Calculates the actual token amount a bid will receive.
+ *
+ * Returns either the partial fill amount (if bid is at clearing price) or
+ * the full token quantity requested by the bid.
+ *
+ * @param bid - The bid with bid number and requested token quantity
+ * @param auctionBucket - The auction bucket with clearing price info
+ * @returns The actual number of tokens the bid will receive
+ *
+ * @example
+ * ```typescript
+ * const bid = await fetchAuctionBidV1(umi, bidPda);
+ * const auction = await fetchAuctionBucketV1(umi, auctionPda);
+ * const fillAmount = getBidFillAmount(bid, auction); // 50000n (partial fill)
+ * ```
+ */
+function getBidFillAmount(auctionBucket, bid) {
+    return isBidPartiallyFilled(auctionBucket, bid)
+        ? auctionBucket.clearingPriceAllocation
+        : bid.tokenQuantity;
+}
+exports.getBidFillAmount = getBidFillAmount;
+/**
+ * Converts SOL amount to micro-SOL (µSOL) amount.
+ *
+ * @param sol - The amount in SOL (lamports)
+ * @returns The equivalent amount in micro-SOL (micro-lamports)
+ *
+ * @example
+ * ```typescript
+ * const solAmount = lamports(1_000_000_000); // 1 SOL
+ * const microSolAmount = toUSol(solAmount); // 1,000,000,000,000,000 µSOL
+ * ```
+ */
+function toUSol(sol) {
+    return (0, umi_1.microLamports)(sol.basisPoints * BigInt(exports.MICRO_LAMPORTS_PER_LAMPORT));
+}
+exports.toUSol = toUSol;
+/**
+ * Converts micro-SOL (µSOL) amount to SOL amount.
+ *
+ * @param uSol - The amount in micro-SOL (micro-lamports)
+ * @returns The equivalent amount in SOL (lamports)
+ *
+ * @example
+ * ```typescript
+ * const microSolAmount = microLamports(1_000_000_000_000_000n); // 1,000,000,000,000,000 µSOL
+ * const solAmount = toSol(microSolAmount); // 1 SOL
+ * ```
+ */
+function toSol(uSol) {
+    return (0, umi_1.lamports)((0, umi_1.divideAmount)(uSol, BigInt(exports.MICRO_LAMPORTS_PER_LAMPORT)).basisPoints);
+}
+exports.toSol = toSol;
+/**
+ * Calculates the micro-SOL price per token basis unit.
+ *
+ * Converts a SOL per token price to micro-SOL per smallest token unit,
+ * accounting for token decimals. This is used for precise sub-lamport pricing.
+ *
+ * @param solPerTokenInput - The price in SOL per whole token (or lamports as bigint)
+ * @param tokenDecimals - The number of decimal places for the token
+ * @returns The price in micro-SOL per token basis unit
+ *
+ * @example
+ * ```typescript
+ * // For a token with 6 decimals, priced at 0.5 SOL per token
+ * const priceUlamports = lamports(500_000_000); // 0.5 SOL
+ * const microSolPerBasis = uSolPerTokenBasis(priceUlamports, 6);
+ * // Returns price per smallest token unit (1/1,000,000 of a token)
+ * ```
+ */
+function uSolPerTokenBasis(solPerTokenInput, tokenDecimals) {
+    return (0, umi_1.divideAmount)(toUSol(typeof solPerTokenInput === 'bigint'
+        ? (0, umi_1.lamports)(solPerTokenInput)
+        : solPerTokenInput), 10 ** tokenDecimals);
+}
+exports.uSolPerTokenBasis = uSolPerTokenBasis;
+/**
+ * Converts micro-SOL per token basis unit to SOL per whole token.
+ *
+ * Takes a price in micro-SOL per smallest token unit and converts it to
+ * SOL per whole token, accounting for token decimals.
+ *
+ * @param ulamportsPerTokenBasis - The price in micro-SOL per token basis unit
+ * @param tokenDecimals - The number of decimal places for the token
+ * @returns The price in SOL per whole token
+ *
+ * @example
+ * ```typescript
+ * // For a token with 6 decimals
+ * const microSolPerBasis = microLamports(500n); // Price per smallest unit
+ * const solPerWholeToken = solPerToken(microSolPerBasis, 6);
+ * // Returns price in SOL for one whole token
+ * ```
+ */
+function solPerToken(ulamportsPerTokenBasis, tokenDecimals) {
+    return toSol((0, umi_1.multiplyAmount)(createMicroLamports(ulamportsPerTokenBasis), 10 ** tokenDecimals));
+}
+exports.solPerToken = solPerToken;
+/**
+ * Calculates the total SOL cost for a bid.
+ *
+ * Multiplies the micro-SOL price per token basis by the token amount
+ * to get the total cost in SOL.
+ *
+ * @param pricePerTokenBasis - The price in micro-SOL per token basis unit
+ * @param tokenAmount - The number of token basis units to purchase
+ * @returns The total cost in SOL
+ *
+ * @example
+ * ```typescript
+ * // Bidding for 1,000,000 token units at 500 micro-SOL each
+ * const pricePerUnit = microLamports(500n);
+ * const amount = 1_000_000n;
+ * const totalCost = totalBidSol(pricePerUnit, amount);
+ * // Returns total SOL needed for the bid
+ * ```
+ */
+function totalBidSol(pricePerTokenBasis, tokenAmount) {
+    const microLamportsPerToken = (0, umi_1.multiplyAmount)(createMicroLamports(pricePerTokenBasis), tokenAmount);
+    return toSol(microLamportsPerToken);
+}
+exports.totalBidSol = totalBidSol;
+//# sourceMappingURL=auction.js.map

package/dist/src/auction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"auction.js","sourceRoot":"","sources":["../../src/auction.ts"],"names":[],"mappings":"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"}

package/dist/src/bondingCurveHelpers.d.ts

@@ -0,0 +1,46 @@
+import { BondingCurveBucketV1, SwapDirection } from './generated';
+/**
+ * Calculate the output amount for a given input amount on a bonding curve.
+ * This function determines how much of the output asset you'll receive for a given input amount.
+ * This function does not take into account fees.
+ *
+ * @param bucket - The bonding curve bucket containing reserves and parameters
+ * @param amountIn - The input amount to swap
+ * @param direction - The swap direction (Buy = SOL in, tokens out; Sell = tokens in, SOL out)
+ * @returns The output amount you'll receive from the swap
+ * @throws Error if the bonding curve type is unsupported or calculation errors occur
+ */
+export declare function getSwapAmountOutForIn(bucket: BondingCurveBucketV1, amountIn: bigint, direction: SwapDirection): bigint;
+/**
+ * Calculate the input amount needed to receive a desired output amount on a bonding curve.
+ * This function determines how much of the input asset you need to provide to get a specific output amount.
+ * This function does not take into account fees.
+ *
+ * @param bucket - The bonding curve bucket containing reserves and parameters
+ * @param amountOut - The desired output amount to receive
+ * @param direction - The swap direction (Buy = SOL in, tokens out; Sell = tokens in, SOL out)
+ * @returns The input amount required to achieve the desired output
+ * @throws Error if the bonding curve type is unsupported or calculation errors occur
+ */
+export declare function getSwapAmountInForOut(bucket: BondingCurveBucketV1, amountOut: bigint, direction: SwapDirection): bigint;
+/**
+ * Calculates the complete swap result including fees for a bonding curve swap.
+ *
+ * @param bucket - The bonding curve bucket
+ * @param amountIn - The input amount (before fees)
+ * @param swapDirection - The swap direction (Buy = SOL in, tokens out; Sell = tokens in, SOL out)
+ * @returns An object containing the actual input amount, fee, and output amount
+ * @throws Error if the bucket has insufficient reserves or calculation errors occur
+ */
+export declare function getSwapResult(bucket: BondingCurveBucketV1, amountIn: bigint, swapDirection: SwapDirection): {
+    amountIn: bigint;
+    fee: bigint;
+    amountOut: bigint;
+};
+/**
+ * Get the current price of the bonding curve.
+ *
+ * @param bucket - The bonding curve bucket
+ * @returns The current price
+ */
+export declare function getCurrentPrice(bucket: BondingCurveBucketV1): bigint;