@alephium/web3 0.9.0-rc.0 → 0.9.0-rc.2

package/dist/src/api/explorer-provider.d.ts

@@ -0,0 +1,20 @@
+import { ApiRequestArguments, ApiRequestHandler } from './types';
+import { Api as ExplorerApi } from './api-explorer';
+export declare class ExplorerProvider {
+    readonly blocks: ExplorerApi<string>['blocks'];
+    readonly transactions: ExplorerApi<string>['transactions'];
+    readonly addresses: ExplorerApi<string>['addresses'];
+    readonly infos: ExplorerApi<string>['infos'];
+    readonly mempool: ExplorerApi<string>['mempool'];
+    readonly tokens: ExplorerApi<string>['tokens'];
+    readonly charts: ExplorerApi<string>['charts'];
+    readonly contractEvents: ExplorerApi<string>['contractEvents'];
+    readonly contracts: ExplorerApi<string>['contracts'];
+    readonly utils: ExplorerApi<string>['utils'];
+    constructor(baseUrl: string, apiKey?: string, customFetch?: typeof fetch);
+    constructor(provider: ExplorerProvider);
+    constructor(handler: ApiRequestHandler);
+    request: (args: ApiRequestArguments) => Promise<any>;
+    static Proxy(explorerProvider: ExplorerProvider): ExplorerProvider;
+    static Remote(handler: ApiRequestHandler): ExplorerProvider;
+}

package/dist/src/api/explorer-provider.js

@@ -0,0 +1,69 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExplorerProvider = void 0;
+const types_1 = require("./types");
+const api_explorer_1 = require("./api-explorer");
+const utils_1 = require("./utils");
+function initializeExplorerApi(baseUrl, apiKey, customFetch) {
+    const explorerApi = new api_explorer_1.Api({
+        baseUrl: baseUrl,
+        baseApiParams: { secure: true },
+        securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {}),
+        customFetch: customFetch ?? utils_1.DEFAULT_THROTTLE_FETCH
+    });
+    explorerApi.setSecurityData(apiKey ?? null);
+    return explorerApi;
+}
+class ExplorerProvider {
+    constructor(param0, apiKey, customFetch) {
+        this.request = (args) => {
+            return (0, types_1.request)(this, args);
+        };
+        let explorerApi;
+        if (typeof param0 === 'string') {
+            explorerApi = initializeExplorerApi(param0, apiKey, customFetch);
+        }
+        else if (typeof param0 === 'function') {
+            explorerApi = new ExplorerProvider('https://1.2.3.4:0');
+            (0, types_1.forwardRequests)(explorerApi, param0);
+        }
+        else {
+            explorerApi = param0;
+        }
+        this.blocks = { ...explorerApi.blocks };
+        this.transactions = { ...explorerApi.transactions };
+        this.addresses = { ...explorerApi.addresses };
+        this.infos = { ...explorerApi.infos };
+        this.mempool = { ...explorerApi.mempool };
+        this.tokens = { ...explorerApi.tokens };
+        this.charts = { ...explorerApi.charts };
+        this.utils = { ...explorerApi.utils };
+        this.contracts = { ...explorerApi.contracts };
+        this.contractEvents = { ...explorerApi.contractEvents };
+    }
+    // This can prevent the proxied explorer provider from being modified
+    static Proxy(explorerProvider) {
+        return new ExplorerProvider(explorerProvider);
+    }
+    static Remote(handler) {
+        return new ExplorerProvider(handler);
+    }
+}
+exports.ExplorerProvider = ExplorerProvider;

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

@@ -0,0 +1,6 @@
+export * from './node-provider';
+export * from './explorer-provider';
+export * as node from './api-alephium';
+export * as explorer from './api-explorer';
+export * from './types';
+export * from './utils';

package/dist/src/api/index.js

@@ -0,0 +1,52 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.explorer = exports.node = void 0;
+__exportStar(require("./node-provider"), exports);
+__exportStar(require("./explorer-provider"), exports);
+exports.node = __importStar(require("./api-alephium"));
+exports.explorer = __importStar(require("./api-explorer"));
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);

package/dist/src/api/node-provider.d.ts

@@ -0,0 +1,38 @@
+import { ApiRequestArguments, ApiRequestHandler, TokenMetaData } from './types';
+import { Api as NodeApi } from './api-alephium';
+import { HexString } from '../contract';
+interface NodeProviderApis {
+    wallets: NodeApi<string>['wallets'];
+    infos: NodeApi<string>['infos'];
+    blockflow: NodeApi<string>['blockflow'];
+    addresses: NodeApi<string>['addresses'];
+    transactions: NodeApi<string>['transactions'];
+    mempool: NodeApi<string>['mempool'];
+    contracts: NodeApi<string>['contracts'];
+    multisig: NodeApi<string>['multisig'];
+    utils: NodeApi<string>['utils'];
+    miners: NodeApi<string>['miners'];
+    events: NodeApi<string>['events'];
+}
+export declare class NodeProvider implements NodeProviderApis {
+    readonly wallets: NodeApi<string>['wallets'];
+    readonly infos: NodeApi<string>['infos'];
+    readonly blockflow: NodeApi<string>['blockflow'];
+    readonly addresses: NodeApi<string>['addresses'];
+    readonly transactions: NodeApi<string>['transactions'];
+    readonly mempool: NodeApi<string>['mempool'];
+    readonly contracts: NodeApi<string>['contracts'];
+    readonly multisig: NodeApi<string>['multisig'];
+    readonly utils: NodeApi<string>['utils'];
+    readonly miners: NodeApi<string>['miners'];
+    readonly events: NodeApi<string>['events'];
+    constructor(baseUrl: string, apiKey?: string, customFetch?: typeof fetch);
+    constructor(provider: NodeProvider);
+    constructor(handler: ApiRequestHandler);
+    request: (args: ApiRequestArguments) => Promise<any>;
+    static Proxy(nodeProvider: NodeProvider): NodeProvider;
+    static Remote(handler: ApiRequestHandler): NodeProvider;
+    fetchStdTokenMetaData: (tokenId: HexString) => Promise<TokenMetaData>;
+    guessStdInterfaceId: (tokenId: HexString) => Promise<HexString | undefined>;
+}
+export {};

package/dist/src/api/node-provider.js

@@ -0,0 +1,99 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeProvider = void 0;
+const types_1 = require("./types");
+const api_alephium_1 = require("./api-alephium");
+const utils_1 = require("./utils");
+const utils_2 = require("../utils");
+function initializeNodeApi(baseUrl, apiKey, customFetch) {
+    const nodeApi = new api_alephium_1.Api({
+        baseUrl: baseUrl,
+        baseApiParams: { secure: true },
+        securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {}),
+        customFetch: customFetch ?? utils_1.DEFAULT_THROTTLE_FETCH
+    });
+    nodeApi.setSecurityData(apiKey ?? null);
+    return nodeApi;
+}
+class NodeProvider {
+    constructor(param0, apiKey, customFetch) {
+        this.request = (args) => {
+            return (0, types_1.request)(this, args);
+        };
+        // Only use this when the token is following the standard token interface
+        this.fetchStdTokenMetaData = async (tokenId) => {
+            const group = 0;
+            const address = (0, utils_2.addressFromTokenId)(tokenId);
+            const calls = Array.from([0, 1, 2, 3], (index) => ({ methodIndex: index, group: group, address: address }));
+            const result = await this.contracts.postContractsMulticallContract({
+                calls: calls
+            });
+            return {
+                symbol: result.results[0].returns[0].value,
+                name: result.results[1].returns[0].value,
+                decimals: Number(result.results[2].returns[0].value),
+                totalSupply: BigInt(result.results[3].returns[0].value)
+            };
+        };
+        this.guessStdInterfaceId = async (tokenId) => {
+            const address = (0, utils_2.addressFromTokenId)(tokenId);
+            const group = (0, utils_2.groupOfAddress)(address);
+            const rawState = await this.contracts.getContractsAddressState((0, utils_2.addressFromTokenId)(tokenId), { group });
+            const lastImmField = rawState.immFields.slice(-1).pop()?.value;
+            const interfaceIdPrefix = '414c5048'; // the hex of 'ALPH'
+            if (typeof lastImmField === 'string' && lastImmField.startsWith(interfaceIdPrefix)) {
+                return lastImmField.slice(8);
+            }
+            else {
+                return undefined;
+            }
+        };
+        let nodeApi;
+        if (typeof param0 === 'string') {
+            nodeApi = initializeNodeApi(param0, apiKey, customFetch);
+        }
+        else if (typeof param0 === 'function') {
+            nodeApi = new NodeProvider('https://1.2.3.4:0');
+            (0, types_1.forwardRequests)(nodeApi, param0);
+        }
+        else {
+            nodeApi = param0;
+        }
+        this.wallets = { ...nodeApi.wallets };
+        this.infos = { ...nodeApi.infos };
+        this.blockflow = { ...nodeApi.blockflow };
+        this.addresses = { ...nodeApi.addresses };
+        this.transactions = { ...nodeApi.transactions };
+        this.mempool = { ...nodeApi.mempool };
+        this.contracts = { ...nodeApi.contracts };
+        this.multisig = { ...nodeApi.multisig };
+        this.utils = { ...nodeApi.utils };
+        this.miners = { ...nodeApi.miners };
+        this.events = { ...nodeApi.events };
+    }
+    // This can prevent the proxied node provider from being modified
+    static Proxy(nodeProvider) {
+        return new NodeProvider(nodeProvider);
+    }
+    static Remote(handler) {
+        return new NodeProvider(handler);
+    }
+}
+exports.NodeProvider = NodeProvider;

package/dist/src/api/types.d.ts

@@ -0,0 +1,38 @@
+import * as node from './api-alephium';
+export type Number256 = bigint | string;
+export type Val = Number256 | boolean | string | Val[];
+export type NamedVals = Record<string, Val>;
+export interface Token {
+    id: string;
+    amount: Number256;
+}
+export declare function toApiToken(token: Token): node.Token;
+export declare function toApiTokens(tokens?: Token[]): node.Token[] | undefined;
+export declare function fromApiToken(token: node.Token): Token;
+export declare function fromApiTokens(tokens?: node.Token[]): Token[] | undefined;
+export declare function toApiBoolean(v: Val): boolean;
+export declare function toApiNumber256(v: Val): string;
+export declare function toApiNumber256Optional(v?: Val): string | undefined;
+export declare function fromApiNumber256(n: string): bigint;
+export declare function toApiByteVec(v: Val): string;
+export declare function toApiAddress(v: Val): string;
+export declare function toApiArray(tpe: string, v: Val): node.Val;
+export declare function toApiVal(v: Val, tpe: string): node.Val;
+export declare function fromApiVals(vals: node.Val[], names: string[], types: string[], systemEvent?: boolean): NamedVals;
+export declare function fromApiArray(vals: node.Val[], types: string[]): Val[];
+export declare function fromApiVal(v: node.Val, tpe: string): Val;
+export declare function typeLength(tpe: string): number;
+export interface ApiRequestArguments {
+    path: string;
+    method: string;
+    params: any[];
+}
+export type ApiRequestHandler = (args: ApiRequestArguments) => Promise<any>;
+export declare function forwardRequests(api: Record<string, any>, handler: ApiRequestHandler): void;
+export declare function request(provider: Record<string, any>, args: ApiRequestArguments): Promise<any>;
+export interface TokenMetaData {
+    name: string;
+    symbol: string;
+    decimals: number;
+    totalSupply: Number256;
+}

package/dist/src/api/types.js

@@ -0,0 +1,259 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.request = exports.forwardRequests = exports.typeLength = exports.fromApiVal = exports.fromApiArray = exports.fromApiVals = exports.toApiVal = exports.toApiArray = exports.toApiAddress = exports.toApiByteVec = exports.fromApiNumber256 = exports.toApiNumber256Optional = exports.toApiNumber256 = exports.toApiBoolean = exports.fromApiTokens = exports.fromApiToken = exports.toApiTokens = exports.toApiToken = void 0;
+const utils_1 = require("../utils");
+utils_1.assertType;
+function toApiToken(token) {
+    return { id: token.id, amount: toApiNumber256(token.amount) };
+}
+exports.toApiToken = toApiToken;
+function toApiTokens(tokens) {
+    return tokens?.map(toApiToken);
+}
+exports.toApiTokens = toApiTokens;
+function fromApiToken(token) {
+    return { id: token.id, amount: fromApiNumber256(token.amount) };
+}
+exports.fromApiToken = fromApiToken;
+function fromApiTokens(tokens) {
+    return tokens?.map(fromApiToken);
+}
+exports.fromApiTokens = fromApiTokens;
+function toApiBoolean(v) {
+    if (typeof v === 'boolean') {
+        return v;
+    }
+    else {
+        throw new Error(`Invalid boolean value: ${v}`);
+    }
+}
+exports.toApiBoolean = toApiBoolean;
+// TODO: check integer bounds
+function toApiNumber256(v) {
+    if ((typeof v === 'number' && Number.isInteger(v)) || typeof v === 'bigint') {
+        return v.toString();
+    }
+    else if (typeof v === 'string') {
+        return v;
+    }
+    else {
+        throw new Error(`Invalid 256 bit number: ${v}`);
+    }
+}
+exports.toApiNumber256 = toApiNumber256;
+function toApiNumber256Optional(v) {
+    return v === undefined ? undefined : toApiNumber256(v);
+}
+exports.toApiNumber256Optional = toApiNumber256Optional;
+function fromApiNumber256(n) {
+    return BigInt(n);
+}
+exports.fromApiNumber256 = fromApiNumber256;
+// TODO: check hex string
+function toApiByteVec(v) {
+    if (typeof v === 'string') {
+        // try to convert from address to contract id
+        try {
+            const address = utils_1.bs58.decode(v);
+            if (address.length == 33 && address[0] == 3) {
+                return Buffer.from(address.slice(1)).toString('hex');
+            }
+        }
+        catch (_) {
+            return v;
+        }
+        return v;
+    }
+    else {
+        throw new Error(`Invalid string: ${v}`);
+    }
+}
+exports.toApiByteVec = toApiByteVec;
+function toApiAddress(v) {
+    if (typeof v === 'string') {
+        try {
+            utils_1.bs58.decode(v);
+            return v;
+        }
+        catch (error) {
+            throw new Error(`Invalid base58 string: ${v}`);
+        }
+    }
+    else {
+        throw new Error(`Invalid string: ${v}`);
+    }
+}
+exports.toApiAddress = toApiAddress;
+function toApiArray(tpe, v) {
+    if (!Array.isArray(v)) {
+        throw new Error(`Expected array, got ${v}`);
+    }
+    const semiColonIndex = tpe.lastIndexOf(';');
+    if (semiColonIndex == -1) {
+        throw new Error(`Invalid Val type: ${tpe}`);
+    }
+    const subType = tpe.slice(1, semiColonIndex);
+    const dim = parseInt(tpe.slice(semiColonIndex + 1, -1));
+    if (v.length != dim) {
+        throw new Error(`Invalid val dimension: ${v}`);
+    }
+    else {
+        return { value: v.map((v) => toApiVal(v, subType)), type: 'Array' };
+    }
+}
+exports.toApiArray = toApiArray;
+function toApiVal(v, tpe) {
+    if (tpe === 'Bool') {
+        return { value: toApiBoolean(v), type: tpe };
+    }
+    else if (tpe === 'U256' || tpe === 'I256') {
+        return { value: toApiNumber256(v), type: tpe };
+    }
+    else if (tpe === 'ByteVec') {
+        return { value: toApiByteVec(v), type: tpe };
+    }
+    else if (tpe === 'Address') {
+        return { value: toApiAddress(v), type: tpe };
+    }
+    else {
+        return toApiArray(tpe, v);
+    }
+}
+exports.toApiVal = toApiVal;
+function _fromApiVal(vals, valIndex, tpe, systemEvent = false) {
+    if (vals.length === 0) {
+        throw new Error('Not enough Vals');
+    }
+    const firstVal = vals[`${valIndex}`];
+    if (tpe === 'Bool' && firstVal.type === tpe) {
+        return [firstVal.value, valIndex + 1];
+    }
+    else if ((tpe === 'U256' || tpe === 'I256') && firstVal.type === tpe) {
+        return [fromApiNumber256(firstVal.value), valIndex + 1];
+    }
+    else if ((tpe === 'ByteVec' || tpe === 'Address') && (firstVal.type === tpe || systemEvent)) {
+        return [firstVal.value, valIndex + 1];
+    }
+    else {
+        const [baseType, dims] = decodeArrayType(tpe);
+        const arraySize = dims.reduce((a, b) => a * b);
+        const nextIndex = valIndex + arraySize;
+        const valsToUse = vals.slice(valIndex, nextIndex);
+        if (valsToUse.length == arraySize && valsToUse.every((val) => val.type === baseType)) {
+            const localVals = valsToUse.map((val) => fromApiVal(val, baseType));
+            return [foldVals(localVals, dims), nextIndex];
+        }
+        else {
+            throw new Error(`Invalid array Val type: ${valsToUse}, ${tpe}`);
+        }
+    }
+}
+function fromApiVals(vals, names, types, systemEvent = false) {
+    let valIndex = 0;
+    const result = {};
+    types.forEach((currentType, index) => {
+        const currentName = names[`${index}`];
+        const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType, systemEvent);
+        valIndex = nextIndex;
+        result[`${currentName}`] = val;
+    });
+    return result;
+}
+exports.fromApiVals = fromApiVals;
+function fromApiArray(vals, types) {
+    let valIndex = 0;
+    const result = [];
+    for (const currentType of types) {
+        const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType);
+        result.push(val);
+        valIndex = nextIndex;
+    }
+    return result;
+}
+exports.fromApiArray = fromApiArray;
+function fromApiVal(v, tpe) {
+    if (v.type === 'Bool' && v.type === tpe) {
+        return v.value;
+    }
+    else if ((v.type === 'U256' || v.type === 'I256') && v.type === tpe) {
+        return fromApiNumber256(v.value);
+    }
+    else if ((v.type === 'ByteVec' || v.type === 'Address') && v.type === tpe) {
+        return v.value;
+    }
+    else {
+        throw new Error(`Invalid node.Val type: ${v}`);
+    }
+}
+exports.fromApiVal = fromApiVal;
+function decodeArrayType(tpe) {
+    const semiColonIndex = tpe.lastIndexOf(';');
+    if (semiColonIndex === -1) {
+        throw new Error(`Invalid Val type: ${tpe}`);
+    }
+    const subType = tpe.slice(1, semiColonIndex);
+    const dim = parseInt(tpe.slice(semiColonIndex + 1, -1));
+    if (subType[0] == '[') {
+        const [baseType, subDim] = decodeArrayType(subType);
+        return [baseType, (subDim.unshift(dim), subDim)];
+    }
+    else {
+        return [subType, [dim]];
+    }
+}
+function foldVals(vals, dims) {
+    if (dims.length == 1) {
+        return vals;
+    }
+    else {
+        const result = [];
+        const chunkSize = vals.length / dims[0];
+        const chunkDims = dims.slice(1);
+        for (let i = 0; i < vals.length; i += chunkSize) {
+            const chunk = vals.slice(i, i + chunkSize);
+            result.push(foldVals(chunk, chunkDims));
+        }
+        return result;
+    }
+}
+function typeLength(tpe) {
+    if (tpe === 'U256' || tpe === 'I256' || tpe === 'Bool' || tpe === 'ByteVec' || tpe === 'Address') {
+        return 1;
+    }
+    const [, dims] = decodeArrayType(tpe);
+    return dims.reduce((a, b) => a * b);
+}
+exports.typeLength = typeLength;
+function forwardRequests(api, handler) {
+    // Update class properties to forward requests
+    for (const [path, pathObject] of Object.entries(api)) {
+        for (const method of Object.keys(pathObject)) {
+            pathObject[`${method}`] = async (...params) => {
+                return handler({ path, method, params });
+            };
+        }
+    }
+}
+exports.forwardRequests = forwardRequests;
+async function request(provider, args) {
+    const call = provider[`${args.path}`][`${args.method}`];
+    return call(...args.params);
+}
+exports.request = request;

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

@@ -0,0 +1,12 @@
+import 'cross-fetch/polyfill';
+export declare function convertHttpResponse<T>(response: {
+    data: T;
+    error?: {
+        detail: string;
+    };
+}): T;
+export declare function retryFetch(...fetchParams: Parameters<typeof fetch>): ReturnType<typeof fetch>;
+export declare function throttledFetch(ratePerSec: number): typeof fetch;
+export declare const RETRY_LIMIT_WHEN_429 = 3;
+export declare const DEFAULT_RATE_LIMIT = 3;
+export declare const DEFAULT_THROTTLE_FETCH: typeof fetch;

package/dist/src/api/utils.js

@@ -0,0 +1,59 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_THROTTLE_FETCH = exports.DEFAULT_RATE_LIMIT = exports.RETRY_LIMIT_WHEN_429 = exports.throttledFetch = exports.retryFetch = exports.convertHttpResponse = void 0;
+require("cross-fetch/polyfill");
+const utils_1 = require("../utils");
+const async_sema_1 = require("async-sema");
+function convertHttpResponse(response) {
+    if (response.error) {
+        throw new Error(`[API Error] - ${response.error.detail}`);
+    }
+    else {
+        return response.data;
+    }
+}
+exports.convertHttpResponse = convertHttpResponse;
+async function retryFetch(...fetchParams) {
+    const retry = async (retryCount) => {
+        const response = await fetch(...fetchParams);
+        if (response.status === 429 && retryCount < exports.RETRY_LIMIT_WHEN_429) {
+            const nextCount = retryCount + 1;
+            await (0, utils_1.sleep)(nextCount * 500);
+            return await retry(nextCount);
+        }
+        else {
+            return response;
+        }
+    };
+    return retry(0);
+}
+exports.retryFetch = retryFetch;
+function throttledFetch(ratePerSec) {
+    const limit = (0, async_sema_1.RateLimit)(ratePerSec);
+    const customFetch = async (...fetchParams) => {
+        await limit();
+        return retryFetch(...fetchParams);
+    };
+    return customFetch;
+}
+exports.throttledFetch = throttledFetch;
+exports.RETRY_LIMIT_WHEN_429 = 3;
+exports.DEFAULT_RATE_LIMIT = 3;
+exports.DEFAULT_THROTTLE_FETCH = throttledFetch(exports.DEFAULT_RATE_LIMIT);

package/dist/src/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const TOTAL_NUMBER_OF_GROUPS = 4;
+export declare const TOTAL_NUMBER_OF_CHAINS: number;
+export declare const MIN_UTXO_SET_AMOUNT: bigint;
+export declare const ALPH_TOKEN_ID: string;
+export declare const ONE_ALPH: bigint;
+export declare const DUST_AMOUNT: bigint;