@alephium/web3 0.0.3 → 0.1.0-rc.0

package/dist/{api → src/api}/api-explorer.js

@@ -9,29 +9,17 @@
  * ## SOURCE: https://github.com/acacode/swagger-typescript-api ##
  * ---------------------------------------------------------------
  */
-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());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Api = exports.HttpClient = exports.ContentType = void 0;
 require("cross-fetch/polyfill");
+function convertHttpResponse(response) {
+    if (response.error) {
+        throw new Error(response.error.detail);
+    }
+    else {
+        return response.data;
+    }
+}
 var ContentType;
 (function (ContentType) {
     ContentType["Json"] = "application/json";
@@ -85,23 +73,30 @@ class HttpClient {
                 this.abortControllers.delete(cancelToken);
             }
         };
-        this.request = (_a) => __awaiter(this, void 0, void 0, function* () {
-            var { body, secure, path, type, query, format, baseUrl, cancelToken } = _a, params = __rest(_a, ["body", "secure", "path", "type", "query", "format", "baseUrl", "cancelToken"]);
+        this.request = async ({ body, secure, path, type, query, format, baseUrl, cancelToken, ...params }) => {
             const secureParams = ((typeof secure === 'boolean' ? secure : this.baseApiParams.secure) &&
                 this.securityWorker &&
-                (yield this.securityWorker(this.securityData))) ||
+                (await this.securityWorker(this.securityData))) ||
                 {};
             const requestParams = this.mergeRequestParams(params, secureParams);
             const queryString = query && this.toQueryString(query);
             const payloadFormatter = this.contentFormatters[type || ContentType.Json];
             const responseFormat = format || requestParams.format;
-            return this.customFetch(`${baseUrl || this.baseUrl || ''}${path}${queryString ? `?${queryString}` : ''}`, Object.assign(Object.assign({}, requestParams), { headers: Object.assign(Object.assign({}, (type && type !== ContentType.FormData ? { 'Content-Type': type } : {})), (requestParams.headers || {})), signal: cancelToken ? this.createAbortSignal(cancelToken) : void 0, body: typeof body === 'undefined' || body === null ? null : payloadFormatter(body) })).then((response) => __awaiter(this, void 0, void 0, function* () {
+            return this.customFetch(`${baseUrl || this.baseUrl || ''}${path}${queryString ? `?${queryString}` : ''}`, {
+                ...requestParams,
+                headers: {
+                    ...(type && type !== ContentType.FormData ? { 'Content-Type': type } : {}),
+                    ...(requestParams.headers || {})
+                },
+                signal: cancelToken ? this.createAbortSignal(cancelToken) : void 0,
+                body: typeof body === 'undefined' || body === null ? null : payloadFormatter(body)
+            }).then(async (response) => {
                 const r = response;
                 r.data = null;
                 r.error = null;
                 const data = !responseFormat
                     ? r
-                    : yield response[responseFormat]()
+                    : await response[responseFormat]()
                         .then((data) => {
                         if (r.ok) {
                             r.data = data;
@@ -121,8 +116,8 @@ class HttpClient {
                 if (!response.ok)
                     throw data;
                 return data;
-            }));
-        });
+            });
+        };
         Object.assign(this, apiConfig);
     }
     encodeQueryParam(key, value) {
@@ -148,7 +143,16 @@ class HttpClient {
         return queryString ? `?${queryString}` : '';
     }
     mergeRequestParams(params1, params2) {
-        return Object.assign(Object.assign(Object.assign(Object.assign({}, this.baseApiParams), params1), (params2 || {})), { headers: Object.assign(Object.assign(Object.assign({}, (this.baseApiParams.headers || {})), (params1.headers || {})), ((params2 && params2.headers) || {})) });
+        return {
+            ...this.baseApiParams,
+            ...params1,
+            ...(params2 || {}),
+            headers: {
+                ...(this.baseApiParams.headers || {}),
+                ...(params1.headers || {}),
+                ...((params2 && params2.headers) || {})
+            }
+        };
     }
 }
 exports.HttpClient = HttpClient;
@@ -167,7 +171,13 @@ class Api extends HttpClient {
              * @name GetBlocks
              * @request GET:/blocks
              */
-            getBlocks: (query, params = {}) => this.request(Object.assign({ path: `/blocks`, method: 'GET', query: query, format: 'json' }, params)),
+            getBlocks: (query, params = {}) => this.request({
+                path: `/blocks`,
+                method: 'GET',
+                query: query,
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse),
             /**
              * @description Get a block with hash
              *
@@ -175,7 +185,12 @@ class Api extends HttpClient {
              * @name GetBlocksBlockHash
              * @request GET:/blocks/{block-hash}
              */
-            getBlocksBlockHash: (blockHash, params = {}) => this.request(Object.assign({ path: `/blocks/${blockHash}`, method: 'GET', format: 'json' }, params)),
+            getBlocksBlockHash: (blockHash, params = {}) => this.request({
+                path: `/blocks/${blockHash}`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse),
             /**
              * @description Get block's transactions
              *
@@ -183,7 +198,13 @@ class Api extends HttpClient {
              * @name GetBlocksBlockHashTransactions
              * @request GET:/blocks/{block-hash}/transactions
              */
-            getBlocksBlockHashTransactions: (blockHash, query, params = {}) => this.request(Object.assign({ path: `/blocks/${blockHash}/transactions`, method: 'GET', query: query, format: 'json' }, params))
+            getBlocksBlockHashTransactions: (blockHash, query, params = {}) => this.request({
+                path: `/blocks/${blockHash}/transactions`,
+                method: 'GET',
+                query: query,
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse)
         };
         this.transactions = {
             /**
@@ -193,25 +214,67 @@ class Api extends HttpClient {
              * @name GetTransactionsTransactionHash
              * @request GET:/transactions/{transaction-hash}
              */
-            getTransactionsTransactionHash: (transactionHash, params = {}) => this.request(Object.assign({ path: `/transactions/${transactionHash}`, method: 'GET', format: 'json' }, params))
+            getTransactionsTransactionHash: (transactionHash, params = {}) => this.request({
+                path: `/transactions/${transactionHash}`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse)
         };
         this.addresses = {
             /**
              * @description Get address information
              *
-             * @tags Addressess
+             * @tags Addresses
              * @name GetAddressesAddress
              * @request GET:/addresses/{address}
              */
-            getAddressesAddress: (address, params = {}) => this.request(Object.assign({ path: `/addresses/${address}`, method: 'GET', format: 'json' }, params)),
+            getAddressesAddress: (address, params = {}) => this.request({
+                path: `/addresses/${address}`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse),
             /**
              * @description List transactions of a given address
              *
-             * @tags Addressess
+             * @tags Addresses
              * @name GetAddressesAddressTransactions
              * @request GET:/addresses/{address}/transactions
              */
-            getAddressesAddressTransactions: (address, query, params = {}) => this.request(Object.assign({ path: `/addresses/${address}/transactions`, method: 'GET', query: query, format: 'json' }, params))
+            getAddressesAddressTransactions: (address, query, params = {}) => this.request({
+                path: `/addresses/${address}/transactions`,
+                method: 'GET',
+                query: query,
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse),
+            /**
+             * @description Get total transactions of a given address
+             *
+             * @tags Addresses
+             * @name GetAddressesAddressTotalTransactions
+             * @request GET:/addresses/{address}/total-transactions
+             */
+            getAddressesAddressTotalTransactions: (address, params = {}) => this.request({
+                path: `/addresses/${address}/total-transactions`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse),
+            /**
+             * @description Get address balance
+             *
+             * @tags Addresses
+             * @name GetAddressesAddressBalance
+             * @request GET:/addresses/{address}/balance
+             */
+            getAddressesAddressBalance: (address, params = {}) => this.request({
+                path: `/addresses/${address}/balance`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse)
         };
         this.infos = {
             /**
@@ -221,7 +284,12 @@ class Api extends HttpClient {
              * @name GetInfos
              * @request GET:/infos
              */
-            getInfos: (params = {}) => this.request(Object.assign({ path: `/infos`, method: 'GET', format: 'json' }, params)),
+            getInfos: (params = {}) => this.request({
+                path: `/infos`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse),
             /**
              * @description List latest height for each chain
              *
@@ -229,7 +297,12 @@ class Api extends HttpClient {
              * @name GetInfosHeights
              * @request GET:/infos/heights
              */
-            getInfosHeights: (params = {}) => this.request(Object.assign({ path: `/infos/heights`, method: 'GET', format: 'json' }, params)),
+            getInfosHeights: (params = {}) => this.request({
+                path: `/infos/heights`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse),
             /**
              * @description Get token supply list
              *
@@ -237,7 +310,13 @@ class Api extends HttpClient {
              * @name GetInfosSupply
              * @request GET:/infos/supply
              */
-            getInfosSupply: (query, params = {}) => this.request(Object.assign({ path: `/infos/supply`, method: 'GET', query: query, format: 'json' }, params)),
+            getInfosSupply: (query, params = {}) => this.request({
+                path: `/infos/supply`,
+                method: 'GET',
+                query: query,
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse),
             /**
              * @description Get the ALPH total supply
              *
@@ -245,7 +324,11 @@ class Api extends HttpClient {
              * @name GetInfosSupplyTotalAlph
              * @request GET:/infos/supply/total-alph
              */
-            getInfosSupplyTotalAlph: (params = {}) => this.request(Object.assign({ path: `/infos/supply/total-alph`, method: 'GET' }, params)),
+            getInfosSupplyTotalAlph: (params = {}) => this.request({
+                path: `/infos/supply/total-alph`,
+                method: 'GET',
+                ...params
+            }).then(convertHttpResponse),
             /**
              * @description Get the ALPH circulating supply
              *
@@ -253,7 +336,35 @@ class Api extends HttpClient {
              * @name GetInfosSupplyCirculatingAlph
              * @request GET:/infos/supply/circulating-alph
              */
-            getInfosSupplyCirculatingAlph: (params = {}) => this.request(Object.assign({ path: `/infos/supply/circulating-alph`, method: 'GET' }, params)),
+            getInfosSupplyCirculatingAlph: (params = {}) => this.request({
+                path: `/infos/supply/circulating-alph`,
+                method: 'GET',
+                ...params
+            }).then(convertHttpResponse),
+            /**
+             * @description Get the ALPH reserved supply
+             *
+             * @tags Infos
+             * @name GetInfosSupplyReservedAlph
+             * @request GET:/infos/supply/reserved-alph
+             */
+            getInfosSupplyReservedAlph: (params = {}) => this.request({
+                path: `/infos/supply/reserved-alph`,
+                method: 'GET',
+                ...params
+            }).then(convertHttpResponse),
+            /**
+             * @description Get the ALPH locked supply
+             *
+             * @tags Infos
+             * @name GetInfosSupplyLockedAlph
+             * @request GET:/infos/supply/locked-alph
+             */
+            getInfosSupplyLockedAlph: (params = {}) => this.request({
+                path: `/infos/supply/locked-alph`,
+                method: 'GET',
+                ...params
+            }).then(convertHttpResponse),
             /**
              * @description Get the total number of transactions
              *
@@ -261,7 +372,11 @@ class Api extends HttpClient {
              * @name GetInfosTotalTransactions
              * @request GET:/infos/total-transactions
              */
-            getInfosTotalTransactions: (params = {}) => this.request(Object.assign({ path: `/infos/total-transactions`, method: 'GET' }, params)),
+            getInfosTotalTransactions: (params = {}) => this.request({
+                path: `/infos/total-transactions`,
+                method: 'GET',
+                ...params
+            }).then(convertHttpResponse),
             /**
              * @description Get the average block time for each chain
              *
@@ -269,7 +384,12 @@ class Api extends HttpClient {
              * @name GetInfosAverageBlockTimes
              * @request GET:/infos/average-block-times
              */
-            getInfosAverageBlockTimes: (params = {}) => this.request(Object.assign({ path: `/infos/average-block-times`, method: 'GET', format: 'json' }, params))
+            getInfosAverageBlockTimes: (params = {}) => this.request({
+                path: `/infos/average-block-times`,
+                method: 'GET',
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse)
         };
         this.charts = {
             /**
@@ -277,10 +397,46 @@ class Api extends HttpClient {
              *
              * @tags Charts
              * @name GetChartsHashrates
-             * @summary Get explorer informations.
+             * @summary Get hashrate chart in H/s
              * @request GET:/charts/hashrates
              */
-            getChartsHashrates: (query, params = {}) => this.request(Object.assign({ path: `/charts/hashrates`, method: 'GET', query: query, format: 'json' }, params))
+            getChartsHashrates: (query, params = {}) => this.request({
+                path: `/charts/hashrates`,
+                method: 'GET',
+                query: query,
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse),
+            /**
+             * @description `interval-type` query param: hourly, daily
+             *
+             * @tags Charts
+             * @name GetChartsTransactionsCount
+             * @summary Get transaction count history
+             * @request GET:/charts/transactions-count
+             */
+            getChartsTransactionsCount: (query, params = {}) => this.request({
+                path: `/charts/transactions-count`,
+                method: 'GET',
+                query: query,
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse),
+            /**
+             * @description `interval-type` query param: hourly, daily
+             *
+             * @tags Charts
+             * @name GetChartsTransactionsCountPerChain
+             * @summary Get transaction count history per chain
+             * @request GET:/charts/transactions-count-per-chain
+             */
+            getChartsTransactionsCountPerChain: (query, params = {}) => this.request({
+                path: `/charts/transactions-count-per-chain`,
+                method: 'GET',
+                query: query,
+                format: 'json',
+                ...params
+            }).then(convertHttpResponse)
         };
         this.utils = {
             /**
@@ -290,7 +446,11 @@ class Api extends HttpClient {
              * @name PutUtilsSanityCheck
              * @request PUT:/utils/sanity-check
              */
-            putUtilsSanityCheck: (params = {}) => this.request(Object.assign({ path: `/utils/sanity-check`, method: 'PUT' }, params))
+            putUtilsSanityCheck: (params = {}) => this.request({
+                path: `/utils/sanity-check`,
+                method: 'PUT',
+                ...params
+            }).then(convertHttpResponse)
         };
     }
 }

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

@@ -0,0 +1,10 @@
+import { Api as NodeApi } from './api-alephium';
+import { Api as ExplorerApi } from './api-explorer';
+export declare class NodeProvider extends NodeApi<null> {
+    constructor(baseUrl: string);
+}
+export declare class ExplorerProvider extends ExplorerApi<null> {
+    constructor(baseUrl: string);
+}
+export * as node from './api-alephium';
+export * as explorer from './api-explorer';

package/dist/src/api/index.js

@@ -0,0 +1,55 @@
+"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;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 __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 = exports.ExplorerProvider = exports.NodeProvider = void 0;
+const api_alephium_1 = require("./api-alephium");
+const api_explorer_1 = require("./api-explorer");
+class NodeProvider extends api_alephium_1.Api {
+    constructor(baseUrl) {
+        super({ baseUrl: baseUrl });
+    }
+}
+exports.NodeProvider = NodeProvider;
+class ExplorerProvider extends api_explorer_1.Api {
+    constructor(baseUrl) {
+        super({ baseUrl: baseUrl });
+    }
+}
+exports.ExplorerProvider = ExplorerProvider;
+exports.node = __importStar(require("./api-alephium"));
+exports.explorer = __importStar(require("./api-explorer"));

package/dist/src/contract/contract.d.ts

@@ -0,0 +1,182 @@
+import { NodeProvider } from '../api';
+import { node } from '../api';
+import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer';
+export declare abstract class Common {
+    readonly sourceCodeSha256: string;
+    readonly functions: node.FunctionSig[];
+    static readonly importRegex: RegExp;
+    static readonly contractRegex: RegExp;
+    static readonly interfaceRegex: RegExp;
+    static readonly scriptRegex: RegExp;
+    private static _artifactCache;
+    static artifactCacheCapacity: number;
+    protected static _getArtifactFromCache(codeHash: string): Contract | Script | undefined;
+    protected static _putArtifactToCache(contract: Contract): void;
+    constructor(sourceCodeSha256: string, functions: node.FunctionSig[]);
+    protected static _contractPath(fileName: string): string;
+    protected static _artifactPath(fileName: string): string;
+    protected static _artifactsFolder(): string;
+    protected static _handleImports(contractStr: string, importsCache: string[]): Promise<string>;
+    protected static _loadContractStr(fileName: string, importsCache: string[], validate: (fileName: string) => void): Promise<string>;
+    static checkFileNameExtension(fileName: string): void;
+    protected static _from<T extends {
+        sourceCodeSha256: string;
+    }>(provider: NodeProvider, fileName: string, loadContractStr: (fileName: string, importsCache: string[]) => Promise<string>, compile: (provider: NodeProvider, fileName: string, contractStr: string, contractHash: string) => Promise<T>): Promise<T>;
+    protected _saveToFile(fileName: string): Promise<void>;
+    abstract buildByteCodeToDeploy(initialFields?: Fields): string;
+}
+export declare class Contract extends Common {
+    readonly bytecode: string;
+    readonly codeHash: string;
+    readonly fieldsSig: node.FieldsSig;
+    readonly eventsSig: node.EventSig[];
+    constructor(sourceCodeSha256: string, bytecode: string, codeHash: string, fieldsSig: node.FieldsSig, eventsSig: node.EventSig[], functions: node.FunctionSig[]);
+    static checkCodeType(fileName: string, contractStr: string): void;
+    private static loadContractStr;
+    static fromSource(provider: NodeProvider, fileName: string): Promise<Contract>;
+    private static compile;
+    static fromJson(artifact: any): Contract;
+    static fromArtifactFile(fileName: string): Promise<Contract>;
+    toString(): string;
+    toState(fields: Fields, asset: Asset, address?: string): ContractState;
+    static randomAddress(): string;
+    private _test;
+    testPublicMethod(provider: NodeProvider, funcName: string, params: TestContractParams): Promise<TestContractResult>;
+    testPrivateMethod(provider: NodeProvider, funcName: string, params: TestContractParams): Promise<TestContractResult>;
+    toApiFields(fields?: Fields): node.Val[];
+    toApiArgs(funcName: string, args?: Arguments): node.Val[];
+    getMethodIndex(funcName: string): number;
+    toApiContractStates(states?: ContractState[]): node.ContractState[] | undefined;
+    toTestContract(funcName: string, params: TestContractParams): node.TestContract;
+    static fromCodeHash(codeHash: string): Promise<Contract>;
+    static getFieldsSig(state: node.ContractState): Promise<node.FieldsSig>;
+    fromApiContractState(state: node.ContractState): Promise<ContractState>;
+    static ContractCreatedEvent: node.EventSig;
+    static ContractDestroyedEvent: node.EventSig;
+    static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined): Promise<ContractEventByTxId>;
+    fromTestContractResult(methodIndex: number, result: node.TestContractResult): Promise<TestContractResult>;
+    paramsForDeployment(params: BuildDeployContractTx): Promise<SignDeployContractTxParams>;
+    transactionForDeployment(signer: SignerWithNodeProvider, params: Omit<BuildDeployContractTx, 'signerAddress'>): Promise<DeployContractTransaction>;
+    buildByteCodeToDeploy(initialFields: Fields): string;
+}
+export declare class Script extends Common {
+    readonly bytecodeTemplate: string;
+    readonly fieldsSig: node.FieldsSig;
+    constructor(sourceCodeSha256: string, bytecodeTemplate: string, fieldsSig: node.FieldsSig, functions: node.FunctionSig[]);
+    static checkCodeType(fileName: string, contractStr: string): void;
+    private static loadContractStr;
+    static fromSource(provider: NodeProvider, fileName: string): Promise<Script>;
+    private static compile;
+    static fromJson(artifact: any): Script;
+    static fromArtifactFile(fileName: string): Promise<Script>;
+    toString(): string;
+    paramsForDeployment(params: BuildExecuteScriptTx): Promise<SignExecuteScriptTxParams>;
+    transactionForDeployment(signer: SignerWithNodeProvider, params: Omit<BuildExecuteScriptTx, 'signerAddress'>): Promise<BuildScriptTxResult>;
+    buildByteCodeToDeploy(initialFields: Fields): string;
+}
+export declare type Number256 = number | bigint | string;
+export declare type Val = Number256 | boolean | string | Val[];
+export declare type NamedVals = Record<string, Val>;
+export declare type Fields = NamedVals;
+export declare type Arguments = NamedVals;
+export declare function extractArray(tpe: string, v: Val): node.Val;
+export declare function toApiVal(v: Val, tpe: string): node.Val;
+export interface Asset {
+    alphAmount: Number256;
+    tokens?: Token[];
+}
+export interface Token {
+    id: string;
+    amount: Number256;
+}
+export interface InputAsset {
+    address: string;
+    asset: Asset;
+}
+export interface ContractState {
+    address: string;
+    contractId: string;
+    bytecode: string;
+    initialStateHash?: string;
+    codeHash: string;
+    fields: Fields;
+    fieldsSig: node.FieldsSig;
+    asset: Asset;
+}
+export interface TestContractParams {
+    group?: number;
+    address?: string;
+    initialFields?: Fields;
+    initialAsset?: Asset;
+    testMethodIndex?: number;
+    testArgs?: Arguments;
+    existingContracts?: ContractState[];
+    inputAssets?: InputAsset[];
+}
+export interface ContractEvent {
+    blockHash: string;
+    txId: string;
+    name: string;
+    fields: Fields;
+}
+export interface ContractEventByTxId {
+    blockHash: string;
+    contractAddress: string;
+    name: string;
+    fields: Fields;
+}
+export interface TestContractResult {
+    address: string;
+    contractId: string;
+    returns: Val[];
+    gasUsed: number;
+    contracts: ContractState[];
+    txOutputs: Output[];
+    events: ContractEventByTxId[];
+}
+export declare type Output = AssetOutput | ContractOutput;
+export interface AssetOutput extends Asset {
+    type: string;
+    address: string;
+    lockTime: number;
+    message: string;
+}
+export interface ContractOutput {
+    type: string;
+    address: string;
+    alphAmount: Number256;
+    tokens: Token[];
+}
+export interface DeployContractTransaction {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    txId: string;
+    contractAddress: string;
+    contractId: string;
+}
+export interface BuildDeployContractTx {
+    signerAddress: string;
+    initialFields?: Fields;
+    initialAlphAmount?: string;
+    initialTokenAmounts?: Token[];
+    issueTokenAmount?: Number256;
+    gasAmount?: number;
+    gasPrice?: Number256;
+    submitTx?: boolean;
+}
+export interface BuildExecuteScriptTx {
+    signerAddress: string;
+    initialFields?: Fields;
+    alphAmount?: Number256;
+    tokens?: Token[];
+    gasAmount?: number;
+    gasPrice?: Number256;
+    submitTx?: boolean;
+}
+export interface BuildScriptTxResult {
+    fromGroup: number;
+    toGroup: number;
+    unsignedTx: string;
+    txId: string;
+}