@alephium/web3 0.2.0-test.1 → 0.2.2

package/dist/src/api/types.js

@@ -0,0 +1,235 @@
+"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) {
+    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,35 +1,35 @@
-import { node, NodeProvider } from '../api';
-import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer';
-import { CompileContractResult, CompileScriptResult } from '../api/api-alephium';
-declare type FieldsSig = node.FieldsSig;
-declare type EventSig = node.EventSig;
-declare type FunctionSig = node.FunctionSig;
+import { NamedVals, node, Number256, Token, Val } from '../api';
+import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerProvider, SignExecuteScriptTxResult, SignDeployContractTxResult } 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 = {
+export declare type CompilerOptions = node.CompilerOptions & {
     errorOnWarnings: boolean;
-    ignoreUnusedConstantsWarnings: 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;
-    name: string | undefined;
     constructor(pattern: string, type: T);
     match(str: string): number;
 }
 declare class SourceFile {
     type: SourceType;
-    typeId: string;
     contractPath: string;
     sourceCode: string;
     sourceCodeHash: string;
-    getArtifactPath(artifactsRootPath: string): string;
-    constructor(type: SourceType, typeId: string, sourceCode: string, contractPath: 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;
@@ -37,37 +37,56 @@ declare class Compiled<T extends Artifact> {
     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>[];
-    readonly contractsRootPath: string;
-    readonly artifactsRootPath: string;
-    readonly nodeProvider: NodeProvider;
+    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;
-    private static checkCompilerWarnings;
-    static contract(path: string, compilerOptions?: Partial<CompilerOptions>): Contract;
-    static script(path: string, compilerOptions?: Partial<CompilerOptions>): Script;
+    static checkCompilerWarnings(warnings: string[], errorOnWarnings: boolean): void;
+    static contract(name: string): Contract;
+    static script(name: string): Script;
     private saveArtifactsToFile;
     contractByCodeHash(codeHash: string): Contract;
-    private saveProjectArtifactToFile;
     private static compile;
     private static loadArtifacts;
     private static loadSourceFile;
     private static loadSourceFiles;
-    static build(contractsRootPath?: string, artifactsRootPath?: string): Promise<void>;
+    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 typeId: string;
+    readonly version: string;
+    readonly name: string;
     readonly functions: FunctionSig[];
-    constructor(typeId: string, functions: FunctionSig[]);
+    constructor(version: string, name: string, functions: FunctionSig[]);
     abstract buildByteCodeToDeploy(initialFields?: Fields): string;
     publicFunctions(): string[];
     usingPreapprovedAssetsFunctions(): string[];
@@ -75,61 +94,56 @@ export declare abstract class Artifact {
 }
 export declare class Contract extends Artifact {
     readonly bytecode: string;
+    readonly bytecodeDebugPatch: string;
     readonly codeHash: string;
     readonly fieldsSig: FieldsSig;
     readonly eventsSig: EventSig[];
-    constructor(typeId: string, bytecode: string, codeHash: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[]);
-    static fromJson(artifact: any): Contract;
-    static fromCompileResult(typeId: string, result: CompileContractResult): Contract;
-    static fromArtifactFile(path: string): Promise<Contract>;
+    readonly bytecodeDebug: string;
+    readonly codeHashDebug: string;
+    constructor(version: string, 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(funcName: string, params: TestContractParams): Promise<TestContractResult>;
-    testPrivateMethod(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;
-    fromApiContractState(state: node.ContractState): Promise<ContractState>;
+    fromApiContractState(state: node.ContractState): ContractState;
+    static fromApiContractState(state: node.ContractState): ContractState;
     static ContractCreatedEvent: EventSig;
     static ContractDestroyedEvent: 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>;
+    static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined): ContractEventByTxId;
+    fromTestContractResult(methodIndex: number, result: node.TestContractResult): TestContractResult;
+    txParamsForDeployment(signer: SignerProvider, params: Omit<BuildDeployContractTx, 'signerAddress'>): Promise<SignDeployContractTxParams>;
+    deploy(signer: SignerProvider, params: Omit<BuildDeployContractTx, 'signerAddress'>): Promise<SignDeployContractTxResult>;
     buildByteCodeToDeploy(initialFields: Fields): string;
 }
 export declare class Script extends Artifact {
     readonly bytecodeTemplate: string;
+    readonly bytecodeDebugPatch: string;
     readonly fieldsSig: FieldsSig;
-    constructor(typeId: string, bytecodeTemplate: string, fieldsSig: FieldsSig, functions: FunctionSig[]);
-    static fromCompileResult(typeId: string, result: CompileScriptResult): Script;
-    static fromJson(artifact: any): Script;
-    static fromArtifactFile(path: string): Promise<Script>;
+    constructor(version: string, 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>;
+    txParamsForExecution(signer: SignerProvider, params: Omit<BuildExecuteScriptTx, 'signerAddress'>): Promise<SignExecuteScriptTxParams>;
+    execute(signer: SignerProvider, params: Omit<BuildExecuteScriptTx, 'signerAddress'>): Promise<SignExecuteScriptTxResult>;
     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;
@@ -166,14 +180,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 {
@@ -186,7 +202,7 @@ export interface ContractOutput {
     type: string;
     address: string;
     alphAmount: Number256;
-    tokens: Token[];
+    tokens?: Token[];
 }
 export interface DeployContractTransaction {
     fromGroup: number;
@@ -199,12 +215,11 @@ export interface DeployContractTransaction {
 export interface BuildDeployContractTx {
     signerAddress: string;
     initialFields?: Fields;
-    initialAttoAlphAmount?: string;
+    initialAttoAlphAmount?: Number256;
     initialTokenAmounts?: Token[];
     issueTokenAmount?: Number256;
     gasAmount?: number;
     gasPrice?: Number256;
-    submitTx?: boolean;
 }
 export interface BuildExecuteScriptTx {
     signerAddress: string;
@@ -213,7 +228,6 @@ export interface BuildExecuteScriptTx {
     tokens?: Token[];
     gasAmount?: number;
     gasPrice?: Number256;
-    submitTx?: boolean;
 }
 export interface BuildScriptTxResult {
     fromGroup: number;