@waves/node-api-js 1.2.10 → 1.3.10-beta.1

package/es/api-node/assets/index.d.ts

@@ -1,79 +1,79 @@
-import { TLong } from '../../interface';
-import { AssetDecimals, IssueTransaction, SignedTransaction, WithApiMixin } from '@waves/ts-types';
-/**
- * GET /assets/details/{assetId}
- * Information about an asset
- */
-export declare function fetchDetails(base: string, assetId: string, options?: RequestInit): Promise<TAssetDetails>;
-export declare function fetchDetails(base: string, assetId: Array<string>, options?: RequestInit): Promise<Array<TAssetDetails>>;
-/**
- * POST /assets/details
- * Provides detailed information about the given assets
- */
-export declare function fetchAssetsDetails(base: string, assetIds: Array<string>, options?: RequestInit): Promise<Array<TAssetDetails | TErrorResponse>>;
-export declare function fetchAssetDistribution(base: string, assetId: string, height: number, limit: number, options?: RequestInit): Promise<IAssetDistribution>;
-/**
- * TODO
- * GET /assets/{assetId}/distribution
- * Asset balance distribution
- */
-export declare function fetchAssetsAddressLimit(base: string, address: string, limit: number, options?: RequestInit): Promise<Array<TAssetDetails>>;
-/**
- * TODO
- * GET assets/nft/${address}/limit/${limit}
- * Asset balance distribution
- */
-interface IFetchAssetsNftParams {
-    address: string;
-    limit: number;
-    after?: string;
-}
-export declare function fetchAssetsNft(base: string, { address, limit, after }: IFetchAssetsNftParams, options?: RequestInit): Promise<Array<TAssetDetails>>;
-export declare function fetchAssetsBalance(base: string, address: string, options?: RequestInit): Promise<TAssetsBalance>;
-export declare function fetchBalanceAddressAssetId(base: string, address: string, assetId: string, options?: RequestInit): Promise<IBalanceAddressAssetId>;
-export declare function convertEthAssetId(base: string, assetId: string): Promise<string>;
-export interface IAssetDistribution {
-    hasNext: boolean;
-    lastItem: string | null;
-    items: Record<string, number>;
-}
-export interface IBalanceAddressAssetId<LONG = TLong> {
-    address: string;
-    assetId: string;
-    balance: LONG;
-}
-export declare type TAssetsBalance = {
-    'address': string;
-    'balances': Array<TAssetBalance>;
-};
-export declare type TAssetBalance<LONG = TLong> = {
-    'assetId': string;
-    'balance': LONG;
-    'reissuable': true;
-    'minSponsoredAssetFee': LONG | null;
-    'sponsorBalance': LONG | null;
-    'quantity': LONG;
-    'issueTransaction': SignedTransaction<IssueTransaction & WithApiMixin> & {
-        feeAssetId: null;
-    };
-};
-export declare type TAssetDetails<LONG = TLong> = {
-    assetId: string;
-    issueHeight: number;
-    issueTimestamp: number;
-    issuer: string;
-    issuerPublicKey: string;
-    name: string;
-    description: string;
-    decimals: AssetDecimals;
-    reissuable: boolean;
-    quantity: LONG;
-    scripted: boolean;
-    minSponsoredAssetFee: LONG | null;
-    originTransactionId: string;
-};
-export declare type TErrorResponse = {
-    error: number;
-    message: string;
-};
-export {};
+import { TLong } from '../../interface';
+import { AssetDecimals, IssueTransaction, SignedTransaction, WithApiMixin } from '@waves/ts-types';
+/**
+ * GET /assets/details/{assetId}
+ * Information about an asset
+ */
+export declare function fetchDetails(base: string, assetId: string, options?: RequestInit): Promise<TAssetDetails>;
+export declare function fetchDetails(base: string, assetId: Array<string>, options?: RequestInit): Promise<Array<TAssetDetails>>;
+/**
+ * POST /assets/details
+ * Provides detailed information about the given assets
+ */
+export declare function fetchAssetsDetails(base: string, assetIds: Array<string>, options?: RequestInit): Promise<Array<TAssetDetails | TErrorResponse>>;
+export declare function fetchAssetDistribution(base: string, assetId: string, height: number, limit: number, options?: RequestInit): Promise<IAssetDistribution>;
+/**
+ * TODO
+ * GET /assets/{assetId}/distribution
+ * Asset balance distribution
+ */
+export declare function fetchAssetsAddressLimit(base: string, address: string, limit: number, options?: RequestInit): Promise<Array<TAssetDetails>>;
+/**
+ * TODO
+ * GET assets/nft/${address}/limit/${limit}
+ * Asset balance distribution
+ */
+interface IFetchAssetsNftParams {
+    address: string;
+    limit: number;
+    after?: string;
+}
+export declare function fetchAssetsNft(base: string, { address, limit, after }: IFetchAssetsNftParams, options?: RequestInit): Promise<Array<TAssetDetails>>;
+export declare function fetchAssetsBalance(base: string, address: string, options?: RequestInit): Promise<TAssetsBalance>;
+export declare function fetchBalanceAddressAssetId(base: string, address: string, assetId: string, options?: RequestInit): Promise<IBalanceAddressAssetId>;
+export declare function convertEthAssetId(base: string, assetId: string): Promise<string>;
+export interface IAssetDistribution {
+    hasNext: boolean;
+    lastItem: string | null;
+    items: Record<string, number>;
+}
+export interface IBalanceAddressAssetId<LONG = TLong> {
+    address: string;
+    assetId: string;
+    balance: LONG;
+}
+export declare type TAssetsBalance = {
+    'address': string;
+    'balances': Array<TAssetBalance>;
+};
+export declare type TAssetBalance<LONG = TLong> = {
+    'assetId': string;
+    'balance': LONG;
+    'reissuable': true;
+    'minSponsoredAssetFee': LONG | null;
+    'sponsorBalance': LONG | null;
+    'quantity': LONG;
+    'issueTransaction': SignedTransaction<IssueTransaction & WithApiMixin> & {
+        feeAssetId: null;
+    };
+};
+export declare type TAssetDetails<LONG = TLong> = {
+    assetId: string;
+    issueHeight: number;
+    issueTimestamp: number;
+    issuer: string;
+    issuerPublicKey: string;
+    name: string;
+    description: string;
+    decimals: AssetDecimals;
+    reissuable: boolean;
+    quantity: LONG;
+    scripted: boolean;
+    minSponsoredAssetFee: LONG | null;
+    originTransactionId: string;
+};
+export declare type TErrorResponse = {
+    error: number;
+    message: string;
+};
+export {};

package/es/api-node/assets/index.js

@@ -1,103 +1,103 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { TRANSACTION_TYPE } from '@waves/ts-types';
-import request from '../../tools/request';
-import { toArray } from '../../tools/utils';
-import query from "../../tools/query";
-export function fetchDetails(base, assetId, options = Object.create(null)) {
-    const isOnce = !Array.isArray(assetId);
-    return Promise.all(toArray(assetId).map(id => request({
-        base,
-        url: `/assets/details/${id}`,
-        options
-    })))
-        .then(list => isOnce ? list[0] : list);
-}
-/**
- * POST /assets/details
- * Provides detailed information about the given assets
- */
-export function fetchAssetsDetails(base, assetIds, options = Object.create(null)) {
-    const body = JSON.stringify({ ids: assetIds });
-    const _options = Object.assign(Object.assign({}, options), { body, headers: {
-            'content-type': 'application/json'
-        }, method: 'POST' });
-    return request({ base, url: `/assets/details`, options: _options });
-}
-export function fetchAssetDistribution(base, assetId, height, limit, options = Object.create(null)) {
-    return request({ base, url: `/assets/${assetId}/distribution/${height}/limit/${limit}`, options });
-}
-/**
- * TODO
- * GET /assets/{assetId}/distribution
- * Asset balance distribution
- */
-export function fetchAssetsAddressLimit(base, address, limit, options = Object.create(null)) {
-    return request({ base, url: `assets/nft/${address}/limit/${limit}`, options });
-}
-export function fetchAssetsNft(base, { address, limit, after }, options = Object.create(null)) {
-    const url = new URL(`assets/nft/${address}/limit/${limit}`, base);
-    if (after) {
-        url.searchParams.append('after', after);
-    }
-    return request({ base, url: `${url.pathname}${url.search}`, options });
-}
-export function fetchAssetsBalance(base, address, options = Object.create(null)) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const balancesResponse = yield request({ base, url: `/assets/balance/${address}`, options });
-        const assetsWithoutIssueTransaction = balancesResponse.balances.reduce((acc, balance, index) => {
-            if (!balance.issueTransaction) {
-                acc[balance.assetId] = index;
-            }
-            return acc;
-        }, {});
-        const detailsIds = Object.keys(assetsWithoutIssueTransaction);
-        if (detailsIds.length) {
-            const assetsDetailsResponse = yield fetchAssetsDetails(base, detailsIds, options);
-            assetsDetailsResponse.forEach((assetDetails) => {
-                if ('error' in assetDetails) {
-                    return;
-                }
-                const assetIndex = assetsWithoutIssueTransaction[assetDetails.assetId];
-                const assetBalance = balancesResponse.balances[assetIndex];
-                if (!assetBalance) {
-                    return;
-                }
-                assetBalance.issueTransaction = {
-                    id: assetDetails.originTransactionId,
-                    name: assetDetails.name,
-                    decimals: assetDetails.decimals,
-                    description: assetDetails.description,
-                    quantity: assetDetails.quantity,
-                    reissuable: assetDetails.reissuable,
-                    sender: assetDetails.issuer,
-                    senderPublicKey: assetDetails.issuerPublicKey,
-                    timestamp: assetDetails.issueTimestamp,
-                    height: assetDetails.issueHeight,
-                    script: assetDetails.scripted ? '-' : null,
-                    proofs: [],
-                    fee: Math.pow(10, 8),
-                    feeAssetId: null,
-                    version: 3,
-                    type: TRANSACTION_TYPE.ISSUE,
-                    chainId: 0
-                };
-            });
-        }
-        return balancesResponse;
-    });
-}
-export function fetchBalanceAddressAssetId(base, address, assetId, options = Object.create(null)) {
-    return request({ base, url: `/assets/balance/${address}/${assetId}`, options });
-}
-export function convertEthAssetId(base, assetId) {
-    return request({ base, url: `/eth/assets${query({ id: assetId })}` }).then(assets => assets[0].assetId);
-}
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { TRANSACTION_TYPE } from '@waves/ts-types';
+import request from '../../tools/request';
+import { toArray } from '../../tools/utils';
+import query from "../../tools/query";
+export function fetchDetails(base, assetId, options = Object.create(null)) {
+    const isOnce = !Array.isArray(assetId);
+    return Promise.all(toArray(assetId).map(id => request({
+        base,
+        url: `/assets/details/${id}`,
+        options
+    })))
+        .then(list => isOnce ? list[0] : list);
+}
+/**
+ * POST /assets/details
+ * Provides detailed information about the given assets
+ */
+export function fetchAssetsDetails(base, assetIds, options = Object.create(null)) {
+    const body = JSON.stringify({ ids: assetIds });
+    const _options = Object.assign(Object.assign({}, options), { body, headers: {
+            'content-type': 'application/json'
+        }, method: 'POST' });
+    return request({ base, url: `/assets/details`, options: _options });
+}
+export function fetchAssetDistribution(base, assetId, height, limit, options = Object.create(null)) {
+    return request({ base, url: `/assets/${assetId}/distribution/${height}/limit/${limit}`, options });
+}
+/**
+ * TODO
+ * GET /assets/{assetId}/distribution
+ * Asset balance distribution
+ */
+export function fetchAssetsAddressLimit(base, address, limit, options = Object.create(null)) {
+    return request({ base, url: `assets/nft/${address}/limit/${limit}`, options });
+}
+export function fetchAssetsNft(base, { address, limit, after }, options = Object.create(null)) {
+    const url = new URL(`assets/nft/${address}/limit/${limit}`, base);
+    if (after) {
+        url.searchParams.append('after', after);
+    }
+    return request({ base, url: `${url.pathname}${url.search}`, options });
+}
+export function fetchAssetsBalance(base, address, options = Object.create(null)) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const balancesResponse = yield request({ base, url: `/assets/balance/${address}`, options });
+        const assetsWithoutIssueTransaction = balancesResponse.balances.reduce((acc, balance, index) => {
+            if (!balance.issueTransaction) {
+                acc[balance.assetId] = index;
+            }
+            return acc;
+        }, {});
+        const detailsIds = Object.keys(assetsWithoutIssueTransaction);
+        if (detailsIds.length) {
+            const assetsDetailsResponse = yield fetchAssetsDetails(base, detailsIds, options);
+            assetsDetailsResponse.forEach((assetDetails) => {
+                if ('error' in assetDetails) {
+                    return;
+                }
+                const assetIndex = assetsWithoutIssueTransaction[assetDetails.assetId];
+                const assetBalance = balancesResponse.balances[assetIndex];
+                if (!assetBalance) {
+                    return;
+                }
+                assetBalance.issueTransaction = {
+                    id: assetDetails.originTransactionId,
+                    name: assetDetails.name,
+                    decimals: assetDetails.decimals,
+                    description: assetDetails.description,
+                    quantity: assetDetails.quantity,
+                    reissuable: assetDetails.reissuable,
+                    sender: assetDetails.issuer,
+                    senderPublicKey: assetDetails.issuerPublicKey,
+                    timestamp: assetDetails.issueTimestamp,
+                    height: assetDetails.issueHeight,
+                    script: assetDetails.scripted ? '-' : null,
+                    proofs: [],
+                    fee: Math.pow(10, 8),
+                    feeAssetId: null,
+                    version: 3,
+                    type: TRANSACTION_TYPE.ISSUE,
+                    chainId: 0
+                };
+            });
+        }
+        return balancesResponse;
+    });
+}
+export function fetchBalanceAddressAssetId(base, address, assetId, options = Object.create(null)) {
+    return request({ base, url: `/assets/balance/${address}/${assetId}`, options });
+}
+export function convertEthAssetId(base, assetId) {
+    return request({ base, url: `/eth/assets${query({ id: assetId })}` }).then(assets => assets[0].assetId);
+}
 //# sourceMappingURL=index.js.map

package/es/api-node/blocks/index.d.ts

@@ -1,131 +1,143 @@
-import { TLong } from '../../interface';
-import { TransactionFromNode, WithApiMixin } from '@waves/ts-types';
-/**
- * GET /blocks/headers/seq/{from}/{to}
- * Get block headers at specified heights
- * @param base
- * @param from
- * @param to
- */
-export declare function fetchHeadersSeq(base: string, from: number, to: number, options?: RequestInit): Promise<Array<IBlockHeader>>;
-/**
- * GET /blocks/headers/last
- * Last block header
- * @param base
- */
-export declare function fetchHeadersLast(base: string, options?: RequestInit): Promise<IBlockHeader>;
-/**
- * GET /blocks/height/{id}
- * Height of a block by its id
- * @param base
- * @param id
- */
-export declare function fetchHeightById(base: string, id: string): Promise<{
-    height: number;
-}>;
-/**
- * GET /blocks/headers/at/{height}
- * Block header at height
- * @param base
- * @param height
- */
-export declare function fetchHeadersAt(base: string, height: number, options?: RequestInit): Promise<IBlockHeader>;
-/**
- * GET /blocks/headers/{id}
- * Get block at specified height
- * @param base
- * @param height
- */
-export declare function fetchHeadersById(base: string, id: string, options?: RequestInit): Promise<IBlock>;
-/**
- * GET /blocks/at/{height}
- * Get block at specified height
- * @param base
- * @param height
- */
-export declare function fetchBlockAt(base: string, height: number, options?: RequestInit): Promise<IBlock>;
-/**
- * GET /blocks/seq/{from}/{to}
- * Block range
- * @param base
- * @param from
- * @param to
- */
-export declare function fetchSeq(base: string, from: number, to: number, options?: RequestInit): Promise<Array<IBlock>>;
-/**
- * GET /blocks/{id}
- * Get block by its id
- * @param base
- * @param id
- */
-export declare function fetchBlockById(base: string, id: string, options?: RequestInit): Promise<IBlock>;
-/**
- * GET /blocks/first
- * Get genesis block
- * @param base
- */
-export declare function fetchFirst(base: string, options?: RequestInit): Promise<IBlock>;
-/**
- * /blocks/address/{address}/{from}/{to}
- * Get list of blocks generated by specified address
- * @param base
- * @param address
- * @param from
- * @param to
- */
-export declare function fetchBlocksByAddress(base: string, address: string, from: number, to: number, options?: RequestInit): Promise<Array<IBlock>>;
-/**
- * GET /blocks/last
- * Last block
- * @param base
- */
-export declare function fetchLast(base: string, options?: RequestInit): Promise<IBlock>;
-/**
- * GET /blocks/delay/{id}/{blockNum}
- * Average delay in milliseconds between last blockNum blocks starting from block with id
- * @param base
- * @param id
- * @param blockNum
- */
-export declare function fetchDelay(base: string, id: string, blockNum: number): Promise<{
-    delay: number;
-}>;
-/**
- * GET /blocks/height
- * @param base
- */
-export declare function fetchHeight(base: string): Promise<{
-    height: number;
-}>;
-/**
- * GET /blocks/heightByTimestamp
- * @param base
- */
-export declare function fetchHeightByTimestamp(base: string, timestamp: number, options?: RequestInit): Promise<{
-    height: number;
-}>;
-export interface IBlockHeader {
-    id: string;
-    blocksize: number;
-    reward: TLong;
-    signature: string;
-    VRF: string;
-    generator: string;
-    generatorPublicKey: string;
-    version: number;
-    reference: string;
-    features: Array<string>;
-    totalFee: TLong;
-    desiredReward: number;
-    transactionCount: number;
-    timestamp: number;
-    height: number;
-    'nxt-consensus': {
-        'base-target': number;
-        'generation-signature': string;
-    };
-}
-export interface IBlock extends IBlockHeader {
-    fee: TLong;
-    transactions: Array<TransactionFromNode & WithApiMixin>;
-}
+import { TLong } from '../../interface';
+import { TransactionFromNode, WithApiMixin } from '@waves/ts-types';
+/**
+ * GET /blocks/headers/seq/{from}/{to}
+ * Get block headers at specified heights
+ * @param base
+ * @param from
+ * @param to
+ */
+export declare function fetchHeadersSeq(base: string, from: number, to: number, options?: RequestInit): Promise<Array<IBlockHeader>>;
+/**
+ * GET /blocks/headers/last
+ * Last block header
+ * @param base
+ */
+export declare function fetchHeadersLast(base: string, options?: RequestInit): Promise<IBlockHeader>;
+/**
+ * GET /blocks/height/{id}
+ * Height of a block by its id
+ * @param base
+ * @param id
+ */
+export declare function fetchHeightById(base: string, id: string): Promise<{
+    height: number;
+}>;
+/**
+ * GET /blocks/headers/at/{height}
+ * Block header at height
+ * @param base
+ * @param height
+ */
+export declare function fetchHeadersAt(base: string, height: number, options?: RequestInit): Promise<IBlockHeader>;
+/**
+ * GET /blocks/headers/{id}
+ * Get block at specified height
+ * @param base
+ * @param height
+ */
+export declare function fetchHeadersById(base: string, id: string, options?: RequestInit): Promise<IBlock>;
+/**
+ * GET /blocks/at/{height}
+ * Get block at specified height
+ * @param base
+ * @param height
+ */
+export declare function fetchBlockAt(base: string, height: number, options?: RequestInit): Promise<IBlock>;
+/**
+ * GET /blocks/seq/{from}/{to}
+ * Block range
+ * @param base
+ * @param from
+ * @param to
+ */
+export declare function fetchSeq(base: string, from: number, to: number, options?: RequestInit): Promise<Array<IBlock>>;
+/**
+ * GET /blocks/{id}
+ * Get block by its id
+ * @param base
+ * @param id
+ */
+export declare function fetchBlockById(base: string, id: string, options?: RequestInit): Promise<IBlock>;
+/**
+ * GET /blocks/first
+ * Get genesis block
+ * @param base
+ */
+export declare function fetchFirst(base: string, options?: RequestInit): Promise<IBlock>;
+/**
+ * /blocks/address/{address}/{from}/{to}
+ * Get list of blocks generated by specified address
+ * @param base
+ * @param address
+ * @param from
+ * @param to
+ */
+export declare function fetchBlocksByAddress(base: string, address: string, from: number, to: number, options?: RequestInit): Promise<Array<IBlock>>;
+/**
+ * GET /blocks/last
+ * Last block
+ * @param base
+ */
+export declare function fetchLast(base: string, options?: RequestInit): Promise<IBlock>;
+/**
+ * GET /blocks/delay/{id}/{blockNum}
+ * Average delay in milliseconds between last blockNum blocks starting from block with id
+ * @param base
+ * @param id
+ * @param blockNum
+ */
+export declare function fetchDelay(base: string, id: string, blockNum: number): Promise<{
+    delay: number;
+}>;
+/**
+ * GET /blocks/height
+ * @param base
+ */
+export declare function fetchHeight(base: string): Promise<{
+    height: number;
+}>;
+/**
+ * GET /blocks/heightByTimestamp
+ * @param base
+ */
+export declare function fetchHeightByTimestamp(base: string, timestamp: number, options?: RequestInit): Promise<{
+    height: number;
+}>;
+export interface IBlockHeader {
+    id: string;
+    blocksize: number;
+    reward: TLong;
+    signature: string;
+    VRF: string;
+    generator: string;
+    generatorPublicKey: string;
+    version: number;
+    reference: string;
+    features: Array<number>;
+    totalFee: TLong;
+    desiredReward: number;
+    transactionCount: number;
+    timestamp: number;
+    height: number;
+    'nxt-consensus': {
+        'base-target': number;
+        'generation-signature': string;
+    };
+    stateHash?: string;
+    rewardShares?: {
+        [key: string]: TLong;
+    };
+    challengedHeader?: {
+        headerSignature: string;
+        features: Array<string>;
+        generator: string;
+        generatorPublicKey: string;
+        desiredReward: TLong;
+        stateHash: string;
+    };
+}
+export interface IBlock extends IBlockHeader {
+    fee: TLong;
+    transactions: Array<TransactionFromNode & WithApiMixin>;
+}