@ar.io/sdk 3.22.2 → 3.23.0-alpha.2

package/lib/esm/cli/utils.js

@@ -1,3 +1,19 @@
+/**
+ * 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 { readFileSync } from 'fs';
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
  *
@@ -16,7 +32,6 @@
 import { EthereumSigner } from '@dha-team/arbundles';
 import { connect } from '@permaweb/aoconnect';
 import { program } from 'commander';
-import { readFileSync } from 'fs';
 import prompts from 'prompts';
 import { ANT, ANTRegistry, ANT_REGISTRY_ID, ANT_REGISTRY_TESTNET_ID, AOProcess, ARIO, ARIOToken, ARIO_DEVNET_PROCESS_ID, ARIO_MAINNET_PROCESS_ID, ARIO_TESTNET_PROCESS_ID, ArweaveSigner, Logger, createAoSigner, fromB64Url, fundFromOptions, initANTStateForAddress, isValidFundFrom, isValidIntent, mARIOToken, sha256B64Url, validIntents, } from '../node/index.js';
 import { globalOptions } from './options.js';
@@ -129,7 +144,8 @@ export function readARIOFromOptions(options) {
     return 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/esm/common/ant-registry.js

@@ -108,7 +108,7 @@ export class AoANTRegistryReadable {
                         Controlled: json.Controlled,
                     };
                 }
-                catch (error) {
+                catch (_error) {
                     retries++;
                     this.logger.debug('Failed to fetch ant registry acl for address from hyperbeam', address, retries);
                     await new Promise((resolve) => setTimeout(resolve, 1000 * retries ** 2));

package/lib/esm/common/ant.js

@@ -704,17 +704,26 @@ export 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/esm/common/index.js

@@ -20,6 +20,7 @@ export * from './ant.js';
 export * from './ant-registry.js';
 export * from './ant-versions.js';
 export * from './faucet.js';
+export * from './marketplace.js';
 // ao
 export * from './io.js';
 export * from './contracts/ao-process.js';

package/lib/esm/common/loggers/winston.js

@@ -22,7 +22,7 @@ export class WinstonLogger {
             // eslint-disable-next-line @typescript-eslint/no-var-requires
             this.winston = require('winston');
         }
-        catch (error) {
+        catch (_error) {
             throw new Error('Winston is not installed. Install it with: npm install winston');
         }
         this.logger = this.winston.createLogger({

package/lib/esm/common/marketplace.js

@@ -0,0 +1,568 @@
+/**
+ * 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';
+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' }],
+        });
+    }
+    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' },
+                ...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 };
+    }
+}
+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,
+        });
+    }
+    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 = ANT.init({
+            process: new 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,
+        });
+    }
+}
+/**
+ * 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,
+ * });
+ * ```
+ */
+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.
+ *
+ * @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));
+}

package/lib/esm/constants.js

@@ -23,6 +23,7 @@ export const ARIO_TESTNET_PROCESS_ID = 'agYcCFJtrMG6cqMuZfskIkFTGvUPddICmtQSBIoP
 export const ARIO_MAINNET_PROCESS_ID = 'qNvAoz0TgcH7DMg8BCVn8jF32QH5L6T29VjHxhHqqGE';
 export const ANT_REGISTRY_TESTNET_ID = 'RR0vheYqtsKuJCWh6xj0beE35tjaEug5cejMw9n2aa8';
 export const ANT_REGISTRY_ID = 'i_le_yKKPVstLTDSmkHRqf-wYphMnwB9OhleiTgMkWc';
+export const MARKETPLACE_CONTRACT_ID = 'wPh88ziUF4meLpHfffmgdA6IFtzmXHgdeg-epzBjkao';
 export const MARIO_PER_ARIO = 1_000_000;
 /**
  * @deprecated - use ANT.versions.getLatestANTVersion() to get latest ANT module

package/lib/esm/utils/json.js

@@ -17,7 +17,7 @@ export function safeDecode(data) {
     try {
         return JSON.parse(data);
     }
-    catch (e) {
+    catch (_e) {
         return data;
     }
 }