@ar.io/sdk 3.22.1 → 3.23.0-alpha.1

package/lib/cjs/cli/cli.js

@@ -570,12 +570,21 @@ const utils_js_1 = require("./utils.js");
 (0, utils_js_1.makeCommand)({
     name: 'transfer-ant-ownership',
     description: 'Transfer ownership of an ANT process',
-    options: [options_js_1.optionMap.processId, options_js_1.optionMap.target, ...options_js_1.writeActionOptions],
+    options: [
+        options_js_1.optionMap.processId,
+        options_js_1.optionMap.target,
+        options_js_1.optionMap.removeControllers,
+        ...options_js_1.writeActionOptions,
+    ],
     action: async (options) => {
         const target = (0, utils_js_1.requiredStringFromOptions)(options, 'target');
-        await (0, utils_js_1.assertConfirmationPrompt)(`Are you sure you want to transfer ANT ownership to ${target}?`, options);
+        const removeControllers = options.removeControllers !== undefined
+            ? options.removeControllers
+            : true;
+        await (0, utils_js_1.assertConfirmationPrompt)(`Are you sure you want to transfer ANT ownership to ${target}${removeControllers ? ' (controllers will be removed)' : ' (controllers will be retained)'}?`, options);
         return (0, utils_js_1.writeANTFromOptions)(options).transfer({
             target,
+            removeControllers,
         }, (0, utils_js_1.customTagsFromOptions)(options));
     },
 });

package/lib/cjs/cli/options.js

@@ -285,6 +285,11 @@ exports.optionMap = {
         description: 'Whether the vaulted transfer is revokable by the sender. Defaults to false',
         type: 'boolean',
     },
+    removeControllers: {
+        alias: '--remove-controllers',
+        description: 'Whether to remove controllers when transferring ANT ownership. Defaults to true',
+        type: 'boolean',
+    },
     lockLengthMs: {
         alias: '--lock-length-ms <lockLengthMs>',
         description: 'The length of time in milliseconds to lock the vault for',

package/lib/cjs/cli/utils.js

@@ -183,7 +183,8 @@ function readARIOFromOptions(options) {
     return index_js_1.ARIO.init({
         hyperbeamUrl: options.hyperbeamUrl,
         process: aoProcessFromOptions({
-            cuUrl: 'https://cu.ardrive.io', // default to ardrive cu for ARIO process
+            cuUrl: 'http://localhost:6363', // default to ardrive cu for ARIO process
+            //cuUrl: 'https://cu.ardrive.io', // default to ardrive cu for ARIO process
             ...options,
         }),
         paymentUrl: options.paymentUrl,

package/lib/cjs/common/ant.js

@@ -709,17 +709,26 @@ class AoANTWriteable extends AoANTReadable {
     }
     /**
      * @param target @type {string} The address of the account you want to transfer the ANT to.
+     * @param removeControllers @type {boolean} Whether to remove the controllers of the ANT. Default is true.
+     * @example
+     * ```ts
+     * ant.transfer({ target: "fGht8v4STuwPnTck1zFVkQqJh5K9q9Zik4Y5-5dV7nk", removeControllers: false }); // will not remove the controllers of the ANT and just transfer ownership
+     * ```
      * @returns {Promise<AoMessageResult>} The result of the interaction.
      * @example
      * ```ts
      * ant.transfer({ target: "fGht8v4STuwPnTck1zFVkQqJh5K9q9Zik4Y5-5dV7nk" });
      * ```
      */
-    async transfer({ target }, options) {
+    async transfer({ target, removeControllers = true, }, options) {
         const tags = [
             ...(options?.tags ?? []),
             { name: 'Action', value: 'Transfer' },
             { name: 'Recipient', value: target },
+            {
+                name: 'Remove-Controllers',
+                value: removeControllers ? 'true' : 'false',
+            },
         ];
         return this.process.send({
             tags,

package/lib/cjs/common/index.js

@@ -36,6 +36,7 @@ __exportStar(require("./ant.js"), exports);
 __exportStar(require("./ant-registry.js"), exports);
 __exportStar(require("./ant-versions.js"), exports);
 __exportStar(require("./faucet.js"), exports);
+__exportStar(require("./marketplace.js"), exports);
 // ao
 __exportStar(require("./io.js"), exports);
 __exportStar(require("./contracts/ao-process.js"), exports);

package/lib/cjs/common/marketplace.js

@@ -0,0 +1,575 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArNSMarketplaceWrite = exports.ArNSMarketplaceRead = void 0;
+exports.calculateListingFee = calculateListingFee;
+exports.calculateSaleTax = calculateSaleTax;
+/**
+ * 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.
+ */
+const index_js_1 = require("../node/index.js");
+class ArNSMarketplaceRead {
+    process;
+    logger;
+    constructor({ process = new index_js_1.AOProcess({
+        processId: index_js_1.MARKETPLACE_CONTRACT_ID,
+    }), logger = index_js_1.Logger.default, }) {
+        this.process = process;
+        this.logger = logger;
+    }
+    async getInfo() {
+        return this.process.read({
+            tags: [{ name: 'Action', value: 'Info' }],
+        });
+    }
+    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,
+        });
+    }
+    async getIntent(intentId) {
+        return this.process.read({
+            tags: [
+                { name: 'Action', value: 'Get-Intent-By-Id' },
+                { name: 'Intent-Id', value: intentId },
+            ],
+        });
+    }
+    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 });
+    }
+    /**
+     * 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 },
+            ],
+        });
+    }
+    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' },
+                ...(0, index_js_1.paginationParamsToTags)(params),
+            ],
+        });
+    }
+    /**
+     * 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 },
+            ],
+        });
+    }
+    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 };
+    }
+}
+exports.ArNSMarketplaceRead = ArNSMarketplaceRead;
+class ArNSMarketplaceWrite extends ArNSMarketplaceRead {
+    process;
+    signer;
+    ario;
+    constructor({ process = new index_js_1.AOProcess({
+        processId: index_js_1.MARKETPLACE_CONTRACT_ID,
+    }), signer, ario, logger = index_js_1.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,
+        });
+    }
+    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,
+        });
+    }
+    async pushANTIntentResolution(intentId) {
+        return this.process.send({
+            tags: [
+                { name: 'Action', value: 'Push-ANT-Intent-Resolution' },
+                { name: 'X-Intent-Id', value: intentId },
+            ],
+            signer: this.signer,
+        });
+    }
+    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,
+        });
+    }
+    async listNameForSale({ name, expirationTime, price, type, walletAddress, minimumPrice, decreaseInterval, }) {
+        // 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 = index_js_1.ANT.init({
+            process: new index_js_1.AOProcess({
+                processId: antId,
+                ao: this.process.ao,
+            }),
+            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;
+        try {
+            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;
+        }
+        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) {
+                intent = await this.getIntentByANTId(antId).catch((error) => {
+                    this.logger.error(`Failed to get intent: ${error.message}`);
+                    throw new Error('An intent already exists for this ANT ID but failed to get intent:\n\n' +
+                        error.message);
+                });
+            }
+            else {
+                // Possible to get other errors, eg insufficient deposited ario balance. Rethrow them here.
+                throw error;
+            }
+        }
+        // Type guard to ensure intent is defined
+        if (intent === undefined) {
+            throw new Error('Failed to create intent');
+        }
+        let antTransferResult;
+        try {
+            antTransferResult = 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 }],
+            });
+            this.logger.info(`ANT transferred: ${JSON.stringify(antTransferResult)}`);
+        }
+        catch (error) {
+            this.logger.error(`Failed to transfer ANT: ${error.message}`);
+            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;
+        let tries = 0;
+        while (order === null && tries < 5) {
+            try {
+                order = await this.getOrderByANTId(antId).catch((error) => {
+                    console.log(new Error('Failed to get order: ' + error.message));
+                    return null;
+                });
+                if (order === null) {
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                    this.logger.info(`Waiting for order to be created...`);
+                    if (tries === 5) {
+                        this.logger.error(`Failed to get order after ${tries} attempts`);
+                        throw new Error(`Failed to get order after ${tries} attempts`);
+                    }
+                    tries++;
+                }
+                // if the order is found, break the loop
+                break;
+            }
+            catch (error) {
+                this.logger.error(`Failed to get order: ${error.message}`);
+                return {
+                    intent,
+                    order: null,
+                    antTransferResult,
+                    error: new Error('Failed to get order: ' + error.message),
+                };
+            }
+        }
+        if (order === null) {
+            this.logger.error(`Failed to get order`);
+            return {
+                intent,
+                order: null,
+                antTransferResult,
+                error: new Error('Failed to get order'),
+            };
+        }
+        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,
+        });
+    }
+    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,
+        });
+    }
+    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,
+        });
+    }
+    /**
+     * 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,
+        });
+    }
+}
+exports.ArNSMarketplaceWrite = ArNSMarketplaceWrite;
+/**
+ * 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.
+ *
+ * @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,
+ * });
+ * ```
+ */
+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.
+ *
+ * @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,
+ * });
+ * ```
+ */
+function calculateSaleTax({ saleAmount, saleTaxNumerator, saleTaxDenominator, }) {
+    // Calculate tax: (saleAmount * numerator) / denominator
+    return ((BigInt(saleAmount) * BigInt(saleTaxNumerator)) / BigInt(saleTaxDenominator));
+}

package/lib/cjs/constants.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_SCHEDULER_ID = exports.AO_AUTHORITY = exports.ANT_LUA_ID = exports.AOS_MODULE_ID = exports.MARIO_PER_ARIO = exports.ANT_REGISTRY_ID = exports.ANT_REGISTRY_TESTNET_ID = exports.ARIO_MAINNET_PROCESS_ID = exports.ARIO_TESTNET_PROCESS_ID = exports.arioDevnetProcessId = exports.ARIO_DEVNET_PROCESS_ID = exports.FQDN_REGEX = exports.ARWEAVE_TX_REGEX = void 0;
+exports.DEFAULT_SCHEDULER_ID = exports.AO_AUTHORITY = exports.ANT_LUA_ID = exports.AOS_MODULE_ID = exports.MARIO_PER_ARIO = exports.MARKETPLACE_CONTRACT_ID = exports.ANT_REGISTRY_ID = exports.ANT_REGISTRY_TESTNET_ID = exports.ARIO_MAINNET_PROCESS_ID = exports.ARIO_TESTNET_PROCESS_ID = exports.arioDevnetProcessId = exports.ARIO_DEVNET_PROCESS_ID = exports.FQDN_REGEX = exports.ARWEAVE_TX_REGEX = void 0;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
  *
@@ -26,6 +26,7 @@ exports.ARIO_TESTNET_PROCESS_ID = 'agYcCFJtrMG6cqMuZfskIkFTGvUPddICmtQSBIoPdiA';
 exports.ARIO_MAINNET_PROCESS_ID = 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE';
 exports.ANT_REGISTRY_TESTNET_ID = 'RR0vheYqtsKuJCWh6xj0beE35tjaEug5cejMw9n2aa8';
 exports.ANT_REGISTRY_ID = 'i_le_yKKPVstLTDSmkHRqf-wYphMnwB9OhleiTgMkWc';
+exports.MARKETPLACE_CONTRACT_ID = 'wPh88ziUF4meLpHfffmgdA6IFtzmXHgdeg-epzBjkao';
 exports.MARIO_PER_ARIO = 1_000_000;
 /**
  * @deprecated - use ANT.versions.getLatestANTVersion() to get latest ANT module

package/lib/cjs/version.js

@@ -17,4 +17,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-exports.version = '3.22.1';
+exports.version = '3.23.0-alpha.1';