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

package/es/tools/request.d.ts

@@ -1,64 +1,64 @@
-export default function <T>(params: IRequestParams<T>): Promise<T>;
-export declare function parseResponse<T>(r: Response): Promise<T>;
-export interface IRequestParams<T> {
-    url: string;
-    base: string;
-    options?: RequestInit | undefined;
-}
-export interface RequestInit {
-    /**
-     * A BodyInit object or null to set request's body.
-     */
-    body?: BodyInit | null;
-    /**
-     * A string indicating how the request will interact with the browser's cache to set request's cache.
-     * Not supported in nodejs environment
-     */
-    cache?: RequestCache;
-    /**
-     * A string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. Sets request's credentials.
-     */
-    credentials?: RequestCredentials;
-    /**
-     * A Headers object, an object literal, or an array of two-item arrays to set request's headers.
-     * Not supported in nodejs environment
-     */
-    headers?: HeadersInit;
-    /**
-     * A cryptographic hash of the resource to be fetched by request. Sets request's integrity.
-     */
-    integrity?: string;
-    /**
-     * A boolean to set request's keepalive.
-     */
-    keepalive?: boolean;
-    /**
-     * A string to set request's method.
-     */
-    method?: string;
-    /**
-     * A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode.
-     * Not supported in nodejs environment
-     */
-    mode?: RequestMode;
-    /**
-     * A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect.
-     */
-    redirect?: RequestRedirect;
-    /**
-     * A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer.
-     */
-    referrer?: string;
-    /**
-     * A referrer policy to set request's referrerPolicy.
-     */
-    referrerPolicy?: ReferrerPolicy;
-    /**
-     * An AbortSignal to set request's signal.
-     */
-    signal?: AbortSignal | null;
-    /**
-     * Can only be null. Used to disassociate request from any Window.
-     */
-    window?: any;
-}
+export default function <T>(params: IRequestParams<T>): Promise<T>;
+export declare function parseResponse<T>(r: Response): Promise<T>;
+export interface IRequestParams<T> {
+    url: string;
+    base: string;
+    options?: RequestInit | undefined;
+}
+export interface RequestInit {
+    /**
+     * A BodyInit object or null to set request's body.
+     */
+    body?: BodyInit | null;
+    /**
+     * A string indicating how the request will interact with the browser's cache to set request's cache.
+     * Not supported in nodejs environment
+     */
+    cache?: RequestCache;
+    /**
+     * A string indicating whether credentials will be sent with the request always, never, or only when sent to a same-origin URL. Sets request's credentials.
+     */
+    credentials?: RequestCredentials;
+    /**
+     * A Headers object, an object literal, or an array of two-item arrays to set request's headers.
+     * Not supported in nodejs environment
+     */
+    headers?: HeadersInit;
+    /**
+     * A cryptographic hash of the resource to be fetched by request. Sets request's integrity.
+     */
+    integrity?: string;
+    /**
+     * A boolean to set request's keepalive.
+     */
+    keepalive?: boolean;
+    /**
+     * A string to set request's method.
+     */
+    method?: string;
+    /**
+     * A string to indicate whether the request will use CORS, or will be restricted to same-origin URLs. Sets request's mode.
+     * Not supported in nodejs environment
+     */
+    mode?: RequestMode;
+    /**
+     * A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect.
+     */
+    redirect?: RequestRedirect;
+    /**
+     * A string whose value is a same-origin URL, "about:client", or the empty string, to set request's referrer.
+     */
+    referrer?: string;
+    /**
+     * A referrer policy to set request's referrerPolicy.
+     */
+    referrerPolicy?: ReferrerPolicy;
+    /**
+     * An AbortSignal to set request's signal.
+     */
+    signal?: AbortSignal | null;
+    /**
+     * Can only be null. Used to disassociate request from any Window.
+     */
+    window?: any;
+}

package/es/tools/request.js

@@ -1,22 +1,22 @@
-import resolve from './resolve';
-import parse from './parse';
-const request = typeof fetch === 'function' ? fetch : require('node-fetch');
-export default function (params) {
-    return request(resolve(params.url, params.base), updateHeaders(params.options))
-        .then(parseResponse);
-}
-export function parseResponse(r) {
-    return r.text().then(message => r.ok ? parse(message) : Promise.reject(tryParse(message)));
-}
-function tryParse(message) {
-    try {
-        return JSON.parse(message);
-    }
-    catch (e) {
-        return message;
-    }
-}
-function updateHeaders(options = Object.create(null)) {
-    return Object.assign({ credentials: 'include' }, options);
-}
+import resolve from './resolve';
+import parse from './parse';
+const request = typeof fetch === 'function' ? fetch : require('node-fetch');
+export default function (params) {
+    return request(resolve(params.url, params.base), updateHeaders(params.options))
+        .then(parseResponse);
+}
+export function parseResponse(r) {
+    return r.text().then(message => r.ok ? parse(message) : Promise.reject(tryParse(message)));
+}
+function tryParse(message) {
+    try {
+        return JSON.parse(message);
+    }
+    catch (e) {
+        return message;
+    }
+}
+function updateHeaders(options = Object.create(null)) {
+    return Object.assign({ credentials: 'include' }, options);
+}
 //# sourceMappingURL=request.js.map

package/es/tools/resolve.d.ts

@@ -1 +1 @@
-export default function (path: string, base: string): string;
+export default function (path: string, base: string): string;

package/es/tools/resolve.js

@@ -1,4 +1,4 @@
-export default function (path, base) {
-    return new URL(path, base).toString();
-}
+export default function (path, base) {
+    return new URL(path, base).toString();
+}
 //# sourceMappingURL=resolve.js.map

package/es/tools/stringify.d.ts

@@ -1 +1 @@
-export default function <T extends Record<string, any>>(data: T): string;
+export default function <T extends Record<string, any>>(data: T): string;

package/es/tools/stringify.js

@@ -1,18 +1,18 @@
-const FIELDS = ['amount', 'matcherFee', 'price', 'minSponsoredAssetFee', 'fee', 'quantity', 'sellMatcherFee', 'buyMatcherFee'];
-export default function (data) {
-    return JSON.stringify(data, function (key, value) {
-        if (FIELDS.includes(key) && value) {
-            return `!${value}!`;
-        }
-        else if (key === 'value' && this['type'] === 'integer') {
-            return `!${value}!`;
-        }
-        else if (key === 'minSponsoredAssetFee' && value == null) {
-            return null;
-        }
-        else {
-            return value;
-        }
-    }, 0).replace(/"\!(-?\d+)\!"/g, '$1');
-}
+const FIELDS = ['amount', 'matcherFee', 'price', 'minSponsoredAssetFee', 'fee', 'quantity', 'sellMatcherFee', 'buyMatcherFee'];
+export default function (data) {
+    return JSON.stringify(data, function (key, value) {
+        if (FIELDS.includes(key) && value) {
+            return `!${value}!`;
+        }
+        else if (key === 'value' && this['type'] === 'integer') {
+            return `!${value}!`;
+        }
+        else if (key === 'minSponsoredAssetFee' && value == null) {
+            return null;
+        }
+        else {
+            return value;
+        }
+    }, 0).replace(/"\!(-?\d+)\!"/g, '$1');
+}
 //# sourceMappingURL=stringify.js.map

package/es/tools/transactions/broadcast.d.ts

@@ -1,14 +1,14 @@
-import { TLong } from '../../interface';
-import { SignedTransaction, Transaction, TransactionMap, WithApiMixin } from '@waves/ts-types';
-export declare type TMap<MAP extends Record<string | number, any>, Key extends keyof MAP> = MAP[Key];
-export declare type TMapTuple<T extends Array<Record<string | number, any>>, TO_MAP extends Record<string | number, Record<string | number, any>>, KEY> = {
-    [K in keyof T]: KEY extends keyof T[K] ? T[K][KEY] extends infer R ? R extends keyof TO_MAP ? TO_MAP[R] : never : never : never;
-};
-export default function <T extends Array<SignedTransaction<Transaction<TLong>>>>(base: string, list: T): Promise<TMapTuple<T, TransactionMap, 'type'> & WithApiMixin>;
-export default function <T extends Transaction<TLong>>(base: string, tx: SignedTransaction<T>, options?: Partial<IOptions>): Promise<TMap<TransactionMap<TLong>, T['type']> & WithApiMixin>;
-export interface IOptions {
-    chain: boolean;
-    confirmations: number;
-    maxWaitTime: number;
-    requestInterval: number;
-}
+import { TLong } from '../../interface';
+import { SignedTransaction, Transaction, TransactionMap, WithApiMixin } from '@waves/ts-types';
+export declare type TMap<MAP extends Record<string | number, any>, Key extends keyof MAP> = MAP[Key];
+export declare type TMapTuple<T extends Array<Record<string | number, any>>, TO_MAP extends Record<string | number, Record<string | number, any>>, KEY> = {
+    [K in keyof T]: KEY extends keyof T[K] ? T[K][KEY] extends infer R ? R extends keyof TO_MAP ? TO_MAP[R] : never : never : never;
+};
+export default function <T extends Array<SignedTransaction<Transaction<TLong>>>>(base: string, list: T): Promise<TMapTuple<T, TransactionMap, 'type'> & WithApiMixin>;
+export default function <T extends Transaction<TLong>>(base: string, tx: SignedTransaction<T>, options?: Partial<IOptions>): Promise<TMap<TransactionMap<TLong>, T['type']> & WithApiMixin>;
+export interface IOptions {
+    chain: boolean;
+    confirmations: number;
+    maxWaitTime: number;
+    requestInterval: number;
+}

package/es/tools/transactions/broadcast.js

@@ -1,43 +1,43 @@
-import { broadcast } from '../../api-node/transactions';
-import { head, toArray } from '../utils';
-import wait from './wait';
-const DEFAULT_BROADCAST_OPTIONS = {
-    chain: false,
-    confirmations: -1,
-    maxWaitTime: 0,
-    requestInterval: 0
-};
-export default function (base, list, options) {
-    const opt = Object.assign(Object.assign({}, DEFAULT_BROADCAST_OPTIONS), (options || {}));
-    const isOnce = !Array.isArray(list);
-    const confirmations = opt.confirmations > 0 ? 1 : 0;
-    return (opt.chain
-        ? chainBroadcast(base, toArray(list), Object.assign(Object.assign({}, opt), { confirmations }))
-        : simpleBroadcast(base, toArray(list)))
-        .then(list => opt.confirmations <= 0 ? list : wait(base, list, opt))
-        .then(list => isOnce ? head(list) : list);
-}
-function simpleBroadcast(base, list) {
-    return Promise.all(list.map(tx => broadcast(base, tx)));
-}
-function chainBroadcast(base, list, options) {
-    return new Promise((resolve, reject) => {
-        const toBroadcast = list.slice().reverse();
-        const result = [];
-        const loop = () => {
-            if (!toBroadcast.length) {
-                resolve(result);
-                return null;
-            }
-            const tx = toBroadcast.pop();
-            broadcast(base, tx)
-                .then(tx => wait(base, tx, options))
-                .then(tx => {
-                result.push(tx);
-                loop();
-            }, reject);
-        };
-        loop();
-    });
-}
+import { broadcast } from '../../api-node/transactions';
+import { head, toArray } from '../utils';
+import wait from './wait';
+const DEFAULT_BROADCAST_OPTIONS = {
+    chain: false,
+    confirmations: -1,
+    maxWaitTime: 0,
+    requestInterval: 0
+};
+export default function (base, list, options) {
+    const opt = Object.assign(Object.assign({}, DEFAULT_BROADCAST_OPTIONS), (options || {}));
+    const isOnce = !Array.isArray(list);
+    const confirmations = opt.confirmations > 0 ? 1 : 0;
+    return (opt.chain
+        ? chainBroadcast(base, toArray(list), Object.assign(Object.assign({}, opt), { confirmations }))
+        : simpleBroadcast(base, toArray(list)))
+        .then(list => opt.confirmations <= 0 ? list : wait(base, list, opt))
+        .then(list => isOnce ? head(list) : list);
+}
+function simpleBroadcast(base, list) {
+    return Promise.all(list.map(tx => broadcast(base, tx)));
+}
+function chainBroadcast(base, list, options) {
+    return new Promise((resolve, reject) => {
+        const toBroadcast = list.slice().reverse();
+        const result = [];
+        const loop = () => {
+            if (!toBroadcast.length) {
+                resolve(result);
+                return null;
+            }
+            const tx = toBroadcast.pop();
+            broadcast(base, tx)
+                .then(tx => wait(base, tx, options))
+                .then(tx => {
+                result.push(tx);
+                loop();
+            }, reject);
+        };
+        loop();
+    });
+}
 //# sourceMappingURL=broadcast.js.map

package/es/tools/transactions/ethTxId2waves.d.ts

@@ -1 +1 @@
-export default function ethTxId2waves(ethTxId: string): string;
+export default function ethTxId2waves(ethTxId: string): string;

package/es/tools/transactions/ethTxId2waves.js

@@ -1,8 +1,8 @@
-import { base16Decode, base58Encode } from '@waves/ts-lib-crypto';
-export default function ethTxId2waves(ethTxId) {
-    let id = ethTxId;
-    if (ethTxId.startsWith('0x'))
-        id = ethTxId.slice(2);
-    return base58Encode(base16Decode(id));
-}
+import { base16Decode, base58Encode } from '@waves/ts-lib-crypto';
+export default function ethTxId2waves(ethTxId) {
+    let id = ethTxId;
+    if (ethTxId.startsWith('0x'))
+        id = ethTxId.slice(2);
+    return base58Encode(base16Decode(id));
+}
 //# sourceMappingURL=ethTxId2waves.js.map

package/es/tools/transactions/wait.d.ts

@@ -1,10 +1,10 @@
-import { TLong } from '../../interface';
-import { Transaction, WithApiMixin } from '@waves/ts-types';
-export default function <T extends Transaction<TLong> & WithApiMixin>(base: string, tx: T, options?: IWaitOptions): Promise<T>;
-export default function <T extends Transaction<TLong> & WithApiMixin>(base: string, list: Array<T>, options?: IWaitOptions): Promise<Array<T>>;
-export default function <T extends Transaction<TLong> & WithApiMixin>(base: string, tx: T | Array<T>, options?: IWaitOptions): Promise<T | Array<T>>;
-export interface IWaitOptions {
-    confirmations?: number;
-    maxWaitTime?: number;
-    requestInterval?: number;
-}
+import { TLong } from '../../interface';
+import { Transaction, WithApiMixin } from '@waves/ts-types';
+export default function <T extends Transaction<TLong> & WithApiMixin>(base: string, tx: T, options?: IWaitOptions): Promise<T>;
+export default function <T extends Transaction<TLong> & WithApiMixin>(base: string, list: Array<T>, options?: IWaitOptions): Promise<Array<T>>;
+export default function <T extends Transaction<TLong> & WithApiMixin>(base: string, tx: T | Array<T>, options?: IWaitOptions): Promise<T | Array<T>>;
+export interface IWaitOptions {
+    confirmations?: number;
+    maxWaitTime?: number;
+    requestInterval?: number;
+}

package/es/tools/transactions/wait.js

@@ -1,39 +1,39 @@
-import { head, indexBy, prop, toArray, wait } from '../utils';
-import { fetchStatus } from '../../api-node/transactions';
-import { TRANSACTION_STATUSES } from '../../constants';
-export default function (base, tx, options) {
-    const isOnce = !Array.isArray(tx);
-    const start = Date.now();
-    const confirmed = [];
-    const confirmations = options && options.confirmations || 0;
-    const maxWaitTime = options && options.maxWaitTime || 0;
-    const requestInterval = options && options.requestInterval || 250;
-    const waitTx = (list) => {
-        return fetchStatus(base, list.map(prop('id')))
-            .then(status => {
-            const hash = indexBy(prop('id'), status.statuses);
-            const hasError = list.some(tx => hash[tx.id].status === TRANSACTION_STATUSES.NOT_FOUND);
-            if (hasError) {
-                throw new Error('One transaction is not in blockchain!');
-            }
-            const toRequest = list.filter(tx => {
-                if (hash[tx.id].confirmations >= confirmations) {
-                    confirmed.push(tx);
-                    return false;
-                }
-                else {
-                    return true;
-                }
-            });
-            if (!toRequest.length) {
-                return void 0;
-            }
-            if (maxWaitTime && Date.now() - start > maxWaitTime) {
-                return Promise.reject('Timeout error!');
-            }
-            return wait(requestInterval).then(() => waitTx(toRequest));
-        });
-    };
-    return waitTx(toArray(tx)).then(() => isOnce ? head(confirmed) : confirmed);
-}
+import { head, indexBy, prop, toArray, wait } from '../utils';
+import { fetchStatus } from '../../api-node/transactions';
+import { TRANSACTION_STATUSES } from '../../constants';
+export default function (base, tx, options) {
+    const isOnce = !Array.isArray(tx);
+    const start = Date.now();
+    const confirmed = [];
+    const confirmations = options && options.confirmations || 0;
+    const maxWaitTime = options && options.maxWaitTime || 0;
+    const requestInterval = options && options.requestInterval || 250;
+    const waitTx = (list) => {
+        return fetchStatus(base, list.map(prop('id')))
+            .then(status => {
+            const hash = indexBy(prop('id'), status.statuses);
+            const hasError = list.some(tx => hash[tx.id].status === TRANSACTION_STATUSES.NOT_FOUND);
+            if (hasError) {
+                throw new Error('One transaction is not in blockchain!');
+            }
+            const toRequest = list.filter(tx => {
+                if (hash[tx.id].confirmations >= confirmations) {
+                    confirmed.push(tx);
+                    return false;
+                }
+                else {
+                    return true;
+                }
+            });
+            if (!toRequest.length) {
+                return void 0;
+            }
+            if (maxWaitTime && Date.now() - start > maxWaitTime) {
+                return Promise.reject('Timeout error!');
+            }
+            return wait(requestInterval).then(() => waitTx(toRequest));
+        });
+    };
+    return waitTx(toArray(tx)).then(() => isOnce ? head(confirmed) : confirmed);
+}
 //# sourceMappingURL=wait.js.map

package/es/tools/utils.d.ts

@@ -1,32 +1,32 @@
-import { TransactionMap, Transaction } from '@waves/ts-types';
-import { TLong } from '../interface';
-export declare function isObject(obj: any): boolean;
-export declare function toArray<T>(data: T | Array<T>): Array<T>;
-export declare function head<T>(data: Array<T>): T | undefined;
-export declare function wait(time: number): Promise<void>;
-export declare function prop<T extends Record<string, any>, P extends keyof T>(key: P): (data: T) => T[P];
-export declare const keys: <T extends Record<import("@waves/ts-types").Long, any>>(obj: T) => (keyof T)[];
-export declare const entries: <T extends Record<import("@waves/ts-types").Long, any>>(obj: T) => [keyof T, T[keyof T]][];
-export declare const values: <T extends Record<import("@waves/ts-types").Long, any>>(obj: T) => T[keyof T][];
-export declare const assign: <T extends Record<import("@waves/ts-types").Long, any>, R extends Record<import("@waves/ts-types").Long, any>>(target: T, merge: R) => T & R;
-export declare const deepAssign: <T extends Record<import("@waves/ts-types").Long, any>[]>(...objects: T) => TUnionToIntersection<T[number]>;
-export declare function map<T, U>(process: (data: T, index: number) => U): (list: Array<T>) => Array<U>;
-export declare function filter<T>(process: (data: T, index: number) => boolean): (list: Array<T>) => Array<T>;
-export declare function filter<T, S extends T>(process: (data: T, index: number) => data is S): (list: Array<T>) => Array<S>;
-export declare function indexBy<T extends Record<string, any>, P extends (data: T) => string | number>(process: (data: T) => T[keyof T], data: Array<T>): Record<ReturnType<P>, T>;
-export declare const uniq: (list: Array<string | null>) => Array<string | null>;
-declare type TChoices = {
-    [Key in keyof TransactionMap<TLong>]?: (data: TransactionMap<TLong>[Key]) => any;
-};
-export interface ISwitchTransactionResult<R extends TChoices> {
-    <T extends Transaction<TLong>>(tx: T): R[T['type']] extends (data: TransactionMap<TLong>[T['type']]) => infer A ? A : undefined;
-}
-export declare function switchTransactionByType<R extends TChoices>(choices: R): ISwitchTransactionResult<R>;
-export declare const pipe: IPipe;
-export interface IPipe {
-    <A, B, R>(a: (data: A) => B, b: (data: B) => R): (a: A) => R;
-    <A, B, C, R>(a: (data: A) => B, b: (data: B) => C, c: (data: C) => R): (a: A) => R;
-    <A, B, C, D, R>(a: (data: A) => B, b: (data: B) => C, c: (data: C) => D, d: (data: D) => R): (a: A) => R;
-}
-export declare type TUnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
-export {};
+import { TransactionMap, Transaction } from '@waves/ts-types';
+import { TLong } from '../interface';
+export declare function isObject(obj: any): boolean;
+export declare function toArray<T>(data: T | Array<T>): Array<T>;
+export declare function head<T>(data: Array<T>): T | undefined;
+export declare function wait(time: number): Promise<void>;
+export declare function prop<T extends Record<string, any>, P extends keyof T>(key: P): (data: T) => T[P];
+export declare const keys: <T extends Record<import("@waves/ts-types").Long, any>>(obj: T) => (keyof T)[];
+export declare const entries: <T extends Record<import("@waves/ts-types").Long, any>>(obj: T) => [keyof T, T[keyof T]][];
+export declare const values: <T extends Record<import("@waves/ts-types").Long, any>>(obj: T) => T[keyof T][];
+export declare const assign: <T extends Record<import("@waves/ts-types").Long, any>, R extends Record<import("@waves/ts-types").Long, any>>(target: T, merge: R) => T & R;
+export declare const deepAssign: <T extends Record<import("@waves/ts-types").Long, any>[]>(...objects: T) => TUnionToIntersection<T[number]>;
+export declare function map<T, U>(process: (data: T, index: number) => U): (list: Array<T>) => Array<U>;
+export declare function filter<T>(process: (data: T, index: number) => boolean): (list: Array<T>) => Array<T>;
+export declare function filter<T, S extends T>(process: (data: T, index: number) => data is S): (list: Array<T>) => Array<S>;
+export declare function indexBy<T extends Record<string, any>, P extends (data: T) => string | number>(process: (data: T) => T[keyof T], data: Array<T>): Record<ReturnType<P>, T>;
+export declare const uniq: (list: Array<string | null>) => Array<string | null>;
+declare type TChoices = {
+    [Key in keyof TransactionMap<TLong>]?: (data: TransactionMap<TLong>[Key]) => any;
+};
+export interface ISwitchTransactionResult<R extends TChoices> {
+    <T extends Transaction<TLong>>(tx: T): R[T['type']] extends (data: TransactionMap<TLong>[T['type']]) => infer A ? A : undefined;
+}
+export declare function switchTransactionByType<R extends TChoices>(choices: R): ISwitchTransactionResult<R>;
+export declare const pipe: IPipe;
+export interface IPipe {
+    <A, B, R>(a: (data: A) => B, b: (data: B) => R): (a: A) => R;
+    <A, B, C, R>(a: (data: A) => B, b: (data: B) => C, c: (data: C) => R): (a: A) => R;
+    <A, B, C, D, R>(a: (data: A) => B, b: (data: B) => C, c: (data: C) => D, d: (data: D) => R): (a: A) => R;
+}
+export declare type TUnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+export {};