@alephium/web3 0.2.0-rc.3 → 0.2.0-rc.30

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

@@ -1,10 +1,11 @@
 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 NodeProvider extends NodeApi<string> {
+    constructor(baseUrl: string, apiKey?: string);
 }
 export declare class ExplorerProvider extends ExplorerApi<null> {
     constructor(baseUrl: string);
 }
 export * as node from './api-alephium';
 export * as explorer from './api-explorer';
+export * from './types';

package/dist/src/api/index.js

@@ -18,7 +18,11 @@ 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]; } });
+    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];
@@ -35,13 +39,27 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
+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);
+};
 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 });
+    constructor(baseUrl, apiKey) {
+        // eslint-disable-next-line security/detect-possible-timing-attacks
+        if (apiKey === undefined) {
+            super({ baseUrl: baseUrl });
+        }
+        else {
+            super({
+                baseUrl: baseUrl,
+                baseApiParams: { secure: true },
+                securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
+            });
+            this.setSecurityData(apiKey);
+        }
     }
 }
 exports.NodeProvider = NodeProvider;
@@ -53,3 +71,4 @@ class ExplorerProvider extends api_explorer_1.Api {
 exports.ExplorerProvider = ExplorerProvider;
 exports.node = __importStar(require("./api-alephium"));
 exports.explorer = __importStar(require("./api-explorer"));
+__exportStar(require("./types"), exports);

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

@@ -0,0 +1,23 @@
+import * as node from './api-alephium';
+export declare type Number256 = number | bigint | string;
+export declare type Val = Number256 | boolean | string | Val[];
+export declare 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): Number256;
+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[]): NamedVals;
+export declare function fromApiArray(vals: node.Val[], types: string[]): Val[];
+export declare function fromApiVal(v: node.Val, tpe: string): Val;

package/dist/src/api/types.js

@@ -0,0 +1,240 @@
+"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.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) {
+    if (Number.isSafeInteger(Number.parseInt(n))) {
+        return Number(n);
+    }
+    else {
+        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) {
+    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) {
+        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) {
+    let valIndex = 0;
+    const result = {};
+    types.forEach((currentType, index) => {
+        const currentName = names[`${index}`];
+        const [val, nextIndex] = _fromApiVal(vals, valIndex, currentType);
+        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;
+    }
+}

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

@@ -0,0 +1,6 @@
+export declare function convertHttpResponse<T>(response: {
+    data: T;
+    error?: {
+        detail: string;
+    };
+}): T;

package/dist/{scripts/rename-gitignore.js → src/api/utils.js}

@@ -16,9 +16,14 @@ 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/>.
 */
-const { rename } = require('fs');
-rename(process.argv[2], process.argv[3], function (error) {
-    if (error)
-        console.log(error);
-    console.log(`Renamed ${process.argv[2]} to ${process.argv[3]}.`);
-});
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertHttpResponse = void 0;
+function convertHttpResponse(response) {
+    if (response.error) {
+        throw new Error(`[Node API Error] - ${response.error.detail}`);
+    }
+    else {
+        return response.data;
+    }
+}
+exports.convertHttpResponse = convertHttpResponse;

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

@@ -1,71 +1,121 @@
-import { NodeProvider } from '../api';
-import { node } from '../api';
+import { NamedVals, node, Number256, Token, Val } from '../api';
 import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer';
+export declare type FieldsSig = node.FieldsSig;
+export declare type EventSig = node.EventSig;
+export declare type FunctionSig = node.FunctionSig;
+export declare type Fields = NamedVals;
+export declare type Arguments = NamedVals;
+declare enum SourceType {
+    Contract = 0,
+    Script = 1,
+    AbstractContract = 2,
+    Interface = 3
+}
+export declare type CompilerOptions = node.CompilerOptions & {
+    errorOnWarnings: boolean;
+};
+export declare const DEFAULT_NODE_COMPILER_OPTIONS: node.CompilerOptions;
+export declare const DEFAULT_COMPILER_OPTIONS: CompilerOptions;
+declare class TypedMatcher<T extends SourceType> {
+    matcher: RegExp;
+    type: T;
+    constructor(pattern: string, type: T);
+    match(str: string): number;
+}
 declare class SourceFile {
-    readonly dirs: string[];
-    readonly dirPath: string;
-    readonly contractPath: string;
-    readonly artifactPath: string;
-    constructor(dirs: string[], fileName: string);
-}
-declare type FieldsSig = node.FieldsSig;
-declare type EventSig = node.EventSig;
-declare type FunctionSig = node.FunctionSig;
-export declare abstract class Common {
-    readonly sourceCodeSha256: string;
+    type: SourceType;
+    contractPath: string;
+    sourceCode: string;
+    sourceCodeHash: string;
+    getArtifactPath(artifactsRootDir: string): string;
+    constructor(type: SourceType, sourceCode: string, sourceCodeHash: string, contractPath: string);
+    static from(type: SourceType, sourceCode: string, contractPath: string): Promise<SourceFile>;
+}
+declare class Compiled<T extends Artifact> {
+    sourceFile: SourceFile;
+    artifact: T;
+    warnings: string[];
+    constructor(sourceFile: SourceFile, artifact: T, warnings: string[]);
+}
+declare type CodeInfo = {
+    sourceCodeHash: string;
+    bytecodeDebugPatch: string;
+    codeHashDebug: string;
+    warnings: string[];
+};
+declare class ProjectArtifact {
+    static readonly artifactFileName = ".project.json";
+    compilerOptionsUsed: node.CompilerOptions;
+    infos: Map<string, CodeInfo>;
+    static checkCompilerOptionsParameter(compilerOptions: node.CompilerOptions): void;
+    constructor(compilerOptionsUsed: node.CompilerOptions, infos: Map<string, CodeInfo>);
+    saveToFile(rootPath: string): Promise<void>;
+    needToReCompile(compilerOptions: node.CompilerOptions, files: SourceFile[]): boolean;
+    static from(rootPath: string): Promise<ProjectArtifact | undefined>;
+}
+export declare class Project {
+    sourceFiles: SourceFile[];
+    contracts: Compiled<Contract>[];
+    scripts: Compiled<Script>[];
+    projectArtifact: ProjectArtifact;
+    readonly contractsRootDir: string;
+    readonly artifactsRootDir: string;
+    static currentProject: Project;
+    static readonly abstractContractMatcher: TypedMatcher<SourceType>;
+    static readonly contractMatcher: TypedMatcher<SourceType.Contract>;
+    static readonly interfaceMatcher: TypedMatcher<SourceType.Interface>;
+    static readonly scriptMatcher: TypedMatcher<SourceType.Script>;
+    static readonly matchers: TypedMatcher<SourceType>[];
+    static buildProjectArtifact(sourceFiles: SourceFile[], contracts: Compiled<Contract>[], scripts: Compiled<Script>[], compilerOptions: node.CompilerOptions): ProjectArtifact;
+    private constructor();
+    private getContractPath;
+    static checkCompilerWarnings(warnings: string[], errorOnWarnings: boolean): void;
+    static contract(name: string): Contract;
+    static script(name: string): Script;
+    private saveArtifactsToFile;
+    contractByCodeHash(codeHash: string): Contract;
+    private static compile;
+    private static loadArtifacts;
+    private static loadSourceFile;
+    private static loadSourceFiles;
+    static readonly DEFAULT_CONTRACTS_DIR = "contracts";
+    static readonly DEFAULT_ARTIFACTS_DIR = "artifacts";
+    static build(compilerOptionsPartial?: Partial<CompilerOptions>, contractsRootDir?: string, artifactsRootDir?: string): Promise<void>;
+}
+export declare abstract class Artifact {
+    readonly name: string;
     readonly functions: 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: FunctionSig[]);
-    protected static _artifactsFolder(): string;
-    static getSourceFile(path: string, _dirs: string[]): SourceFile;
-    protected static _handleImports(pathes: string[], contractStr: string, importsCache: string[]): Promise<string>;
-    protected static _loadContractStr(sourceFile: SourceFile, importsCache: string[], validate: (code: string) => void): Promise<string>;
-    static checkFileNameExtension(fileName: string): void;
-    protected static _from<T extends {
-        sourceCodeSha256: string;
-    }>(provider: NodeProvider, sourceFile: SourceFile, loadContractStr: (sourceFile: SourceFile, importsCache: string[]) => Promise<string>, compile: (provider: NodeProvider, sourceFile: SourceFile, contractStr: string, contractHash: string, errorOnWarnings: boolean) => Promise<T>, errorOnWarnings: boolean): Promise<T>;
-    protected _saveToFile(sourceFile: SourceFile): Promise<void>;
+    constructor(name: string, functions: FunctionSig[]);
     abstract buildByteCodeToDeploy(initialFields?: Fields): string;
     publicFunctions(): string[];
     usingPreapprovedAssetsFunctions(): string[];
     usingAssetsInContractFunctions(): string[];
-    protected static checkCompilerWarnings(compiled: {
-        warnings: string[];
-    }, errorOnWarnings: boolean): void;
 }
-export declare class Contract extends Common {
+export declare class Contract extends Artifact {
     readonly bytecode: string;
+    readonly bytecodeDebugPatch: string;
     readonly codeHash: string;
     readonly fieldsSig: FieldsSig;
     readonly eventsSig: EventSig[];
-    constructor(sourceCodeSha256: string, bytecode: string, codeHash: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[]);
-    static checkCodeType(fileName: string, contractStr: string): void;
-    private static loadContractStr;
-    static fromSource(provider: NodeProvider, path: string, errorOnWarnings?: boolean): Promise<Contract>;
-    private static compile;
-    static fromJson(artifact: any): Contract;
-    static fromArtifactFile(path: string): Promise<Contract>;
-    fetchState(provider: NodeProvider, address: string, group: number): Promise<ContractState>;
+    readonly bytecodeDebug: string;
+    readonly codeHashDebug: string;
+    constructor(name: string, bytecode: string, bytecodeDebugPatch: string, codeHash: string, codeHashDebug: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[]);
+    static fromJson(artifact: any, bytecodeDebugPatch?: string, codeHashDebug?: string): Contract;
+    static fromCompileResult(result: node.CompileContractResult): Contract;
+    static fromArtifactFile(path: string, bytecodeDebugPatch: string, codeHashDebug: string): Promise<Contract>;
+    fetchState(address: string, group: number): Promise<ContractState>;
     toString(): string;
     toState(fields: Fields, asset: Asset, address?: string): ContractState;
     static randomAddress(): string;
+    private _printDebugMessages;
     private _test;
-    testPublicMethod(provider: NodeProvider, funcName: string, params: TestContractParams): Promise<TestContractResult>;
-    testPrivateMethod(provider: NodeProvider, funcName: string, params: TestContractParams): Promise<TestContractResult>;
+    testPublicMethod(funcName: string, params: TestContractParams, printDebugMessages?: boolean): Promise<TestContractResult>;
+    testPrivateMethod(funcName: string, params: TestContractParams, printDebugMessages?: boolean): 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<FieldsSig>;
     fromApiContractState(state: node.ContractState): Promise<ContractState>;
     static ContractCreatedEvent: EventSig;
     static ContractDestroyedEvent: EventSig;
@@ -75,36 +125,23 @@ export declare class Contract extends Common {
     transactionForDeployment(signer: SignerWithNodeProvider, params: Omit<BuildDeployContractTx, 'signerAddress'>): Promise<DeployContractTransaction>;
     buildByteCodeToDeploy(initialFields: Fields): string;
 }
-export declare class Script extends Common {
+export declare class Script extends Artifact {
     readonly bytecodeTemplate: string;
+    readonly bytecodeDebugPatch: string;
     readonly fieldsSig: FieldsSig;
-    constructor(sourceCodeSha256: string, bytecodeTemplate: string, fieldsSig: FieldsSig, functions: FunctionSig[]);
-    static checkCodeType(fileName: string, contractStr: string): void;
-    private static loadContractStr;
-    static fromSource(provider: NodeProvider, path: string, errorOnWarnings?: boolean): Promise<Script>;
-    private static compile;
-    static fromJson(artifact: any): Script;
-    static fromArtifactFile(path: string): Promise<Script>;
+    constructor(name: string, bytecodeTemplate: string, bytecodeDebugPatch: string, fieldsSig: FieldsSig, functions: FunctionSig[]);
+    static fromCompileResult(result: node.CompileScriptResult): Script;
+    static fromJson(artifact: any, bytecodeDebugPatch?: string): Script;
+    static fromArtifactFile(path: string, bytecodeDebugPatch: 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;
@@ -141,14 +178,16 @@ export interface ContractEventByTxId {
     name: string;
     fields: Fields;
 }
+export declare type DebugMessage = node.DebugMessage;
 export interface TestContractResult {
-    address: string;
     contractId: string;
+    contractAddress: string;
     returns: Val[];
     gasUsed: number;
     contracts: ContractState[];
     txOutputs: Output[];
     events: ContractEventByTxId[];
+    debugMessages: DebugMessage[];
 }
 export declare type Output = AssetOutput | ContractOutput;
 export interface AssetOutput extends Asset {
@@ -161,7 +200,7 @@ export interface ContractOutput {
     type: string;
     address: string;
     alphAmount: Number256;
-    tokens: Token[];
+    tokens?: Token[];
 }
 export interface DeployContractTransaction {
     fromGroup: number;