@ar.io/sdk 3.24.0 → 4.0.0-alpha.2

package/lib/esm/common/marketplace.js

@@ -1,724 +0,0 @@
-/**
- * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { ANT, AOProcess, Logger, MARKETPLACE_CONTRACT_ID, paginationParamsToTags, } from '../node/index.js';
-/**
- * Read-only client for the ArNS marketplace
- * @experimental
- */
-export class ArNSMarketplaceRead {
-    process;
-    logger;
-    constructor({ process = new AOProcess({
-        processId: MARKETPLACE_CONTRACT_ID,
-    }), logger = Logger.default, }) {
-        this.process = process;
-        this.logger = logger;
-    }
-    async getInfo() {
-        return this.process.read({
-            tags: [{ name: 'Action', value: 'Info' }],
-            select: (message) => message.Tags.some((tag) => tag.name === 'Action' && tag.value === 'Info-Notice'),
-        });
-    }
-    async getPaginatedIntents({ cursor, limit, sortBy, sortOrder, filters, } = {}) {
-        const tags = [
-            { name: 'Action', value: 'Get-Paginated-Intents' },
-            { name: 'Cursor', value: cursor },
-            { name: 'Limit', value: limit?.toString() },
-            { name: 'Sort-By', value: sortBy },
-            { name: 'Sort-Order', value: sortOrder },
-            { name: 'Filters', value: JSON.stringify(filters) },
-        ];
-        const filteredTags = tags.filter((tag) => tag.value !== undefined);
-        return this.process.read({
-            tags: filteredTags,
-            select: (message) => message.Tags.some((tag) => tag.name === 'Action' &&
-                tag.value === 'Get-Paginated-Intents-Notice'),
-        });
-    }
-    async getIntent(intentId) {
-        return this.process.read({
-            tags: [
-                { name: 'Action', value: 'Get-Intent-By-Id' },
-                { name: 'Intent-Id', value: intentId },
-            ],
-            select: (message) => message.Tags.some((tag) => tag.name === 'Action' && tag.value === 'Get-Intent-By-Id-Notice'),
-        });
-    }
-    async getIntentByANTId(antId) {
-        const res = await this.getPaginatedIntents({
-            filters: {
-                antProcessId: antId,
-            },
-        });
-        if (res.items.length === 0) {
-            throw new Error(`No intent found for ANT ID: ${antId}`);
-        }
-        return res.items[0];
-    }
-    /**
-     * Get orders with flexible selectors
-     * @param params - Parameters for filtering and pagination
-     * @returns Orders matching the criteria
-     */
-    async getPaginatedOrders(params) {
-        const tags = [
-            { name: 'Action', value: 'Get-Orders' },
-            { name: 'Status', value: params?.status },
-            { name: 'Ids', value: params?.ids?.join(',') },
-            { name: 'Dominant-Token', value: params?.dominantToken },
-            { name: 'Swap-Token', value: params?.swapToken },
-            { name: 'Cursor', value: params?.cursor },
-            { name: 'Limit', value: params?.limit?.toString() },
-            { name: 'Sort-By', value: params?.sortBy },
-            { name: 'Sort-Order', value: params?.sortOrder },
-            {
-                name: 'Filters',
-                value: params?.filters ? JSON.stringify(params.filters) : undefined,
-            },
-        ];
-        const filteredTags = tags.filter((tag) => tag.value !== undefined);
-        return this.process.read({
-            tags: filteredTags,
-            select: (message) => message.Tags.some((tag) => tag.name === 'Action' && tag.value === 'Get-Orders-Notice'),
-        });
-    }
-    /**
-     * Get a single order by ID
-     * @param orderId - The order ID to fetch
-     * @returns The order if found
-     */
-    async getOrder(orderId) {
-        return this.process.read({
-            tags: [
-                { name: 'Action', value: 'Get-Order' },
-                { name: 'Order-Id', value: orderId },
-            ],
-            select: (message) => message.Tags.some((tag) => tag.name === 'Action' && tag.value === 'Get-Order-Notice'),
-        });
-    }
-    async getOrderByANTId(antId) {
-        const res = await this.getPaginatedOrders({
-            dominantToken: antId,
-        });
-        if (res.items.length === 0) {
-            throw new Error(`No order found for ANT ID: ${antId}`);
-        }
-        // Strange behaviour here. It seems that the filter logic will return an order with potentially different dominant token.
-        const order = res.items[0];
-        if (order.dominantToken !== antId) {
-            throw new Error(`No order for ANT ID: ${antId}`);
-        }
-        return res.items[0];
-    }
-    async getPaginatedMarketplaceBalances(params) {
-        return this.process.read({
-            tags: [
-                { name: 'Action', value: 'Get-Paginated-Balances' },
-                ...paginationParamsToTags(params),
-            ],
-            select: (message) => message.Tags.some((tag) => tag.name === 'Action' &&
-                tag.value === 'Get-Paginated-Balances-Notice'),
-        });
-    }
-    /**
-     * Get ARIO balance for an address in the marketplace
-     */
-    async getMarketplaceBalance({ address, }) {
-        return this.process.read({
-            tags: [
-                { name: 'Action', value: 'Get-Balance' },
-                { name: 'Address', value: address },
-            ],
-            select: (message) => message.Tags.some((tag) => tag.name === 'Action' && tag.value === 'Get-Balance-Notice'),
-        });
-    }
-    async getUserAssets({ address, arioProcessId, }) {
-        async function fetchIntents(context) {
-            const intents = [];
-            // fetch all intents for user, paginating as needed and adding each ant id to the set
-            let intentsCursor = undefined;
-            let intentsHasMore = true;
-            while (intentsHasMore) {
-                const intentsRes = await context.getPaginatedIntents({
-                    cursor: intentsCursor,
-                    limit: 1000,
-                    filters: {
-                        initiator: address,
-                    },
-                });
-                intentsRes.items.forEach((intent) => {
-                    intents.push(intent);
-                });
-                intentsCursor = intentsRes.nextCursor;
-                intentsHasMore = intentsRes.hasMore;
-            }
-            return intents;
-        }
-        async function fetchOrders(context) {
-            const orders = [];
-            // fetch all orders for user, paginating as needed
-            let ordersCursor = undefined;
-            let ordersHasMore = true;
-            while (ordersHasMore) {
-                const ordersRes = await context.getPaginatedOrders({
-                    cursor: ordersCursor,
-                    limit: 1000,
-                    filters: {
-                        creator: address,
-                    },
-                });
-                ordersRes.items.forEach((order) => {
-                    orders.push(order);
-                });
-                ordersCursor = ordersRes.nextCursor;
-                ordersHasMore = ordersRes.hasMore;
-            }
-            return orders;
-        }
-        // parallel fetch balances, intents, and orders
-        const [balances, intents, orders] = await Promise.all([
-            this.getMarketplaceBalance({ address }),
-            fetchIntents(this),
-            fetchOrders(this),
-        ]);
-        const antIdsArray = Array.from(new Set([
-            ...intents.map((intent) => intent.antProcessId),
-            ...orders.map((order) => order.dominantToken),
-            ...orders.map((order) => order.swapToken),
-        ])).filter((antId) => antId !== arioProcessId); // since we add both swap and dominant token for simplicity, we need to filter out the ario token
-        return { intents, orders, balances, antIds: antIdsArray };
-    }
-}
-/**
- * Write client for the ArNS marketplace
- * @experimental
- */
-export class ArNSMarketplaceWrite extends ArNSMarketplaceRead {
-    process;
-    signer;
-    ario;
-    constructor({ process = new AOProcess({
-        processId: MARKETPLACE_CONTRACT_ID,
-    }), signer, ario, logger = Logger.default, }) {
-        super({ process: process, logger: logger });
-        this.process = process;
-        this.signer = signer;
-        this.ario = ario;
-        this.logger = logger;
-    }
-    /**
-     * Deposit ARIO to the marketplace (simulates Credit-Notice from ARIO token process)
-     * Returns the message ID for verification
-     */
-    async depositArIO(params) {
-        return this.ario.transfer({
-            // the marketplace process id is the target
-            target: this.process.processId,
-            qty: Number(params.amount),
-        }, {
-            tags: [{ name: 'X-Action', value: 'Deposit' }],
-        });
-    }
-    /**
-     * Withdraw ARIO from the marketplace back to user
-     */
-    async withdrawArIO(params) {
-        return this.process.send({
-            tags: [
-                { name: 'Action', value: 'Withdraw-Ario' },
-                { name: 'Quantity', value: params.amount },
-            ],
-            signer: this.signer,
-            select: (message) => message.Tags.some((tag) => tag.name === 'Action' && tag.value === 'Withdraw-Ario-Notice'),
-        });
-    }
-    async createIntent({ antId, orderType, quantity, price, expirationTime, minimumPrice, decreaseInterval, }) {
-        const tags = [
-            { name: 'Action', value: 'Create-Intent' },
-            { name: 'X-Intent-ANT-Id', value: antId },
-            { name: 'X-Intent-Order-Type', value: orderType },
-            { name: 'X-Intent-Quantity', value: quantity },
-            { name: 'X-Intent-Price', value: price },
-            { name: 'X-Intent-Expiration-Time', value: expirationTime },
-            { name: 'X-Intent-Minimum-Price', value: minimumPrice },
-            { name: 'X-Intent-Decrease-Interval', value: decreaseInterval },
-        ];
-        const filteredTags = tags.filter((tag) => tag.value !== undefined);
-        return this.process.send({
-            tags: filteredTags,
-            signer: this.signer,
-            select: (message) => message.Tags.some((tag) => tag.name === 'Action' && tag.value === 'Create-Intent-Notice'),
-        });
-    }
-    async pushANTIntentResolution(intentId) {
-        return this.process.send({
-            tags: [
-                { name: 'Action', value: 'Push-ANT-Intent-Resolution' },
-                { name: 'X-Intent-Id', value: intentId },
-            ],
-            signer: this.signer,
-            select: (message) => message.Tags.some((tag) => tag.name === 'Action' &&
-                tag.value === 'Push-ANT-Intent-Resolution-Notice'),
-        });
-    }
-    async settleAuction(params) {
-        const tags = [
-            { name: 'Action', value: 'Settle-Auction' },
-            { name: 'Order-Id', value: params.orderId },
-            { name: 'Dominant-Token', value: params.dominantToken },
-            { name: 'Swap-Token', value: params.swapToken },
-        ];
-        const filteredTags = tags.filter((tag) => tag.value !== undefined);
-        return this.process.send({
-            tags: filteredTags,
-            signer: this.signer,
-            select: (message) => message.Tags.some((tag) => tag.name === 'Action' && tag.value === 'Settle-Auction-Notice'),
-        });
-    }
-    async listNameForSale({ name, expirationTime, price, type, walletAddress, minimumPrice, decreaseInterval, onProgress = (event) => {
-        this.logger.info(`List name for sale progress: ${event.step}`);
-    }, }, timeoutOptions) {
-        const maxRetries = timeoutOptions?.maxRetries ?? 15;
-        const statusPollIntervalMs = timeoutOptions?.statusPollIntervalMs ?? 3000;
-        // Get arns record for the current ant id associated with it
-        const record = await this.ario.getArNSRecord({ name: name });
-        this.logger.info(`Record ${name} found: ${JSON.stringify(record)}`);
-        if (record === undefined) {
-            throw new Error(`Record ${name} not found`);
-        }
-        const antId = record.processId;
-        this.logger.info(`ANT ID for ${name} found: ${antId}`);
-        const ant = ANT.init({
-            process: new AOProcess({
-                processId: antId,
-                ao: this.process.ao,
-                logger: this.logger,
-            }),
-            signer: this.signer,
-        });
-        const antState = await ant.getState();
-        if (antState.Owner !== walletAddress) {
-            this.logger.error(`Wallet address ${walletAddress} does not match the owner of the ANT ${antId}. Only the owner can list the name for sale.`);
-            throw new Error('Wallet address does not match the owner of the ANT. Only the owner can list the name for sale.');
-        }
-        let intent;
-        const createIntentEventData = {
-            name,
-            antId,
-            orderType: type,
-            price,
-            expirationTime,
-        };
-        try {
-            onProgress({
-                step: 'creating-intent',
-                ...createIntentEventData,
-            });
-            const intentResult = await this.createIntent({
-                antId,
-                orderType: type,
-                quantity: price,
-                expirationTime: expirationTime.toString(),
-                price: price,
-                minimumPrice: minimumPrice,
-                decreaseInterval: decreaseInterval,
-            });
-            if (intentResult.result === undefined) {
-                throw new Error('Failed to create intent: ' + intentResult.id);
-            }
-            this.logger.info(`Intent created: ${JSON.stringify(intentResult.result)}`);
-            intent = intentResult.result;
-            onProgress({
-                step: 'intent-created',
-                ...createIntentEventData,
-                intent,
-            });
-        }
-        catch (error) {
-            this.logger.error(`Error creating intent: ${error.message}`);
-            // check error for existing intent. Will be a contract error message.
-            const isExistingIntentError = error.message.includes('An intent already exists for this ANT ID');
-            if (isExistingIntentError) {
-                let fetchedIntent;
-                let lastIntentError = null;
-                for (let attempt = 0; attempt <= maxRetries; attempt++) {
-                    try {
-                        fetchedIntent = await this.getIntentByANTId(antId);
-                        lastIntentError = null;
-                        break;
-                    }
-                    catch (getIntentError) {
-                        lastIntentError = getIntentError;
-                        this.logger.error(`Failed to get intent (attempt ${attempt + 1}/${maxRetries + 1}): ${getIntentError.message}`);
-                        if (attempt < maxRetries) {
-                            const backoffMs = statusPollIntervalMs * Math.pow(2, attempt);
-                            await new Promise((resolve) => setTimeout(resolve, backoffMs));
-                        }
-                    }
-                }
-                if (lastIntentError !== null || fetchedIntent === undefined) {
-                    const intentError = new Error('An intent already exists for this ANT ID but failed to get intent:\n\n' +
-                        (lastIntentError?.message ?? 'Unknown error'));
-                    onProgress({
-                        step: 'error',
-                        name,
-                        antId,
-                        error: intentError,
-                        failedStep: 'creating-intent',
-                    });
-                    throw intentError;
-                }
-                intent = fetchedIntent;
-            }
-            else {
-                // Possible to get other errors, eg insufficient deposited ario balance. Rethrow them here.
-                onProgress({
-                    step: 'error',
-                    name,
-                    antId,
-                    error: error,
-                    failedStep: 'creating-intent',
-                });
-                throw error;
-            }
-        }
-        // Type guard to ensure intent is defined
-        if (intent === undefined) {
-            const intentError = new Error('Failed to create intent');
-            onProgress({
-                step: 'error',
-                name,
-                antId,
-                error: intentError,
-                failedStep: 'creating-intent',
-            });
-            throw intentError;
-        }
-        const transferAntEventData = {
-            name,
-            antId,
-            intentId: intent.intentId,
-            marketplaceProcessId: this.process.processId,
-        };
-        let antTransferResult;
-        try {
-            onProgress({
-                step: 'transferring-ant',
-                ...transferAntEventData,
-            });
-            let transferResult;
-            let lastTransferError = null;
-            for (let attempt = 0; attempt <= maxRetries; attempt++) {
-                try {
-                    transferResult = await ant.transfer({
-                        target: this.process.processId,
-                        removeControllers: false, // important: do not remove the controllers of the ANT to prevent loss of control
-                    }, {
-                        tags: [{ name: 'X-Intent-Id', value: intent.intentId }],
-                    });
-                    lastTransferError = null;
-                    break;
-                }
-                catch (error) {
-                    lastTransferError = error;
-                    this.logger.error(`Failed to transfer ANT (attempt ${attempt + 1}/${maxRetries + 1}): ${error.message}`);
-                    if (attempt < maxRetries) {
-                        const backoffMs = statusPollIntervalMs * Math.pow(2, attempt);
-                        await new Promise((resolve) => setTimeout(resolve, backoffMs));
-                    }
-                }
-            }
-            if (lastTransferError !== null || transferResult === undefined) {
-                throw lastTransferError ?? new Error('Failed to transfer ANT');
-            }
-            antTransferResult = transferResult;
-            this.logger.info(`ANT transferred: ${JSON.stringify(antTransferResult)}`);
-            onProgress({
-                step: 'ant-transferred',
-                ...transferAntEventData,
-                transferResult: antTransferResult,
-            });
-        }
-        catch (error) {
-            this.logger.error(`Failed to transfer ANT: ${error.message}`);
-            onProgress({
-                step: 'error',
-                name,
-                antId,
-                error: error,
-                failedStep: 'transferring-ant',
-                intent,
-            });
-            return {
-                intent,
-                order: null,
-                antTransferResult: null,
-                error: error,
-            };
-        }
-        // poll for the order to be created
-        // This is to ensure the order is created before returning the result for ux purposes.
-        // This may still fail, in which case we return the intent and ant transfer result and handle the error in the client.
-        let order = null;
-        for (let attempt = 0; attempt <= maxRetries; attempt++) {
-            try {
-                order = await this.getOrderByANTId(antId).catch((error) => {
-                    this.logger.warn(`Failed to get order: ${error.message}`);
-                    return null;
-                });
-                if (order !== null) {
-                    break;
-                }
-                if (attempt < maxRetries) {
-                    this.logger.info(`Waiting for order to be created...`);
-                    const backoffMs = statusPollIntervalMs * Math.pow(2, attempt);
-                    await new Promise((resolve) => setTimeout(resolve, backoffMs));
-                }
-            }
-            catch (error) {
-                this.logger.error(`Failed to get order: ${error.message}`);
-                const orderError = new Error('Failed to get order: ' + error.message);
-                onProgress({
-                    step: 'error',
-                    name,
-                    antId,
-                    error: orderError,
-                    failedStep: 'transferring-ant',
-                    intent,
-                });
-                return {
-                    intent,
-                    order: null,
-                    antTransferResult,
-                    error: orderError,
-                };
-            }
-        }
-        if (order === null) {
-            this.logger.error(`Failed to get order`);
-            const orderError = new Error('Failed to get order');
-            onProgress({
-                step: 'error',
-                name,
-                antId,
-                error: orderError,
-                failedStep: 'transferring-ant',
-                intent,
-            });
-            return {
-                intent,
-                order: null,
-                antTransferResult,
-                error: orderError,
-            };
-        }
-        onProgress({
-            step: 'complete',
-            name,
-            antId,
-            intent,
-            order,
-            transferResult: antTransferResult,
-        });
-        return { intent, order, antTransferResult, error: null };
-    }
-    async cancelOrder(orderId) {
-        const tags = [
-            { name: 'Action', value: 'Cancel-Order' },
-            { name: 'Order-Id', value: orderId },
-        ];
-        return this.process.send({
-            tags,
-            signer: this.signer,
-            select: (message) => message.Tags.some((tag) => tag.name === 'Action' && tag.value === 'Cancel-Order-Notice'),
-        });
-    }
-    async createOrder({ swapToken, quantity, orderType, price, expirationTime, minimumPrice, decreaseInterval, transferDenomination, }) {
-        const tags = [
-            { name: 'Action', value: 'Create-Order' },
-            { name: 'Swap-Token', value: swapToken },
-            { name: 'Quantity', value: quantity },
-            { name: 'Order-Type', value: orderType },
-            { name: 'Price', value: price },
-            { name: 'Expiration-Time', value: expirationTime },
-            { name: 'Minimum-Price', value: minimumPrice },
-            { name: 'Decrease-Interval', value: decreaseInterval },
-            { name: 'Transfer-Denomination', value: transferDenomination },
-        ];
-        const filteredTags = tags.filter((tag) => tag.value !== undefined);
-        // Send the message
-        return this.process.send({
-            tags: filteredTags,
-            signer: this.signer,
-            select: (message) => message.Tags.some((tag) => tag.name === 'Action' && tag.value === 'Create-Order-Notice'),
-        });
-    }
-    async buyFixedPriceANT(params) {
-        const order = await this.getOrderByANTId(params.antId);
-        if (order === undefined) {
-            throw new Error(`No active sell order found for ANT: ${params.antId}`);
-        }
-        if (order.status !== 'active') {
-            throw new Error(`Order status is ${order.status}, must be active`);
-        }
-        if (order.price === undefined) {
-            throw new Error(`Order price is undefined for ANT: ${params.antId}`);
-        }
-        // Create a buy order that matches the sell order
-        // This should trigger immediate execution if prices match
-        // For ArNS: buying 1 ANT, so quantity = price = total cost
-        return this.createOrder({
-            swapToken: params.antId,
-            quantity: order.price, // Total ARIO cost
-            orderType: 'fixed',
-            price: order.price, // Match their asking price
-        });
-    }
-    async buyDutchAuctionANT(params) {
-        const order = await this.getOrderByANTId(params.antId);
-        if (order === undefined) {
-            throw new Error(`No active sell order found for ANT: ${params.antId}`);
-        }
-        if (order.status !== 'active') {
-            throw new Error(`Order status is ${order.status}, must be active`);
-        }
-        if (order.orderType !== 'dutch') {
-            throw new Error(`Order is not a Dutch auction, it's: ${order.orderType}`);
-        }
-        if (order.price === undefined) {
-            throw new Error(`Order starting price is undefined for ANT: ${params.antId}`);
-        }
-        // For Dutch auction, the current price will be calculated on execution
-        return this.createOrder({
-            swapToken: params.antId,
-            quantity: order.price,
-            orderType: 'fixed',
-            price: order.price,
-        });
-    }
-    /**
-     * Place a bid on an English auction
-     * Note: This requires you to have sufficient ARIO balance in the marketplace
-     */
-    async bidOnANTEnglishAuction(params) {
-        const order = await this.getOrderByANTId(params.antId);
-        if (order === undefined) {
-            throw new Error(`No active sell order found for ANT: ${params.antId}`);
-        }
-        if (order.status !== 'active') {
-            throw new Error(`Order status is ${order.status}, must be active`);
-        }
-        if (order.orderType !== 'english') {
-            throw new Error(`Order is not an English auction, it's: ${order.orderType}`);
-        }
-        // Check if auction has expired
-        if (order.expirationTime !== undefined &&
-            Date.now() >= order.expirationTime) {
-            throw new Error(`Auction has already expired for ANT: ${params.antId}`);
-        }
-        return this.process.send({
-            tags: [
-                { name: 'Action', value: 'Bid-On-English-Auction' },
-                { name: 'Order-Id', value: order.id },
-                { name: 'Bid-Amount', value: params.bidAmount },
-            ],
-            signer: this.signer,
-            select: (message) => message.Tags.some((tag) => tag.name === 'Action' &&
-                tag.value === 'Bid-On-English-Auction-Notice'),
-        });
-    }
-    /**
-     * Settle an expired English auction
-     * Can be called by anyone after the auction expires
-     * The highest bidder wins the ANT
-     */
-    async settleANTEnglishAuction(params) {
-        const order = await this.getOrderByANTId(params.antId);
-        if (order === undefined) {
-            throw new Error(`No active sell order found for ANT: ${params.antId}`);
-        }
-        if (order.orderType !== 'english') {
-            throw new Error(`Order is not an English auction, it's: ${order.orderType}`);
-        }
-        // Check if auction has expired
-        if (order.expirationTime !== undefined &&
-            Date.now() < order.expirationTime) {
-            throw new Error(`Auction has not yet expired for ANT: ${params.antId}. Expires at: ${new Date(order.expirationTime).toISOString()}`);
-        }
-        return this.settleAuction({
-            orderId: order.id,
-            dominantToken: order.dominantToken,
-            swapToken: order.swapToken,
-        });
-    }
-}
-/**
- * Calculates the listing fee for an order based on the end timestamp.
- * The fee is calculated by rounding up the hours until the end timestamp to the nearest hour.
- *
- * @experimental
- * @param params - Parameters for calculating the listing fee
- * @param params.listingFeePerHour - The listing fee per hour in mARIO (as a string)
- * @param params.endTimestamp - Unix timestamp when the order expires
- * @returns The listing fee in mARIO as a BigInt
- *
- * @example
- * ```typescript
- * const info = await marketplace.getInfo();
- * const endTimestamp = Date.now() + 24 * 60 * 60 * 1000; // 24 hours from now
- * const listingFee = calculateListingFee({
- *   listingFeePerHour: info.fees.listingFeePerHour,
- *   endTimestamp,
- * });
- * ```
- */
-export function calculateListingFee({ listingFeePerHour, endTimestamp, }) {
-    const now = Date.now();
-    const millisecondsUntilEnd = endTimestamp - now;
-    if (millisecondsUntilEnd <= 0) {
-        return BigInt(0);
-    }
-    // Convert milliseconds to hours and round up to the nearest hour
-    const hoursUntilEnd = Math.ceil(millisecondsUntilEnd / (1000 * 60 * 60));
-    // Calculate listing fee: hours * fee per hour
-    return BigInt(hoursUntilEnd) * BigInt(listingFeePerHour);
-}
-/**
- * Calculates the sale tax for an order based on the sale amount.
- *
- * @experimental
- * @param params - Parameters for calculating the sale tax
- * @param params.saleAmount - The sale amount in mARIO (as a string or number)
- * @param params.saleTaxNumerator - The numerator for sale tax calculation
- * @param params.saleTaxDenominator - The denominator for sale tax calculation
- * @returns The sale tax in mARIO as a BigInt
- *
- * @example
- * ```typescript
- * const info = await marketplace.getInfo();
- * const saleAmount = 100000000000; // 100 ARIO in mARIO
- * const tax = calculateSaleTax({
- *   saleAmount,
- *   saleTaxNumerator: info.fees.saleTaxNumerator,
- *   saleTaxDenominator: info.fees.saleTaxDenominator,
- * });
- * ```
- */
-export function calculateSaleTax({ saleAmount, saleTaxNumerator, saleTaxDenominator, }) {
-    // Calculate tax: (saleAmount * numerator) / denominator
-    return ((BigInt(saleAmount) * BigInt(saleTaxNumerator)) / BigInt(saleTaxDenominator));
-}