apenft-js-tron 1.0.0

package/dist/src/tradeAPI/nft.d.ts

@@ -0,0 +1,42 @@
+import { Contracts } from './contracts';
+export declare class AssetFactory extends Contracts {
+    private contracts;
+    contract721(address: any): Promise<any>;
+    balanceOf(address: string, account: string): Promise<any>;
+    /**
+     * Deploy the ERC721 contract and return the contract address
+     * @param name
+     * @param symbol
+     * @param baseUrl
+     * @returns Promise
+     */
+    createAsset721x(name: string, symbol: string, baseUrl: string): Promise<any>;
+    /**
+     * Deploy the ERC721 contract and return the contract address
+     * @param {string} name - contract name
+     * @param {string} symbol - contract symbol
+     * @param {string} baseUrl - contract metadata json url
+     * @param {object} [options]  - options，see https://cn.developers.tron.network/reference/tronweb-createsmartcontract
+     * @returns {Promise<{txHash,txSend}>}  Promise object
+     */
+    createAsset721(name: string, symbol: string, baseUrl: string, options?: any): Promise<{
+        txHash: any;
+        txSend: any;
+    }>;
+    /**
+     * @deprecated use createAsset721
+     * contract().new(options) will return "Invalid issuer address provided"
+     */
+    deployAsset721(name: string, symbol: string, baseUrl: string, options?: any): Promise<any>;
+    /**
+     *
+     * @param {string} assetAddr - NFT contract address
+     * @param {string} to - NFT token  receiver address
+     * @param {string} [url] - options ，NFT metadata baseUrl
+     * @returns Promise
+     */
+    mint721(assetAddr: string, to: string, url?: string): Promise<{
+        txHash: any;
+        txSend: any;
+    }>;
+}

package/dist/src/tradeAPI/orders.d.ts

@@ -0,0 +1,69 @@
+import { Asset, Order, OrderJSON, Token, UnhashedOrder, UnsignedOrder } from '../utils/types';
+import { Contracts } from './contracts';
+export declare enum OrderCheckStatus {
+    StartOrderHashSign = "startOrderHashSign",
+    EndOrderHashSign = "endOrderHashSign",
+    StartOrderMatch = "startOrderMatch",
+    OrderMatchTxHash = "orderMatchTxHash",
+    EndOrderMatch = "endOrderMatch",
+    StartCancelOrder = "startCancelOrder",
+    EndCancelOrder = "endCancelOrder",
+    RegisterTxHash = "registerTxHash",
+    EndRegister = "endRegister",
+    ApproveErc20TxHash = "approveErc20TxHash",
+    EndApproveErc20 = "endApproveErc20",
+    ApproveErc721TxHash = "approveErc721TxHash",
+    EndApproveErc721 = "endApproveErc721",
+    ApproveErc1155TxHash = "approveErc1155TxHash",
+    EndApproveErc1155 = "endApproveErc1155",
+    TransferErc1155 = "transferErc1155",
+    TransferErc721 = "transferErc721",
+    End = "End"
+}
+export interface CallBack {
+    next<T>(arg: OrderCheckStatus, data?: any): OrderCheckStatus;
+}
+export declare class Orders extends Contracts {
+    makeMatchingOrder({ signedOrder, accountAddress, recipientAddress }: {
+        signedOrder: any;
+        accountAddress: string;
+        recipientAddress?: string;
+    }): {
+        buy: Order;
+        sell: Order;
+    };
+    createSignedOrder({ unHashOrder }: {
+        unHashOrder: UnhashedOrder;
+    }): Promise<OrderJSON>;
+    createBuyOrder({ asset, accountAddress, startAmount, paymentTokenObj, quantity, expirationTime, sellOrder, referrerAddress }: {
+        asset: Asset;
+        accountAddress: string;
+        startAmount: number;
+        paymentTokenObj: Token;
+        quantity?: number;
+        expirationTime?: number;
+        sellOrder?: Order;
+        referrerAddress?: string;
+    }): Promise<OrderJSON>;
+    createSellOrder({ asset, accountAddress, startAmount, paymentTokenObj, endAmount, quantity, listingTime, expirationTime, waitForHighestBid, englishAuctionReservePrice, extraBountyBasisPoints, buyerAddress, }: {
+        asset: Asset;
+        accountAddress: string;
+        startAmount: number;
+        paymentTokenObj?: Token;
+        endAmount?: number;
+        quantity?: number;
+        listingTime?: number;
+        expirationTime?: number;
+        waitForHighestBid?: boolean;
+        englishAuctionReservePrice?: number;
+        extraBountyBasisPoints?: number;
+        buyerAddress?: string;
+    }): Promise<OrderJSON>;
+    getOrderCurrentPrice(order: Order): Promise<string>;
+    getOrderCancelledOrFinalized(order: Order): Promise<boolean>;
+    checkMatchOrder(buy: Order, sell: Order): Promise<boolean>;
+    checkOrder(order: Order): Promise<boolean>;
+    orderToJSON(order: Order): OrderJSON;
+    orderFromJSON(order: any): Order;
+    computeOrderCallData(order: UnsignedOrder, networkName: string, assetRecipientAddress: string): any;
+}

package/dist/src/tradeAPI/ordersApi.d.ts

@@ -0,0 +1,54 @@
+import { APIConfig, OrderJSON, OrderType } from '../utils/types';
+import { Fetch } from './base';
+export interface ChainInfo {
+    chain?: string;
+    chainId?: string;
+}
+export interface OrderVersionParams extends ChainInfo {
+    contractAddress: string;
+    tokenId: string | undefined;
+}
+export interface OrderVersionData {
+    isTradable: boolean;
+    isEditable: boolean;
+    uri: string;
+    orderVersion: number;
+}
+export interface OrderConfData {
+    engReserveMinEth: number;
+    offerMinEth: number;
+    relayerFee: number;
+}
+export interface OrderCancelParams extends ChainInfo {
+    hash: string;
+    signature: string;
+}
+export interface OrderQueryParams extends ChainInfo {
+    assetContractAddress: string;
+    tokenId: string;
+    orderType: OrderType;
+}
+export declare class OrdersAPI extends Fetch {
+    chain: string;
+    chainId: number;
+    walletChainId: string;
+    chainInfo: ChainInfo;
+    constructor(config: APIConfig);
+    /**
+     * Send an order to the orderbook.
+     * Throws when the order is invalid.
+     * IN NEXT VERSION: change order input to Order type
+     * @param order Order JSON to post to the orderbook
+     * @param retries Number of times to retry if the service is unavailable for any reason
+     */
+    ordersPost({ order, retries }: {
+        order: OrderJSON;
+        retries?: number;
+        LanguageType?: string;
+        Authorization?: string;
+    }): Promise<any>;
+    ordersVersion(orderAsset: OrderVersionParams, retries?: number): Promise<OrderVersionData>;
+    ordersConfData(retries?: number): Promise<OrderConfData>;
+    ordersHidden(cancelParams: OrderCancelParams, retries?: number): Promise<any>;
+    ordersQuery(queryParams: OrderQueryParams, retries?: number): Promise<any>;
+}

package/dist/src/utils/Abi.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { bufferToHex } from 'ethereumjs-util';
+import { AnnotatedFunctionInput } from './types';
+export { bufferToHex };
+interface ABICoder {
+    eventID: (name: string, types: Array<any>) => Buffer;
+    methodSig: (abi: any) => string;
+    methodID: (name: string, types: Array<any>) => Buffer;
+    rawEncode: (types: Array<any>, values: Array<any>) => Buffer;
+    simpleEncode: (method: string) => Buffer;
+    rawInputsEncode: (inputs: Array<any>) => Buffer;
+    rawDecode: (types: Array<any>, values: string) => any;
+    paramsArray: (inputs: Array<AnnotatedFunctionInput>, values: Array<any>) => Array<any>;
+}
+export declare function elementaryName(name: string): string;
+export declare function encodeSingle(type: any, arg: any): Buffer;
+export declare function isDynamic(type: string): boolean;
+export declare const ABI: ABICoder;

package/dist/src/utils/PromiEvent.d.ts

@@ -0,0 +1,21 @@
+import EventEmitter from 'eventemitter3';
+interface PE extends Promise<any>, EventEmitter {
+    _events: any;
+    emit: any;
+    on: any;
+    once: any;
+    off: any;
+    listeners: any;
+    addListener: any;
+    removeListener: any;
+    removeAllListeners: any;
+}
+declare const PromiEvent: {
+    (justPromise?: boolean): {
+        resolve: (value: unknown) => void;
+        reject: (value: unknown) => void;
+        eventEmitter: Partial<PE>;
+    };
+    resolve(value: any): Partial<PE>;
+};
+export default PromiEvent;

package/dist/src/utils/check.d.ts

@@ -0,0 +1,25 @@
+import { ExchangeMetadata, Order, UnhashedOrder } from '../utils/types';
+import { Contracts } from '../tradeAPI/contracts';
+export declare function getAccountProxyAddr(contracts: Contracts, schemaName: string): Promise<string>;
+export declare function checkRegisterProxy(proxyRegistryContract: any, account: string): Promise<boolean>;
+export declare function checkApproveTokenTransferProxy(exchangeContract: any, erc20Contract: any, account: string): Promise<boolean>;
+export declare function checkApproveERC1155TransferProxy(contract: any, nftsContract: any, account: string): Promise<boolean>;
+export declare function checkApproveERC721TransferProxy(contract: any, nftsContract: any, account: string, tokenID: string): Promise<boolean>;
+export declare function checkApproveSchemaProxy(contract: any, orderMetadata: ExchangeMetadata, account: string): Promise<boolean>;
+export declare function checkUnhashedOrder(contract: any, order: UnhashedOrder): Promise<boolean>;
+export declare function checkOrder(contract: any, order: Order): Promise<boolean>;
+export declare function checkMatchOrder(contract: any, buy: Order, sell: Order): Promise<boolean>;
+export declare function checkDataToCall(netWorkName: string, order: UnhashedOrder): void;
+export declare function validateOrder(exchangeHelper: any, order: Order): Promise<any>;
+export declare function _ordersCanMatch(buy: Order, sell: Order): boolean;
+export declare function ordersCanMatch(exchangeHelper: any, buy: Order, sell: Order): Promise<any>;
+export declare function getOrderCancelledOrFinalized(contract: any, order: Order): Promise<boolean>;
+export declare function checkOrderCancelledOrFinalized(contract: any, order: Order): Promise<void>;
+export declare function checkAssetMint(contract: any, metadata: ExchangeMetadata): Promise<boolean>;
+export declare function checkAssetAddress(netWorkName: string, order: UnhashedOrder): Promise<void>;
+export declare function checkAssetApprove(contract: any, order: UnhashedOrder): Promise<any>;
+export declare function checkAssetBalance(contract: any, order: UnhashedOrder): Promise<number>;
+export declare const getAPENFTAssetURI: (contract: any, tokenId: string) => Promise<{
+    overURI: any;
+    URI: any;
+}>;

package/dist/src/utils/constants.d.ts

@@ -0,0 +1,22 @@
+import BigNumber from 'bignumber.js';
+export { BigNumber };
+export declare const NULL_ADDRESS = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";
+export declare const NULL_BLOCK_HASH = "0x0000000000000000000000000000000000000000000000000000000000000000";
+export declare const MAX_DIGITS_IN_UNSIGNED_256_INT = 78;
+export declare const MAX_UINT_256 = "115792089237316195423570985008687907853269984665640564039457584007913129639935";
+export declare const MIN_EXPIRATION_SECONDS = 10;
+export declare const MIN_Listing_SECONDS = 10;
+export declare const ORDER_MATCHING_LATENCY_SECONDS: number;
+export declare const DEFAULT_BUYER_FEE_BASIS_POINTS = 0;
+export declare const DEFAULT_SELLER_FEE_BASIS_POINTS: {
+    [key: string]: any;
+};
+export declare const DEFAULT_MAX_BOUNTY: {
+    [key: string]: any;
+};
+export declare const APENFT_SELLER_BOUNTY_BASIS_POINTS = 100;
+export declare const INVERSE_BASIS_POINT = 10000;
+export declare const STATIC_EXTRADATA = "0x0c225aad";
+export declare const TOKEN_TYPE_MAP: {
+    [key: string]: any;
+};

package/dist/src/utils/error.d.ts

@@ -0,0 +1,20 @@
+/**
+ * To simplify typifying ABIs
+ */
+export interface CustomError {
+    name?: string;
+    data?: any;
+    code: string;
+    message?: string;
+    context?: {
+        [key: string]: any;
+    };
+}
+export type APENFTErrorCodes = Array<Readonly<CustomError>>;
+export declare const ErrorCodes: APENFTErrorCodes;
+export declare class APENFTError extends Error {
+    code: string;
+    data: any;
+    context: any;
+    constructor(err: CustomError);
+}

package/dist/src/utils/fees.d.ts

@@ -0,0 +1,40 @@
+import { Asset, ComputedFees, OrderSide, UnhashedOrder, FeeMethod } from './types';
+/**
+ * Compute the fees for an order
+ * @param param0 __namedParameters
+ * @param asset Asset to use for fees. May be blank ONLY for multi-collection bundles.
+ * @param side The side of the order (buy or sell)
+ * @param accountAddress The account to check fees for (useful if fees differ by account, like transfer fees)
+ * @param isPrivate Whether the order is private or not (known taker)
+ * @param extraBountyBasisPoints The basis points to add for the bounty. Will throw if it exceeds the assets' contract's APENFT fee.
+ */
+export declare function computeFees({ asset, side, accountAddress, isPrivate, extraBountyBasisPoints, networkName }: {
+    asset?: Asset;
+    side: OrderSide;
+    accountAddress?: string;
+    isPrivate?: boolean;
+    extraBountyBasisPoints?: number;
+    networkName: string;
+}): ComputedFees;
+export declare function _getBuyFeeParameters(buyerProtocolFeeBasisPoints: number, sellerProtocolFeeBasisPoints: number, totalBuyerFeeBasisPoints: number, totalSellerFeeBasisPoints: number, sellOrder?: UnhashedOrder): {
+    makerRelayerFee: import("bignumber.js").BigNumber;
+    takerRelayerFee: import("bignumber.js").BigNumber;
+    makerProtocolFee: import("bignumber.js").BigNumber;
+    takerProtocolFee: import("bignumber.js").BigNumber;
+    makerReferrerFee: import("bignumber.js").BigNumber;
+    feeMethod: FeeMethod;
+};
+export declare function _getSellFeeParameters(buyerProtocolFeeBasisPoints: number, sellerProtocolFeeBasisPoints: number, totalBuyerFeeBasisPoints: number, totalSellerFeeBasisPoints: number, waitForHighestBid: boolean, sellerBountyBasisPoints?: number): {
+    makerRelayerFee: import("bignumber.js").BigNumber;
+    takerRelayerFee: import("bignumber.js").BigNumber;
+    makerProtocolFee: import("bignumber.js").BigNumber;
+    takerProtocolFee: import("bignumber.js").BigNumber;
+    makerReferrerFee: import("bignumber.js").BigNumber;
+    feeMethod: FeeMethod;
+};
+/**
+ * Validate fee parameters
+ * @param totalBuyerFeeBasisPoints Total buyer fees
+ * @param totalSellerFeeBasisPoints Total seller fees
+ */
+export declare function _validateFees(totalBuyerFeeBasisPoints: number, totalSellerFeeBasisPoints: number): void;

package/dist/src/utils/helper.d.ts

@@ -0,0 +1,23 @@
+import { Asset, ExchangeMetadata, ECSignature, UnhashedOrder, Order } from './types';
+import { BigNumber } from './constants';
+export declare function toBaseUnitAmount(amount: BigNumber, decimals: number): BigNumber;
+export declare const getAPENFTAssetURI: (contract: any, tokenId: string) => Promise<{
+    overURI: any;
+    URI: any;
+}>;
+export declare function assetToMetadata(asset: Asset, quantity: string): ExchangeMetadata;
+export declare function makeBigNumber(arg: number | string | BigNumber): BigNumber;
+export declare function web3Sign(web3: any, msg: string, account: string): Promise<string>;
+export declare function getAccountBalance(web3: any, account: string, erc20?: any): Promise<any>;
+export declare function getSchemaList(networkName: string, schemaName?: string): Array<any>;
+export declare function hashOrder(web3: any, order: UnhashedOrder): string;
+export declare function orderParamsEncode(order: UnhashedOrder): Array<any>;
+export declare function orderSigEncode(order: ECSignature): Array<any>;
+export declare function getTokenList(networkName: string, { symbol, address }: {
+    symbol?: string;
+    address?: string;
+}): Array<any>;
+export declare const checkResult: (index: number | undefined, web3: any, defer: any, signedTransaction: any) => Promise<any>;
+export declare const checkResultFast: (index: number | undefined, web3: any, defer: any, signedTransaction: any) => Promise<any>;
+export declare function Sleep(ms: number): Promise<unknown>;
+export declare const orderFromJSON: (order: any) => Order;

package/dist/src/utils/makeOrder.d.ts

@@ -0,0 +1,80 @@
+import { Asset, ECSignature, APENFTAsset, APENFTSchemaName, Order, OrderJSON, UnhashedOrder, UnsignedOrder, Token } from './types';
+import { BigNumber } from './constants';
+import { CallSpec } from '../schemas/schemasFunctions';
+export declare function getSchema(networkName: string, schemaName: APENFTSchemaName): any;
+export declare function getAPENFTAsset(schema: any, asset: Asset, quantity?: BigNumber): APENFTAsset;
+export declare function getSchemaAndAsset(networkName: string, asset: Asset, quantity: number): any;
+export declare function generatePseudoRandomSalt(): BigNumber;
+export declare function getPriceParameters(paymentTokenObj: Token, expirationTime: number, startAmount: number, endAmount?: number, waitingForBestCounterOrder?: boolean, englishAuctionReservePrice?: number): {
+    basePrice: BigNumber;
+    extra: BigNumber;
+    paymentToken: string;
+    reservePrice: BigNumber | undefined;
+};
+export declare function getTimeParameters(expirationTimestamp: number, listingTimestamp?: number, waitingForBestCounterOrder?: boolean): {
+    listingTime: BigNumber;
+    expirationTime: BigNumber;
+};
+export declare function _makeBuyOrder({ networkName, exchangeAddr, asset, quantity, accountAddress, startAmount, expirationTime, paymentTokenObj, extraBountyBasisPoints, feeRecipientAddr, sellOrder, referrerAddress }: {
+    networkName: string;
+    exchangeAddr: string;
+    asset: Asset;
+    quantity: number;
+    accountAddress: string;
+    startAmount: number;
+    expirationTime: number;
+    paymentTokenObj: Token;
+    extraBountyBasisPoints: number;
+    feeRecipientAddr: string;
+    sellOrder?: Order;
+    referrerAddress?: string;
+}): Promise<UnhashedOrder>;
+export declare function _makeSellOrder({ networkName, exchangeAddr, asset, quantity, accountAddress, startAmount, endAmount, listingTime, expirationTime, waitForHighestBid, englishAuctionReservePrice, paymentTokenObj, extraBountyBasisPoints, feeRecipientAddr, buyerAddress }: {
+    networkName: string;
+    exchangeAddr: string;
+    asset: Asset;
+    quantity: number;
+    accountAddress: string;
+    startAmount: number;
+    endAmount?: number;
+    waitForHighestBid: boolean;
+    englishAuctionReservePrice?: number;
+    listingTime?: number;
+    expirationTime: number;
+    paymentTokenObj: Token;
+    extraBountyBasisPoints: number;
+    feeRecipientAddr: string;
+    buyerAddress: string;
+}): Promise<UnhashedOrder>;
+export declare function getOrderHash(/* web3: any, */ exchangeHelper: any, order: UnhashedOrder): Promise<string>;
+export declare function hashAndValidateOrder(web3: any, exchangeHelper: any, order: UnhashedOrder): Promise<OrderJSON>;
+export declare function signOrderHash(web3: any, hashedOrder: UnsignedOrder): Promise<ECSignature>;
+export declare const orderToJSON: (order: Order) => OrderJSON;
+export declare function getCurrentPrice(exchangeHelper: any, order: Order): Promise<string>;
+export declare function _getStaticCallTargetAndExtraData({ networkName, asset, useTxnOriginStaticCall }: {
+    networkName: string;
+    asset: Asset;
+    useTxnOriginStaticCall: boolean;
+}): Promise<{
+    staticTarget: string;
+    staticExtradata: string;
+}>;
+export declare const computeOrderParams: (order: UnsignedOrder, networkName: string, assetRecipientAddress: string) => CallSpec;
+export declare const computeOrderCallData: (order: UnsignedOrder, networkName: string, assetRecipientAddress: string) => CallSpec;
+export declare function _makeMatchingOrder({ networkName, unSignedOrder, accountAddress, assetRecipientAddress, feeRecipientAddress }: {
+    networkName: string;
+    unSignedOrder: UnsignedOrder;
+    accountAddress: string;
+    assetRecipientAddress: string;
+    feeRecipientAddress: string;
+}): UnhashedOrder;
+/**
+ * Assign an order and a new matching order to their buy/sell sides
+ * @param order Original order
+ * @param matchingOrder The result of _makeMatchingOrder
+ */
+export declare function assignOrdersToSides(order: Order, matchingOrder: UnsignedOrder): {
+    buy: Order;
+    sell: Order;
+};
+export declare const orderFromJSON: (order: any) => Order;