@alephium/web3 0.35.1 → 0.36.1

package/dist/src/api/api-alephium.d.ts

@@ -380,6 +380,7 @@ export interface CompileContractResult {
 export interface CompileProjectResult {
     contracts: CompileContractResult[];
     scripts: CompileScriptResult[];
+    structs?: StructSig[];
 }
 export interface CompileScriptResult {
     version: string;
@@ -696,6 +697,12 @@ export interface Source {
     gasAmount?: number;
     utxos?: OutputRef[];
 }
+export interface StructSig {
+    name: string;
+    fieldNames: string[];
+    fieldTypes: string[];
+    isMutable: boolean[];
+}
 export interface SubmitMultisig {
     unsignedTx: string;
     signatures: string[];
@@ -995,7 +1002,7 @@ export declare class HttpClient<SecurityDataType = unknown> {
 }
 /**
  * @title Alephium API
- * @version 2.9.0
+ * @version 2.10.0
  * @baseUrl ../
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {

package/dist/src/api/api-alephium.js

@@ -151,7 +151,7 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 2.9.0
+ * @version 2.10.0
  * @baseUrl ../
  */
 class Api extends HttpClient {

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

@@ -1,7 +1,10 @@
 import * as node from './api-alephium';
 export type Number256 = bigint | string;
-export type Val = Number256 | boolean | string | Val[];
+export type Val = Number256 | boolean | string | Val[] | ValObject;
+export interface ValObject extends Record<string, Val> {
+}
 export type NamedVals = Record<string, Val>;
+export declare const PrimitiveTypes: string[];
 export interface Token {
     id: string;
     amount: Number256;
@@ -18,11 +21,9 @@ 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 getDefaultValue(tpe: string): Val;
-export declare function typeLength(tpe: string): number;
+export declare function fromApiPrimitiveVal(value: node.Val, tpe: string, systemEvent?: boolean): Val;
+export declare function decodeArrayType(tpe: string): [string, number];
+export declare function getDefaultPrimitiveValue(tpe: string): Val;
 export interface ApiRequestArguments {
     path: string;
     method: string;

package/dist/src/api/types.js

@@ -17,10 +17,11 @@ 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.StdInterfaceIds = exports.request = exports.requestWithLog = exports.forwardRequests = exports.typeLength = exports.getDefaultValue = 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;
+exports.StdInterfaceIds = exports.request = exports.requestWithLog = exports.forwardRequests = exports.getDefaultPrimitiveValue = exports.decodeArrayType = exports.fromApiPrimitiveVal = exports.toApiVal = exports.toApiArray = exports.toApiAddress = exports.toApiByteVec = exports.fromApiNumber256 = exports.toApiNumber256Optional = exports.toApiNumber256 = exports.toApiBoolean = exports.fromApiTokens = exports.fromApiToken = exports.toApiTokens = exports.toApiToken = exports.PrimitiveTypes = void 0;
 const constants_1 = require("../constants");
 const debug_1 = require("../debug");
 const utils_1 = require("../utils");
+exports.PrimitiveTypes = ['U256', 'I256', 'Bool', 'ByteVec', 'Address'];
 utils_1.assertType;
 function toApiToken(token) {
     return { id: token.id, amount: toApiNumber256(token.amount) };
@@ -145,88 +146,32 @@ function toApiVal(v, tpe) {
     }
 }
 exports.toApiVal = toApiVal;
-function _fromApiVal(vals, valIndex, tpe, systemEvent = false) {
-    if (vals.length === 0) {
-        throw new Error('Not enough Vals');
+function fromApiPrimitiveVal(value, tpe, systemEvent = false) {
+    if (tpe === 'Bool' && value.type === tpe) {
+        return value.value;
     }
-    const firstVal = vals[`${valIndex}`];
-    if (tpe === 'Bool' && firstVal.type === tpe) {
-        return [firstVal.value, valIndex + 1];
+    else if ((tpe === 'U256' || tpe === 'I256') && value.type === tpe) {
+        return fromApiNumber256(value.value);
     }
-    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 if ((tpe === 'ByteVec' || tpe === 'Address') && (value.type === tpe || systemEvent)) {
+        return value.value;
     }
     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}`);
-        }
+        throw new Error(`Expected primitive type, got ${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;
+exports.fromApiPrimitiveVal = fromApiPrimitiveVal;
 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]];
+        throw new Error(`Invalid array type: ${tpe}`);
     }
+    const baseType = tpe.slice(1, semiColonIndex);
+    const size = parseInt(tpe.slice(semiColonIndex + 1, -1));
+    return [baseType, size];
 }
-function getDefaultValue(tpe) {
+exports.decodeArrayType = decodeArrayType;
+function getDefaultPrimitiveValue(tpe) {
     if (tpe === 'U256' || tpe === 'I256')
         return 0n;
     if (tpe === 'Bool')
@@ -235,35 +180,9 @@ function getDefaultValue(tpe) {
         return '';
     if (tpe === 'Address')
         return constants_1.ZERO_ADDRESS;
-    // array type
-    const [baseType, dims] = decodeArrayType(tpe);
-    const defaultBaseValue = getDefaultValue(baseType);
-    return dims.reduceRight((acc, length) => Array(length).fill(acc), defaultBaseValue);
-}
-exports.getDefaultValue = getDefaultValue;
-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);
+    throw Error(`Expected primitive type, got ${tpe}`);
 }
-exports.typeLength = typeLength;
+exports.getDefaultPrimitiveValue = getDefaultPrimitiveValue;
 async function call(args, handler) {
     const debugModeEnabled = (0, debug_1.isDebugModeEnabled)();
     const { path, method, params } = args;

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

@@ -1,4 +1,4 @@
-import { NamedVals, node, NodeProvider, Number256, Token } from '../api';
+import { NamedVals, node, NodeProvider, Number256, Token, Val } from '../api';
 import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignerProvider, Address } from '../signer';
 import { Optional } from '../utils';
 import { EventSubscribeOptions, EventSubscription } from './events';
@@ -15,7 +15,8 @@ declare enum SourceKind {
     Contract = 0,
     Script = 1,
     AbstractContract = 2,
-    Interface = 3
+    Interface = 3,
+    Struct = 4
 }
 export type CompilerOptions = node.CompilerOptions & {
     errorOnWarnings: boolean;
@@ -63,10 +64,21 @@ export declare class ProjectArtifact {
     needToReCompile(compilerOptions: node.CompilerOptions, sourceInfos: SourceInfo[], fullNodeVersion: string): boolean;
     static from(rootPath: string): Promise<ProjectArtifact | undefined>;
 }
+export declare class Struct {
+    name: string;
+    fieldNames: string[];
+    fieldTypes: string[];
+    isMutable: boolean[];
+    constructor(name: string, fieldNames: string[], fieldTypes: string[], isMutable: boolean[]);
+    static fromJson(json: any): Struct;
+    static fromStructSig(sig: node.StructSig): Struct;
+    toJson(): any;
+}
 export declare class Project {
     sourceInfos: SourceInfo[];
     contracts: Map<string, Compiled<Contract>>;
     scripts: Map<string, Compiled<Script>>;
+    structs: Struct[];
     projectArtifact: ProjectArtifact;
     readonly contractsRootDir: string;
     readonly artifactsRootDir: string;
@@ -76,12 +88,15 @@ export declare class Project {
     static readonly contractMatcher: TypedMatcher<SourceKind.Contract>;
     static readonly interfaceMatcher: TypedMatcher<SourceKind.Interface>;
     static readonly scriptMatcher: TypedMatcher<SourceKind.Script>;
+    static readonly structMatcher: TypedMatcher<SourceKind.Struct>;
     static readonly matchers: TypedMatcher<SourceKind>[];
     static buildProjectArtifact(fullNodeVersion: string, sourceInfos: SourceInfo[], contracts: Map<string, Compiled<Contract>>, scripts: Map<string, Compiled<Script>>, compilerOptions: node.CompilerOptions): ProjectArtifact;
     private constructor();
     static checkCompilerWarnings(warnings: string[], errorOnWarnings: boolean): void;
     static contract(name: string): Contract;
     static script(name: string): Script;
+    private static loadStructs;
+    private saveStructsToFile;
     private saveArtifactsToFile;
     contractByCodeHash(codeHash: string): Contract;
     private static getCompileResult;
@@ -114,13 +129,14 @@ export declare class Contract extends Artifact {
     readonly eventsSig: EventSig[];
     readonly constants: Constant[];
     readonly enums: Enum[];
+    readonly structs: Struct[];
     readonly stdInterfaceId?: HexString;
     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[], constants: Constant[], enums: Enum[], stdInterfaceId?: HexString);
-    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>;
+    constructor(version: string, name: string, bytecode: string, bytecodeDebugPatch: string, codeHash: string, codeHashDebug: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[], constants: Constant[], enums: Enum[], structs: Struct[], stdInterfaceId?: HexString);
+    static fromJson(artifact: any, bytecodeDebugPatch?: string, codeHashDebug?: string, structs?: Struct[]): Contract;
+    static fromCompileResult(result: node.CompileContractResult, structs?: Struct[]): Contract;
+    static fromArtifactFile(path: string, bytecodeDebugPatch: string, codeHashDebug: string, structs?: Struct[]): Promise<Contract>;
     toString(): string;
     getInitialFieldsWithDefaultValues(): Fields;
     toState<T extends Fields>(fields: T, asset: Asset, address?: string): ContractState<T>;
@@ -149,14 +165,19 @@ export declare class Script extends Artifact {
     readonly bytecodeTemplate: string;
     readonly bytecodeDebugPatch: string;
     readonly fieldsSig: FieldsSig;
-    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>;
+    readonly structs: Struct[];
+    constructor(version: string, name: string, bytecodeTemplate: string, bytecodeDebugPatch: string, fieldsSig: FieldsSig, functions: FunctionSig[], structs: Struct[]);
+    static fromCompileResult(result: node.CompileScriptResult, structs?: Struct[]): Script;
+    static fromJson(artifact: any, bytecodeDebugPatch?: string, structs?: Struct[]): Script;
+    static fromArtifactFile(path: string, bytecodeDebugPatch: string, structs?: Struct[]): Promise<Script>;
     toString(): string;
     txParamsForExecution<P extends Fields>(signer: SignerProvider, params: ExecuteScriptParams<P>): Promise<SignExecuteScriptTxParams>;
     buildByteCodeToDeploy(initialFields: Fields): string;
 }
+export declare function fromApiFields(immFields: node.Val[], mutFields: node.Val[], fieldsSig: FieldsSig, structs: Struct[]): NamedVals;
+export declare function getDefaultValue(fieldsSig: FieldsSig, structs: Struct[]): Fields;
+export declare function fromApiArray(values: node.Val[], types: string[], structs: Struct[]): Val[];
+export declare function fromApiEventFields(vals: node.Val[], eventSig: node.EventSig, systemEvent?: boolean): Fields;
 export interface Asset {
     alphAmount: Number256;
     tokens?: Token[];
@@ -175,7 +196,6 @@ export interface ContractState<T extends Fields = Fields> {
     fieldsSig: FieldsSig;
     asset: Asset;
 }
-export declare function toApiVals(fields: Fields, names: string[], types: string[]): node.Val[];
 export interface TestContractParams<F extends Fields = Fields, A extends Arguments = Arguments> {
     group?: number;
     address?: string;