apenft-js-tron 1.0.0

package/dist/bundle.js.LICENSE.txt

@@ -0,0 +1,28 @@
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>
+ * @license  MIT
+ */
+
+/*!
+ * The buffer module from node.js, for the browser.
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */
+
+/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+/*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+/**
+ * [js-sha3]{@link https://github.com/emn178/js-sha3}
+ *
+ * @version 0.8.0
+ * @author Chen, Yi-Cyuan [emn178@gmail.com]
+ * @copyright Chen, Yi-Cyuan 2015-2018
+ * @license MIT
+ */

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export { APENFTOrders } from './src/tradeAPI';
+export { APENFTQuery } from './src/queryAPI';
+export { initApprove } from './src/tradeAPI/approve';
+export { Network, MakeOrderType, APENFTSchemaName, OrderSide } from './src/utils/types';
+export { AssetFactory } from './src/tradeAPI/nft';
+export type { APIConfig } from './src/utils/types';
+export { toBaseUnitAmount, getSchemaList, makeBigNumber, } from './src/utils/helper';
+export { NULL_ADDRESS } from './src/utils/constants';
+export { APENFTError } from './src/utils/error';

package/dist/src/config.d.ts

@@ -0,0 +1,57 @@
+import { Network } from './utils/types';
+export declare const CHAIN_ID: {
+    [key: string]: number;
+};
+export declare const HOST_CHAINNAME: {
+    [key: string]: Network;
+};
+export declare const ID_CHAINNAME: {
+    [key: number]: Network;
+};
+export declare const CHAIN: {
+    [key: string]: string;
+};
+export declare const API_BASE_URL: {
+    [key: string]: {
+        api: string;
+        key: string;
+        secret: string;
+        api2: string;
+        apenftBaseApiUrl: string;
+    };
+};
+export declare const NULL_ADDRESS = "T9yD14Nj9j7xAB4dbGeiX9h8unkKHxuWwb";
+export declare const GasPrice_NOW: {
+    url: string;
+    type: string;
+};
+export declare const GasLimitOffset = 1.18;
+export declare enum TRON_CONTRACTS_ADDRESSES_BASE58 {
+    ERC20AssetProxy = "TRgSk4foxSg4JaV2EjNz8qzaNrBhUtWUnz",
+    ERC721AssetProxy = "TRJ54KCbg29a4nb8LVPgNp61o2ity2WkDu",
+    ERC1155AssetProxy = "TQPdK4DutVPkFhcWP6KqshpyRBT95zS2CE",
+    APENFTExchange = "TQr5axvJzETeHsUiXv6QjBEh1BKH571AZu",
+    ExchangeHelper = "TYxaWsBNMtE9L1bsUUdXCKm99Ab2jziEbA",
+    APENFTExchangeKeeper = "TEQAs54FPKYQdTZAPyT3okfbq2MH4dEeP1",
+    APENFTSharedAsset = "TG8UTFQfcmyqb3bSjqK1svTtzrn2mLcUXS",
+    FeeRecipientAddress = "TPyjyZfsYaXStgz2NmAraF1uZcMtkgNan5",
+    WTRX = "TNUC9Qb1rRpS5CbWLmNMxXBjyFoydXjWFR"
+}
+export declare enum SHASTA_CONTRACTS_ADDRESSES_BASE58 {
+    ERC20AssetProxy = "TC7G2nApC3WKGkkkrppUJSmNSnj7KYkaiq",
+    ERC721AssetProxy = "TVDuLb8zE9mcMJqMtUD1gMTnFKRZduwhb7",
+    ERC1155AssetProxy = "TEHxYWo9AkzMy2CFAghQQgBNCgBMqtZGKa",
+    APENFTExchange = "TYnuR3ripQNZUYUvjkjzbwQ48zHKdAtzis",
+    ExchangeHelper = "TCWuXtzPEqKJ2MLygtCr27i1ehYFJKDBdT",
+    APENFTExchangeKeeper = "TEdP593yFJkAiBzwdT56JrXW1pohsTA4ag",
+    APENFTSharedAsset = "TG8UTFQfcmyqb3bSjqK1svTtzrn2mLcUXS",
+    FeeRecipientAddress = "TRxMn4k6ZpPhHLEqVojaXRzr3PP3p3B9KE",
+    WTRX = "TF2ipqRnrDzuPrANJCJggmaM753FCE1ZWE",
+    ERC721Asset = "TKGSPEk2FLrEod8bTLCxxS9AbeXvYe21aC",
+    ERC20Asset = "TTRjXLinU9FAZETtL5TDNsQGd7sc7Hu26T",
+    ERC1155Asset = "TD34cLBPdDhjRHDgiWkG42LnbCZk5fP2fP",
+    FactoryContract = ""
+}
+export declare const CONTRACTS_ADDRESSES: {
+    [key: string]: any;
+};

package/dist/src/queryAPI/graphql/accountApi.d.ts

@@ -0,0 +1,11 @@
+import { APIConfig, AddressParams, SearchParams, UserAssetOffersParams, UserAssetParams } from "../../utils/types";
+import { GraphqlApi } from "./base";
+export declare class AccountApi extends GraphqlApi {
+    constructor(config: APIConfig);
+    getUser(params: AddressParams): Promise<any>;
+    getUsers(params: SearchParams): Promise<any>;
+    getCollections(params: UserAssetParams): Promise<any>;
+    getUserSentOffers(params: UserAssetOffersParams): Promise<any>;
+    getUserReceivedOffers(params: UserAssetOffersParams): Promise<any>;
+    getAssets(params: UserAssetParams): Promise<any>;
+}

package/dist/src/queryAPI/graphql/assetApi.d.ts

@@ -0,0 +1,13 @@
+import { APIConfig, AssetListingsParams, AssetDetailParams, AssetMoreParams, AssetTradingHistory } from "../../utils/types";
+import { GraphqlApi } from "./base";
+export declare class AssetApi extends GraphqlApi {
+    constructor(config: APIConfig);
+    getAssetListings(params: AssetListingsParams): Promise<any>;
+    getAssetOffers(params: AssetListingsParams): Promise<any>;
+    getAssetDetail(params: AssetDetailParams): Promise<any>;
+    getAssetTradingHistory(params: AssetTradingHistory): Promise<any>;
+    getAssetMoreCollection(params: AssetMoreParams): Promise<any>;
+    getAssetListingInfo(params: AssetDetailParams): Promise<any>;
+    getAssetSales(params: AssetDetailParams): Promise<any>;
+    getAssetBids(params: AssetDetailParams): Promise<any>;
+}

package/dist/src/queryAPI/graphql/base.d.ts

@@ -0,0 +1,37 @@
+import { GraphQLClient } from 'graphql-request';
+import { Network, APIConfig, Token } from '../../utils/types';
+export declare class GraphqlApi implements APIConfig {
+    networkName: Network;
+    account: string;
+    /**
+     * Base url for the API
+     */
+    readonly apiBaseUrl: string;
+    gqlClient: GraphQLClient;
+    /**
+     * Logger function to use when debugging
+     */
+    private appKey;
+    private appSecret;
+    chain: string;
+    private chainId;
+    walletChainId: string;
+    /**
+     * Create an instance of the APENFT API
+     * @param config APIConfig for setting up the API, including an optional API key, network name, and base URL
+     * @param logger Optional function for logging debug strings before and after requests are made
+     */
+    constructor(config: APIConfig);
+    paymentTokens?: Token[] | undefined;
+    private getAPISign;
+    blockChainRequest({ funcName, gql, params }: {
+        funcName: string;
+        gql: string;
+        params: any;
+    }): Promise<any>;
+    putRequest({ funcName, gql, params }: {
+        funcName: string;
+        gql: string;
+        params: any;
+    }): Promise<any>;
+}

package/dist/src/queryAPI/graphql/collectionApi.d.ts

@@ -0,0 +1,10 @@
+import { APIConfig, CollectionTradeTrendParams, AddressParams, CollectionTradingHistoryParams, HotCollectionsParams } from "../../utils/types";
+import { GraphqlApi } from "./base";
+export declare class CollectionApi extends GraphqlApi {
+    constructor(config: APIConfig);
+    getSingleCollectionInfo(params: AddressParams): Promise<any>;
+    getCollectionTradeTrend(params: CollectionTradeTrendParams): Promise<any>;
+    getSingleCollectionAttributes(params: AddressParams): Promise<any>;
+    getCollectionTradingHistory(params: CollectionTradingHistoryParams): Promise<any>;
+    getHotCollections(params: HotCollectionsParams): Promise<any>;
+}

package/dist/src/queryAPI/graphql/gql/account.d.ts

@@ -0,0 +1,6 @@
+export declare const getUser: string;
+export declare const getUsers: string;
+export declare const getCollections: string;
+export declare const getUserSentOffers: string;
+export declare const getUserReceivedOffers: string;
+export declare const getAssets: string;

package/dist/src/queryAPI/graphql/gql/asset.d.ts

@@ -0,0 +1,8 @@
+export declare const getAssetDetail: string;
+export declare const getAssetListings: string;
+export declare const getAssetOffers: string;
+export declare const getAssetTradingHistory: string;
+export declare const getAssetMoreCollection: string;
+export declare const getAssetListingInfo: string;
+export declare const getAssetSales: string;
+export declare const getAssetBids: string;

package/dist/src/queryAPI/graphql/gql/collection.d.ts

@@ -0,0 +1,5 @@
+export declare const getCollectionTradeTrend: string;
+export declare const getSingleCollectionAttributes: string;
+export declare const getSingleCollectionInfo: string;
+export declare const getCollectionTradingHistory: string;
+export declare const getHotCollections: string;

package/dist/src/queryAPI/graphql/gql/fragments.d.ts

@@ -0,0 +1,8 @@
+export declare const PAGINATION_FIELDS: string;
+export declare const USER_FIELDS: string;
+export declare const CURRENCY_FIELDS: string;
+export declare const ASKS_FIELDS: string;
+export declare const BIDS_FIELDS: string;
+export declare const SALES_FIELDS: string;
+export declare const ASSETS_FIELDS: string;
+export declare const ORDER_FIELDS: string;

package/dist/src/queryAPI/graphql/index.d.ts

@@ -0,0 +1,9 @@
+import { CollectionApi } from "./collectionApi";
+import { AssetApi } from "./assetApi";
+import { AccountApi } from "./accountApi";
+export declare const GqlApi: {
+    collectionApi: typeof CollectionApi;
+    assetApi: typeof AssetApi;
+    accountApi: typeof AccountApi;
+};
+export { CollectionApi, AssetApi, AccountApi };

package/dist/src/queryAPI/index.d.ts

@@ -0,0 +1,45 @@
+import { QueryAPI } from "./restful/queryAPI";
+import { CollectionApi, AssetApi, AccountApi } from "./graphql";
+import TronWeb from "tronweb";
+import { APIConfig, AddressParams, CollectionTradeTrendParams, CollectionTradingHistoryParams, HotCollectionsParams, FixPriceOrderParams, EnglishAuctionOrderParams, LowerPriceOrderParams, Pagination } from "../utils/types";
+export declare class APENFTQuery extends QueryAPI {
+    gqlApi: {
+        collectionApi: CollectionApi;
+        assetApi: AssetApi;
+        accountApi: AccountApi;
+    };
+    walletProvider: TronWeb;
+    accountAddress: string;
+    constructor(walletProvider: TronWeb, apiConfig: APIConfig, walletAccount?: {
+        address?: string;
+        privateKey?: string;
+    });
+    getSingleCollectionInfo(address: string): Promise<any>;
+    getCollectionTradeTrend({ days, collection, }: CollectionTradeTrendParams): Promise<any>;
+    getSingleCollectionAttributes({ address, }: AddressParams): Promise<any>;
+    getCollectionTradingHistory({ pagination, event_types, currencies, collections, user, }: CollectionTradingHistoryParams): Promise<any>;
+    getHotCollections({ chain, is_recommend, }: HotCollectionsParams): Promise<any>;
+    getAssetListingOrders(collection: string, id: string, pagination?: Pagination): Promise<any>;
+    getAssetOffers(collection: string, id: string, pagination?: Pagination): Promise<any>;
+    getAssetDetail(collection: string, id: string): Promise<any>;
+    getAssetTradingHistory(collection: string, id: string, pagination?: Pagination): Promise<any>;
+    getCollectionAssetsList(collection: string, pagination?: Pagination): Promise<any>;
+    getAssetBestAskOrderInfo(collection: string, id: string): Promise<any>;
+    getAssetBidInfo(collection: string, id: string): Promise<any>;
+    getAssetBidOrderParams(collection: string, id: string, price?: number, currencyUnit?: string): Promise<any>;
+    getEnglishAuctionOrderParams({ collection, id, bidPrice, reservePrice, currency, expirationTime, }: EnglishAuctionOrderParams): Promise<any>;
+    getFixPriceOrderParams({ collection, id, price, currency, expirationTime, buyerAddress, }: FixPriceOrderParams): Promise<any>;
+    getEnglishAuctionBiddingOrderParams({ collection, id, price, currency, }: FixPriceOrderParams): Promise<any>;
+    getLowerPriceOrderParams({ collection, id, price, }: LowerPriceOrderParams): Promise<any>;
+    getMakeOfferOrderOrderParams({ collection, id, price, currency, expirationTime, }: FixPriceOrderParams): Promise<any>;
+    getTransferParams(collection: string, id: string): Promise<any>;
+    private getAssetFormatData;
+    getAssetSaleInfo(collection: string, id: string): Promise<any>;
+    getAssetSales(collection: string, id: string): Promise<any>;
+    getAssetBids(collection: string, id: string): Promise<any>;
+    getAssetListings(collection: string, id: string): Promise<any>;
+    getAssetsList(account: string, pagination?: Pagination): Promise<any>;
+    getSentOffers(account: string, pagination?: Pagination): Promise<any>;
+    getReceivedOffers(account: string, pagination?: Pagination): Promise<any>;
+    getCollections(account: string, pagination?: Pagination): Promise<any>;
+}

package/dist/src/queryAPI/restful/base.d.ts

@@ -0,0 +1,50 @@
+import { APIConfig } from '../../utils/types';
+export declare class Fetch {
+    /**
+     * Page size to use for fetching orders
+     */
+    apiBaseUrl: string;
+    authToken: string;
+    chain: string;
+    /**
+     * Logger function to use when debugging
+     */
+    logger: (arg: string) => void;
+    constructor(url: string, config: APIConfig, logger?: (arg: string) => void);
+    /**
+     * Get JSON data from API, sending auth token in headers
+     * @param url Path to URL endpoint under API
+     * @param body Data to send. Will be stringified using QueryString
+     */
+    get(url: string, body?: {
+        [key: string]: any;
+    }): Promise<any>;
+    /**
+     * POST JSON data to API, sending auth token in headers
+     * @param apiPath Path to URL endpoint under API
+     * @param body Data to send. Will be JSON.stringified
+     * @param opts RequestInit opts, similar to Fetch API. If it contains
+     *  a body, it won't be stringified.
+     */
+    post(apiPath: string, body?: {
+        [key: string]: any;
+    }, opts?: RequestInit): Promise<any>;
+    /**
+     * PUT JSON data to API, sending auth token in headers
+     * @param apiPath Path to URL endpoint under API
+     * @param body Data to send
+     * @param opts RequestInit opts, similar to Fetch API. If it contains
+     *  a body, it won't be stringified.
+     */
+    put(apiPath: string, body?: {
+        [key: string]: any;
+    }, opts?: RequestInit): Promise<any>;
+    /**
+     * Get from an API Endpoint, sending auth token in headers
+     * @param apiPath Path to URL endpoint under API
+     * @param opts RequestInit opts, similar to Fetch API
+     */
+    private _fetch;
+    private _handleApiResponse;
+    throwOrContinue(error: any, retries: number): void;
+}

package/dist/src/queryAPI/restful/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/queryAPI/restful/queryAPI.d.ts

@@ -0,0 +1,26 @@
+import { APIConfig, OrderType } from '../../utils/types';
+import { Fetch } from './base';
+export interface ChainInfo {
+    chain?: string;
+    chainId?: string;
+}
+export interface OrderQueryParams extends ChainInfo {
+    assetContractAddress: string;
+    tokenId: string;
+    orderType: OrderType;
+}
+export declare class QueryAPI extends Fetch {
+    /**
+     * Page size to use for fetching orders
+     */
+    pageSize: number;
+    /**
+     * Logger function to use when debugging
+     */
+    logger: (arg: string) => void;
+    chain: string;
+    chainId: number;
+    walletChainId: string;
+    chainInfo: ChainInfo;
+    constructor(config: APIConfig, logger?: (arg: string) => void);
+}

package/dist/src/schemas/common/ERC1155/index.d.ts

@@ -0,0 +1,7 @@
+export interface SemiFungibleTradeType {
+    id: string;
+    address: string;
+    quantity: string;
+    data: string;
+}
+export declare const ERC1155Schema: any;

package/dist/src/schemas/common/ERC20/index.d.ts

@@ -0,0 +1,6 @@
+export interface FungibleTradeType {
+    address: string;
+    account: string;
+    quantity: string;
+}
+export declare const ERC20Schema: any;

package/dist/src/schemas/common/ERC721/index.d.ts

@@ -0,0 +1,5 @@
+export interface NonFungibleContractType {
+    id: string;
+    address: string;
+}
+export declare const ERC721Schema: any;

package/dist/src/schemas/common/Element/exchange.d.ts

@@ -0,0 +1,9 @@
+export interface Exchange {
+    address: string;
+    sell?: Array<any>;
+    sellSig?: Array<any>;
+    buy?: Array<any>;
+    buySig?: Array<any>;
+    metadata?: string;
+}
+export declare const APENFTExchangeSchemas: any;

package/dist/src/schemas/common/Element/registry.d.ts

@@ -0,0 +1,4 @@
+export interface Registry {
+    address: string;
+}
+export declare const APENFTRegistrySchemas: any;

package/dist/src/schemas/common/ens.d.ts

@@ -0,0 +1,7 @@
+export interface ENSName {
+    nodeHash: string;
+    nameHash: string;
+    name: string;
+}
+export declare const namehash: (name: string) => string;
+export declare const nodehash: (name: string) => string;

package/dist/src/schemas/index.d.ts

@@ -0,0 +1,18 @@
+import { ExchangeMetadata } from '../utils/types';
+import { encodeBuy, encodeSell, encodeCall, encodeWeb3Call, encodeParamsCall, getParams } from './schemasFunctions';
+export { encodeBuy, encodeSell, encodeCall, encodeWeb3Call, encodeParamsCall, getParams };
+export declare const schemas: {
+    tron: any[];
+    shasta: any[];
+};
+export declare const common: {
+    APENFTRegistrySchemas: any;
+    APENFTExchangeSchemas: any;
+    ERC20Schema: any;
+    ERC721Schema: any;
+    ERC1155Schema: any;
+};
+export declare function getBalanceSchemas(metadata: ExchangeMetadata): any;
+export declare function getIsApproveSchemas(metadata: ExchangeMetadata): any;
+export declare function getApproveSchemas(metadata: ExchangeMetadata): any;
+export declare function getTransferSchemas(metadata: ExchangeMetadata): any;

package/dist/src/schemas/schemasFunctions.d.ts

@@ -0,0 +1,24 @@
+import { AnnotatedFunctionABI, FunctionInputKind, OfferType } from '../utils/types';
+export declare const encodeReplacementPattern: ReplacementEncoder;
+export declare const encodeCall: (abi: AnnotatedFunctionABI, parameters: Array<any>) => string;
+export declare const encodeWeb3Call: (abi: AnnotatedFunctionABI, parameters: Array<any>) => string;
+export declare const getParams: (abi: AnnotatedFunctionABI, { owner, replace }: {
+    owner?: string | undefined;
+    replace?: string | boolean | undefined;
+}) => any[];
+export declare const encodeParamsCall: (abi: AnnotatedFunctionABI, { owner, replace }: {
+    owner?: string | undefined;
+    replace?: string | boolean | undefined;
+}) => string;
+export interface CallSpec {
+    target: string;
+    dataToCall: string;
+    replacementPattern: string;
+}
+export type SellEncoder<T> = (schema: any, asset: T, address: string) => CallSpec;
+export declare const encodeSell: SellEncoder<any>;
+export type BuyEncoder<T> = (schema: any, asset: T, address: string, type?: OfferType) => CallSpec;
+export declare const encodeBuy: BuyEncoder<any>;
+export type DefaultCallEncoder = (abi: AnnotatedFunctionABI, address: string) => string;
+export declare const encodeDefaultCall: DefaultCallEncoder;
+export type ReplacementEncoder = (abi: AnnotatedFunctionABI, kind?: FunctionInputKind) => string;

package/dist/src/schemas/shasta/index.d.ts

@@ -0,0 +1 @@
+export declare const shastaSchemas: Array<any>;

package/dist/src/schemas/tron/index.d.ts

@@ -0,0 +1 @@
+export declare const tronSchemas: Array<any>;

package/dist/src/tokens/index.d.ts

@@ -0,0 +1,4 @@
+export declare const tokens: {
+    tron: any;
+    shasta: any;
+};

package/dist/src/tokens/shasta/index.d.ts

@@ -0,0 +1 @@
+export declare const shastaTokens: any;

package/dist/src/tokens/tron/index.d.ts

@@ -0,0 +1 @@
+export declare const tronTokens: any;

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

@@ -0,0 +1,33 @@
+import { TronWeb, BuyOrderApprove, APIConfig, ExchangeMetadata, OrderSide, SellOrderApprove } from '../utils/types';
+import { BigNumber } from '../utils/constants';
+import { CreateOrderParams } from '../utils/types';
+import { ContractSchemas } from './contractSchemas';
+import { Contracts } from './contracts';
+export declare class Account extends ContractSchemas {
+    account: string;
+    accountProxy: string;
+    contracts: Contracts;
+    constructor(web3: TronWeb, apiConfig: APIConfig);
+    private getTokenApprove;
+    private getAssetApprove;
+    private orderApprove;
+    getOrderApproveStep(params: CreateOrderParams, side: OrderSide, startAmount: number): Promise<SellOrderApprove | BuyOrderApprove>;
+    private orderApproveCalldata;
+    getAccountProxy(schemaName: string): Promise<string>;
+    checkTokenTransferProxy(to: string): Promise<BigNumber>;
+    getTokenBalances(to: string, account?: string): Promise<string>;
+    getAssetBalances(metadata: ExchangeMetadata, account?: string): Promise<string>;
+    approveTokenTransferProxy(tokenAddr: string): Promise<any>;
+    approveTokenTransferProxyCalldata(tokenAddr: string): any;
+    checkAssetTransferProxy(metadata: ExchangeMetadata): Promise<boolean>;
+    approveAssetTransferProxy(metadata: ExchangeMetadata): Promise<any>;
+    approveAssetTransferProxyCalldata(metadata: ExchangeMetadata, operator: string): any;
+    orderMatch({ buy, sell, metadata }: {
+        buy: any;
+        sell: any;
+        metadata?: string;
+    }): Promise<any>;
+    orderCancel(order: any): Promise<any>;
+    assetTransfer(metadata: ExchangeMetadata, to: string): Promise<any>;
+    accountApprove(error: any): Promise<any>;
+}

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

@@ -0,0 +1,3 @@
+export declare const isSellOrderHandle: (orderType: any) => boolean;
+export declare const isBuyOrderHandle: (orderType: any) => boolean;
+export declare const initApprove: ({ APENFTOrders, orderType, orderParams }: any) => Promise<boolean>;

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

@@ -0,0 +1,40 @@
+export declare class Fetch {
+    /**
+     * Page size to use for fetching orders
+     */
+    apiBaseUrl: string;
+    authToken: string;
+    constructor(url: string);
+    /**
+     * Get JSON data from API, sending auth token in headers
+     * @param apiPath Path to URL endpoint under API
+     * @param query Data to send. Will be stringified using QueryString
+     */
+    get(url: string): Promise<any>;
+    /**
+     * POST JSON data to API, sending auth token in headers
+     * @param apiPath Path to URL endpoint under API
+     * @param body Data to send. Will be JSON.stringified
+     * @param opts RequestInit opts, similar to Fetch API. If it contains
+     *  a body, it won't be stringified.
+     */
+    post(apiPath: string, body?: {
+        [key: string]: any;
+    }, opts?: RequestInit): Promise<any>;
+    /**
+     * PUT JSON data to API, sending auth token in headers
+     * @param apiPath Path to URL endpoint under API
+     * @param body Data to send
+     * @param opts RequestInit opts, similar to Fetch API. If it contains
+     *  a body, it won't be stringified.
+     */
+    put(apiPath: string, body: any, opts?: RequestInit): Promise<any>;
+    /**
+     * Get from an API Endpoint, sending auth token in headers
+     * @param apiPath Path to URL endpoint under API
+     * @param opts RequestInit opts, similar to Fetch API
+     */
+    private _fetch;
+    private _handleApiResponse;
+    throwOrContinue(error: any, retries: number): void;
+}

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

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import TronWeb from "tronweb";
+import { EventEmitter } from 'events';
+import { Token } from "../utils/types";
+export declare class ContractSchemas extends EventEmitter {
+    web3: TronWeb;
+    networkName: string;
+    chainId: number;
+    contractsAddr: any;
+    WTRXAddr: string;
+    APENFTSharedAssetAddr: string;
+    APENFTExchangeKeeperAddr: string;
+    feeRecipientAddress: string;
+    APENFTExchange: string;
+    erc20AssetProxy: string;
+    erc721AssetProxy: string;
+    erc1155AssetProxy: string;
+    WTRXToken: Token;
+    paymentTokenList: Array<Token>;
+    TRX: Token;
+    Erc20Func: any;
+    APENFTRegistryFunc: any;
+    APENFTExchangeFunc: any;
+    constructor(web3: any, apiConfig: any);
+    getGasPrice(): Promise<number>;
+    tronCall(transactionConfig: any, outputs: any[]): Promise<any>;
+    tronSend(transactionConfig: any, from: string): Promise<any>;
+}

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

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { APIConfig, Token, TronWeb } from '../utils/types';
+import { EventEmitter } from 'events';
+export declare class Contracts extends EventEmitter {
+    web3: any;
+    networkName: string;
+    contractsAddr: any;
+    WTRXAddr: string;
+    APENFTSharedAssetAddr: string;
+    APENFTExchangeKeeperAddr: string;
+    feeRecipientAddress: string;
+    erc20AssetProxyAddr: string;
+    erc721AssetProxyAddr: string;
+    erc1155AssetProxyAddr: string;
+    factoryContractAddr: string;
+    erc20: any;
+    erc721: any;
+    erc1155: any;
+    authenticatedProxy: any;
+    exchange: any;
+    exchangeHelper: any;
+    APENFTSharedAsset: any;
+    erc20AssetProxy: any;
+    factoryContract: any;
+    WTRXToken: Token;
+    paymentTokenList: Array<Token>;
+    TRX: Token;
+    constructor(web3: TronWeb, apiConfig: APIConfig);
+}

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

@@ -0,0 +1,25 @@
+import TronWeb from "tronweb";
+import { OrdersAPI } from './ordersApi';
+import { Orders } from './orders';
+import { Account } from './account';
+import { AssetFactory } from './nft';
+import { APIConfig, Asset, SellOrderParams, EnglishAuctionOrderParams, BiddingOrderParams, BuyOrderParams, OrderJSON } from "../utils/types";
+export declare class APENFTOrders extends OrdersAPI {
+    orders: Orders;
+    account: Account;
+    assetFactory: AssetFactory;
+    walletProvider: TronWeb;
+    accountAddress: string;
+    constructor(walletProvider: TronWeb, apiConfig: APIConfig, walletAccount?: {
+        address?: string;
+        privateKey?: string;
+    });
+    ordersCancelSign(hash: string): Promise<any>;
+    getAssetOrderVersion(assetData: Asset): Promise<any>;
+    createSellOrder({ asset, quantity, paymentToken, listingTime, expirationTime, startAmount, endAmount, buyerAddress }: SellOrderParams): Promise<any>;
+    createAuctionOrder({ asset, quantity, paymentToken, expirationTime, startAmount, englishAuctionReservePrice }: EnglishAuctionOrderParams): Promise<any>;
+    createBiddingOrder({ asset, quantity, paymentToken, startAmount, bestAsk }: BiddingOrderParams): Promise<any>;
+    createBuyOrder({ asset, quantity, paymentToken, expirationTime, startAmount }: BuyOrderParams): Promise<any>;
+    createLowerPriceOrder({ oldOrder, parameter, asset }: any): Promise<any>;
+    acceptOrder(bestOrder: OrderJSON): Promise<any>;
+}