@alephium/web3 0.3.0-rc.8 → 0.5.0-rc.0

package/dist/src/contract/contract.js

@@ -43,7 +43,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = void 0;
+exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.ContractFactory = exports.randomTxId = exports.toApiVals = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = void 0;
 const buffer_1 = require("buffer/");
 const crypto_1 = require("crypto");
 const fs_1 = __importDefault(require("fs"));
@@ -52,8 +52,8 @@ const api_1 = require("../api");
 const ralph = __importStar(require("./ralph"));
 const utils_1 = require("../utils");
 const global_1 = require("../global");
-const __1 = require("..");
 const path = __importStar(require("path"));
+const events_1 = require("./events");
 var SourceKind;
 (function (SourceKind) {
     SourceKind[SourceKind["Contract"] = 0] = "Contract";
@@ -249,7 +249,7 @@ class Project {
         }
         return script.artifact;
     }
-    async saveArtifactsToFile() {
+    async saveArtifactsToFile(projectRootDir) {
         const artifactsRootDir = this.artifactsRootDir;
         const saveToFile = async function (compiled) {
             const artifactPath = compiled.sourceInfo.getArtifactPath(artifactsRootDir);
@@ -261,7 +261,7 @@ class Project {
         };
         this.contracts.forEach((contract) => saveToFile(contract));
         this.scripts.forEach((script) => saveToFile(script));
-        await this.projectArtifact.saveToFile(this.artifactsRootDir);
+        await this.projectArtifact.saveToFile(projectRootDir);
     }
     contractByCodeHash(codeHash) {
         const contract = [...this.contracts.values()].find((c) => c.artifact.codeHash === codeHash || c.artifact.codeHashDebug == codeHash);
@@ -270,7 +270,7 @@ class Project {
         }
         return contract.artifact;
     }
-    static async compile(provider, sourceInfos, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
+    static async compile(provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
         const sourceStr = sourceInfos.map((f) => f.sourceCode).join('\n');
         const result = await provider.contracts.postContractsCompileProject({
             code: sourceStr,
@@ -290,10 +290,10 @@ class Project {
         });
         const projectArtifact = Project.buildProjectArtifact(sourceInfos, contracts, scripts, compilerOptions);
         const project = new Project(contractsRootDir, artifactsRootDir, sourceInfos, contracts, scripts, errorOnWarnings, projectArtifact);
-        await project.saveArtifactsToFile();
+        await project.saveArtifactsToFile(projectRootDir);
         return project;
     }
-    static async loadArtifacts(provider, sourceInfos, projectArtifact, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
+    static async loadArtifacts(provider, sourceInfos, projectArtifact, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
         try {
             const contracts = new Map();
             const scripts = new Map();
@@ -317,7 +317,7 @@ class Project {
         }
         catch (error) {
             console.log(`Failed to load artifacts, error: ${error}, try to re-compile contracts...`);
-            return Project.compile(provider, sourceInfos, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions);
+            return Project.compile(provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions);
         }
     }
     static getImportSourcePath(projectRootDir, importPath) {
@@ -406,14 +406,14 @@ class Project {
         const provider = (0, global_1.getCurrentNodeProvider)();
         const sourceFiles = await Project.loadSourceFiles(projectRootDir, contractsRootDir);
         const { errorOnWarnings, ...nodeCompilerOptions } = { ...exports.DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial };
-        const projectArtifact = await ProjectArtifact.from(artifactsRootDir);
+        const projectArtifact = await ProjectArtifact.from(projectRootDir);
         if (typeof projectArtifact === 'undefined' || projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles)) {
             console.log(`Compiling contracts in folder "${contractsRootDir}"`);
-            Project.currentProject = await Project.compile(provider, sourceFiles, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
+            Project.currentProject = await Project.compile(provider, sourceFiles, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
         }
         else {
             console.log(`Contracts are compiled already. Loading them from folder "${artifactsRootDir}"`);
-            Project.currentProject = await Project.loadArtifacts(provider, sourceFiles, projectArtifact, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
+            Project.currentProject = await Project.loadArtifacts(provider, sourceFiles, projectArtifact, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, nodeCompilerOptions);
         }
     }
 }
@@ -482,12 +482,6 @@ class Contract extends Artifact {
         const artifact = JSON.parse(content.toString());
         return Contract.fromJson(artifact, bytecodeDebugPatch, codeHashDebug);
     }
-    async fetchState(address, group) {
-        const state = await __1.web3.getCurrentNodeProvider().contracts.getContractsAddressState(address, {
-            group: group
-        });
-        return this.fromApiContractState(state);
-    }
     toString() {
         const object = {
             version: this.version,
@@ -519,34 +513,12 @@ class Contract extends Artifact {
         bytes[0] = 3;
         return utils_1.bs58.encode(bytes);
     }
-    _printDebugMessages(funcName, messages) {
+    printDebugMessages(funcName, messages) {
         if (messages.length != 0) {
             console.log(`Testing ${this.name}.${funcName}:`);
             messages.forEach((m) => console.log(`Debug - ${m.contractAddress} - ${m.message}`));
         }
     }
-    async _test(funcName, params, expectPublic, accessType, printDebugMessages) {
-        const apiParams = this.toTestContract(funcName, params);
-        const apiResult = await __1.web3.getCurrentNodeProvider().contracts.postContractsTestContract(apiParams);
-        const methodIndex = typeof params.testMethodIndex !== 'undefined' ? params.testMethodIndex : this.getMethodIndex(funcName);
-        const isPublic = this.functions[`${methodIndex}`].isPublic;
-        if (printDebugMessages) {
-            this._printDebugMessages(funcName, apiResult.debugMessages);
-        }
-        if (isPublic === expectPublic) {
-            const result = await this.fromTestContractResult(methodIndex, apiResult);
-            return result;
-        }
-        else {
-            throw new Error(`The test method ${funcName} is not ${accessType}`);
-        }
-    }
-    async testPublicMethod(funcName, params, printDebugMessages = true) {
-        return this._test(funcName, params, true, 'public', printDebugMessages);
-    }
-    async testPrivateMethod(funcName, params, printDebugMessages = true) {
-        return this._test(funcName, params, false, 'private', printDebugMessages);
-    }
     toApiFields(fields) {
         if (typeof fields === 'undefined') {
             return [];
@@ -573,12 +545,15 @@ class Contract extends Artifact {
     toApiContractStates(states) {
         return typeof states != 'undefined' ? states.map((state) => toApiContractState(state)) : undefined;
     }
-    toTestContract(funcName, params) {
+    toApiTestContractParams(funcName, params) {
+        const immFields = params.initialFields === undefined ? [] : extractFields(params.initialFields, this.fieldsSig, false);
+        const mutFields = params.initialFields === undefined ? [] : extractFields(params.initialFields, this.fieldsSig, true);
         return {
             group: params.group,
             address: params.address,
             bytecode: this.bytecodeDebug,
-            initialFields: this.toApiFields(params.initialFields),
+            initialImmFields: immFields,
+            initialMutFields: mutFields,
             initialAsset: typeof params.initialAsset !== 'undefined' ? toApiAsset(params.initialAsset) : undefined,
             methodIndex: this.getMethodIndex(funcName),
             args: this.toApiArgs(funcName, params.testArgs),
@@ -593,7 +568,7 @@ class Contract extends Artifact {
             bytecode: state.bytecode,
             initialStateHash: state.initialStateHash,
             codeHash: state.codeHash,
-            fields: fromApiFields(state.fields, this.fieldsSig),
+            fields: fromApiFields(state.immFields, state.mutFields, this.fieldsSig),
             fieldsSig: this.fieldsSig,
             asset: fromApiAsset(state.asset)
         };
@@ -602,12 +577,12 @@ class Contract extends Artifact {
         const contract = Project.currentProject.contractByCodeHash(state.codeHash);
         return contract.fromApiContractState(state);
     }
-    static fromApiEvent(event, codeHash) {
+    static fromApiEvent(event, codeHash, txId) {
         let eventSig;
-        if (event.eventIndex == -1) {
+        if (event.eventIndex == Contract.ContractCreatedEventIndex) {
             eventSig = this.ContractCreatedEvent;
         }
-        else if (event.eventIndex == -2) {
+        else if (event.eventIndex == Contract.ContractDestroyedEventIndex) {
             eventSig = this.ContractDestroyedEvent;
         }
         else {
@@ -615,13 +590,15 @@ class Contract extends Artifact {
             eventSig = contract.eventsSig[event.eventIndex];
         }
         return {
+            txId: txId,
             blockHash: event.blockHash,
             contractAddress: event.contractAddress,
             name: eventSig.name,
+            eventIndex: event.eventIndex,
             fields: fromApiEventFields(event.fields, eventSig)
         };
     }
-    fromTestContractResult(methodIndex, result) {
+    fromApiTestContractResult(methodIndex, result, txId) {
         const addressToCodeHash = new Map();
         addressToCodeHash.set(result.address, result.codeHash);
         result.contracts.forEach((contract) => addressToCodeHash.set(contract.address, contract.codeHash));
@@ -632,46 +609,72 @@ class Contract extends Artifact {
             gasUsed: result.gasUsed,
             contracts: result.contracts.map((contract) => Contract.fromApiContractState(contract)),
             txOutputs: result.txOutputs.map(fromApiOutput),
-            events: result.events.map((event) => {
-                const contractAddress = event.contractAddress;
-                const codeHash = addressToCodeHash.get(contractAddress);
-                if (typeof codeHash !== 'undefined' || event.eventIndex < 0) {
-                    return Contract.fromApiEvent(event, codeHash);
-                }
-                else {
-                    throw Error(`Cannot find codeHash for the contract address: ${contractAddress}`);
-                }
-            }),
+            events: Contract.fromApiEvents(result.events, addressToCodeHash, txId),
             debugMessages: result.debugMessages
         };
     }
     async txParamsForDeployment(signer, params) {
-        const bytecode = this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {});
+        const bytecode = this.buildByteCodeToDeploy(params.initialFields ?? {});
         const signerParams = {
             signerAddress: await signer.getSelectedAddress(),
             bytecode: bytecode,
-            initialAttoAlphAmount: params.initialAttoAlphAmount,
-            issueTokenAmount: params.issueTokenAmount,
-            initialTokenAmounts: params.initialTokenAmounts,
-            gasAmount: params.gasAmount,
-            gasPrice: params.gasPrice
+            initialAttoAlphAmount: params?.initialAttoAlphAmount,
+            issueTokenAmount: params?.issueTokenAmount,
+            initialTokenAmounts: params?.initialTokenAmounts,
+            gasAmount: params?.gasAmount,
+            gasPrice: params?.gasPrice
         };
         return signerParams;
     }
-    async deploy(signer, params) {
-        const signerParams = await this.txParamsForDeployment(signer, params);
-        return signer.signAndSubmitDeployContractTx(signerParams);
-    }
     buildByteCodeToDeploy(initialFields) {
         return ralph.buildContractByteCode(this.bytecode, initialFields, this.fieldsSig);
     }
+    static fromApiEvents(events, addressToCodeHash, txId) {
+        return events.map((event) => {
+            const contractAddress = event.contractAddress;
+            const codeHash = addressToCodeHash.get(contractAddress);
+            if (typeof codeHash !== 'undefined' || event.eventIndex < 0) {
+                return Contract.fromApiEvent(event, codeHash, txId);
+            }
+            else {
+                throw Error(`Cannot find codeHash for the contract address: ${contractAddress}`);
+            }
+        });
+    }
+    toApiCallContract(params, groupIndex, contractAddress, methodIndex) {
+        const functionSig = this.functions[`${methodIndex}`];
+        const args = toApiVals(params.args ?? {}, functionSig.paramNames, functionSig.paramTypes);
+        return {
+            ...params,
+            group: groupIndex,
+            address: contractAddress,
+            methodIndex: methodIndex,
+            args: args
+        };
+    }
+    fromApiCallContractResult(result, txId, methodIndex) {
+        const addressToCodeHash = new Map();
+        result.contracts.forEach((contract) => addressToCodeHash.set(contract.address, contract.codeHash));
+        const functionSig = this.functions[`${methodIndex}`];
+        const returns = (0, api_1.fromApiArray)(result.returns, functionSig.returnTypes);
+        return {
+            returns: returns,
+            gasUsed: result.gasUsed,
+            contracts: result.contracts.map((state) => Contract.fromApiContractState(state)),
+            txInputs: result.txInputs,
+            txOutputs: result.txOutputs.map((output) => fromApiOutput(output)),
+            events: Contract.fromApiEvents(result.events, addressToCodeHash, txId)
+        };
+    }
 }
 exports.Contract = Contract;
+Contract.ContractCreatedEventIndex = -1;
 Contract.ContractCreatedEvent = {
     name: 'ContractCreated',
     fieldNames: ['address'],
     fieldTypes: ['Address']
 };
+Contract.ContractDestroyedEventIndex = -2;
 Contract.ContractDestroyedEvent = {
     name: 'ContractDestroyed',
     fieldNames: ['address'],
@@ -716,7 +719,7 @@ class Script extends Artifact {
     async txParamsForExecution(signer, params) {
         const signerParams = {
             signerAddress: await signer.getSelectedAddress(),
-            bytecode: this.buildByteCodeToDeploy(params.initialFields ? params.initialFields : {}),
+            bytecode: this.buildByteCodeToDeploy(params.initialFields ?? {}),
             attoAlphAmount: params.attoAlphAmount,
             tokens: params.tokens,
             gasAmount: params.gasAmount,
@@ -724,16 +727,26 @@ class Script extends Artifact {
         };
         return signerParams;
     }
-    async execute(signer, params) {
-        const signerParams = await this.txParamsForExecution(signer, params);
-        return await signer.signAndSubmitExecuteScriptTx(signerParams);
-    }
     buildByteCodeToDeploy(initialFields) {
         return ralph.buildScriptByteCode(this.bytecodeTemplate, initialFields, this.fieldsSig);
     }
 }
 exports.Script = Script;
-function fromApiFields(vals, fieldsSig) {
+function fromApiFields(immFields, mutFields, fieldsSig) {
+    const vals = [];
+    let immIndex = 0;
+    let mutIndex = 0;
+    const isMutable = fieldsSig.types.flatMap((tpe, index) => Array((0, api_1.typeLength)(tpe)).fill(fieldsSig.isMutable[`${index}`]));
+    isMutable.forEach((mutable) => {
+        if (mutable) {
+            vals.push(mutFields[`${mutIndex}`]);
+            mutIndex += 1;
+        }
+        else {
+            vals.push(immFields[`${immIndex}`]);
+            immIndex += 1;
+        }
+    });
     return (0, api_1.fromApiVals)(vals, fieldsSig.names, fieldsSig.types);
 }
 function fromApiEventFields(vals, eventSig) {
@@ -759,13 +772,23 @@ function getVal(vals, name) {
         throw Error(`No Val exists for ${name}`);
     }
 }
+function extractFields(fields, fieldsSig, mutable) {
+    const fieldIndexes = fieldsSig.names
+        .map((_, index) => index)
+        .filter((index) => fieldsSig.isMutable[`${index}`] === mutable);
+    const fieldNames = fieldIndexes.map((index) => fieldsSig.names[`${index}`]);
+    const fieldTypes = fieldIndexes.map((index) => fieldsSig.types[`${index}`]);
+    return toApiVals(fields, fieldNames, fieldTypes);
+}
 function toApiContractState(state) {
+    const stateFields = state.fields ?? {};
     return {
         address: state.address,
         bytecode: state.bytecode,
         codeHash: state.codeHash,
         initialStateHash: state.initialStateHash,
-        fields: toApiFields(state.fields, state.fieldsSig),
+        immFields: extractFields(stateFields, state.fieldsSig, false),
+        mutFields: extractFields(stateFields, state.fieldsSig, true),
         asset: toApiAsset(state.asset)
     };
 }
@@ -782,6 +805,7 @@ function toApiVals(fields, names, types) {
         return (0, api_1.toApiVal)(val, tpe);
     });
 }
+exports.toApiVals = toApiVals;
 function toApiInputAsset(inputAsset) {
     return { address: inputAsset.address, asset: toApiAsset(inputAsset.asset) };
 }
@@ -813,5 +837,70 @@ function fromApiOutput(output) {
         throw new Error(`Unknown output type: ${output}`);
     }
 }
-(0, utils_1.assertType)();
-(0, utils_1.assertType)();
+function randomTxId() {
+    const bytes = new Uint8Array(32);
+    crypto_1.webcrypto.getRandomValues(bytes);
+    return (0, utils_1.binToHex)(bytes);
+}
+exports.randomTxId = randomTxId;
+utils_1.assertType;
+class ContractFactory {
+    constructor(contract) {
+        this.contract = contract;
+    }
+    async deploy(signer, deployParams) {
+        const signerParams = await this.contract.txParamsForDeployment(signer, deployParams);
+        const result = await signer.signAndSubmitDeployContractTx(signerParams);
+        return {
+            ...result,
+            instance: this.at(result.contractAddress)
+        };
+    }
+}
+exports.ContractFactory = ContractFactory;
+function decodeFields(event, eventSig, eventIndex) {
+    if (event.eventIndex !== eventIndex) {
+        throw new Error(`Invalid event index: ${event.eventIndex}, expected: ${eventIndex}`);
+    }
+    return (0, api_1.fromApiVals)(event.fields, eventSig.fieldNames, eventSig.fieldTypes);
+}
+function decodeContractCreatedEvent(event) {
+    const fields = decodeFields(event, Contract.ContractCreatedEvent, Contract.ContractCreatedEventIndex);
+    return {
+        blockHash: event.blockHash,
+        txId: event.txId,
+        eventIndex: event.eventIndex,
+        name: Contract.ContractCreatedEvent.name,
+        fields: { address: fields['address'] }
+    };
+}
+exports.decodeContractCreatedEvent = decodeContractCreatedEvent;
+function decodeContractDestroyedEvent(event) {
+    const fields = decodeFields(event, Contract.ContractDestroyedEvent, Contract.ContractDestroyedEventIndex);
+    return {
+        blockHash: event.blockHash,
+        txId: event.txId,
+        eventIndex: event.eventIndex,
+        name: Contract.ContractDestroyedEvent.name,
+        fields: { address: fields['address'] }
+    };
+}
+exports.decodeContractDestroyedEvent = decodeContractDestroyedEvent;
+function subscribeEventsFromContract(options, address, eventIndex, decodeFunc, fromCount) {
+    const messageCallback = (event) => {
+        if (event.eventIndex !== eventIndex) {
+            return Promise.resolve();
+        }
+        return options.messageCallback(decodeFunc(event));
+    };
+    const errorCallback = (err, subscription) => {
+        return options.errorCallback(err, subscription);
+    };
+    const opt = {
+        pollingInterval: options.pollingInterval,
+        messageCallback: messageCallback,
+        errorCallback: errorCallback
+    };
+    return (0, events_1.subscribeToEvents)(opt, address, fromCount);
+}
+exports.subscribeEventsFromContract = subscribeEventsFromContract;

package/dist/src/contract/ralph.js

@@ -253,8 +253,12 @@ function buildScriptByteCode(bytecodeTemplate, fields, fieldsSig) {
     });
 }
 exports.buildScriptByteCode = buildScriptByteCode;
-function buildContractByteCode(bytecode, fields, fieldsSig) {
-    const fieldsEncoded = fieldsSig.names.flatMap((fieldName, fieldIndex) => {
+function encodeFields(fields, fieldsSig, mutable) {
+    const fieldIndexes = fieldsSig.isMutable
+        .map((_, index) => index)
+        .filter((index) => fieldsSig.isMutable[`${index}`] === mutable);
+    const fieldsEncoded = fieldIndexes.flatMap((fieldIndex) => {
+        const fieldName = fieldsSig.names[`${fieldIndex}`];
         const fieldType = fieldsSig.types[`${fieldIndex}`];
         if (fieldName in fields) {
             const fieldValue = fields[`${fieldName}`];
@@ -265,7 +269,12 @@ function buildContractByteCode(bytecode, fields, fieldsSig) {
         }
     });
     const fieldsLength = buffer_1.Buffer.from(encodeI256(BigInt(fieldsEncoded.length))).toString('hex');
-    return bytecode + fieldsLength + fieldsEncoded.map((f) => buffer_1.Buffer.from(f).toString('hex')).join('');
+    return fieldsLength + fieldsEncoded.map((f) => buffer_1.Buffer.from(f).toString('hex')).join('');
+}
+function buildContractByteCode(bytecode, fields, fieldsSig) {
+    const encodedImmFields = encodeFields(fields, fieldsSig, false);
+    const encodedMutFields = encodeFields(fields, fieldsSig, true);
+    return bytecode + encodedImmFields + encodedMutFields;
 }
 exports.buildContractByteCode = buildContractByteCode;
 var ApiValType;

package/dist/src/signer/tx-builder.js

@@ -62,7 +62,7 @@ class TransactionBuilder {
         };
         const response = await this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data);
         const contractId = __1.utils.binToHex(__1.utils.contractIdFromAddress(response.contractAddress));
-        return { ...response, contractId, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
+        return { ...response, groupIndex: response.fromGroup, contractId, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
     async buildExecuteScriptTx(params, publicKey) {
         TransactionBuilder.validatePublicKey(params, publicKey);
@@ -75,7 +75,7 @@ class TransactionBuilder {
             ...rest
         };
         const response = await this.nodeProvider.contracts.postContractsUnsignedTxExecuteScript(data);
-        return { ...response, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
+        return { ...response, groupIndex: response.fromGroup, gasPrice: (0, api_1.fromApiNumber256)(response.gasPrice) };
     }
     async buildUnsignedTx(params) {
         const data = { unsignedTx: params.unsignedTx };

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

@@ -43,8 +43,7 @@ export interface SignDeployContractTxParams {
     gasPrice?: Number256;
 }
 export interface SignDeployContractTxResult {
-    fromGroup: number;
-    toGroup: number;
+    groupIndex: number;
     unsignedTx: string;
     txId: string;
     signature: string;
@@ -62,8 +61,7 @@ export interface SignExecuteScriptTxParams {
     gasPrice?: Number256;
 }
 export interface SignExecuteScriptTxResult {
-    fromGroup: number;
-    toGroup: number;
+    groupIndex: number;
     unsignedTx: string;
     txId: string;
     signature: string;

package/dist/src/utils/utils.js

@@ -94,7 +94,9 @@ function groupOfAddress(address) {
         return groupOfP2shAddress(addressBody);
     }
     else {
-        throw new Error(`Invalid asset address type: ${addressType}`);
+        // Contract Address
+        const id = contractIdFromAddress(address);
+        return id[`${id.length - 1}`];
     }
 }
 exports.groupOfAddress = groupOfAddress;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.3.0-rc.8",
+  "version": "0.5.0-rc.0",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -27,8 +27,8 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "1.6.4",
-    "explorer_backend_version": "1.12.0-rc2"
+    "alephium_version": "1.7.0-rc1",
+    "explorer_backend_version": "1.12.0"
   },
   "scripts": {
     "build": "rm -rf dist/* && npx tsc --build . && webpack",

package/src/api/api-alephium.ts

@@ -577,7 +577,8 @@ export interface ContractState {
 
   /** @format 32-byte-hash */
   initialStateHash?: string
-  fields: Val[]
+  immFields: Val[]
+  mutFields: Val[]
   asset: AssetState
 }
 
@@ -884,7 +885,8 @@ export interface TestContract {
 
   /** @format contract */
   bytecode: string
-  initialFields?: Val[]
+  initialImmFields?: Val[]
+  initialMutFields?: Val[]
   initialAsset?: AssetState
 
   /** @format int32 */
@@ -1332,7 +1334,7 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title Alephium API
- * @version 1.6.4
+ * @version 1.7.0
  * @baseUrl ../
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {

package/src/api/types.ts

@@ -227,3 +227,11 @@ function foldVals(vals: Val[], dims: number[]): Val {
     return result
   }
 }
+
+export function typeLength(tpe: string): number {
+  if (tpe === 'U256' || tpe === 'I256' || tpe === 'Bool' || tpe === 'ByteVec' || tpe === 'Address') {
+    return 1
+  }
+  const [, dims] = decodeArrayType(tpe)
+  return dims.reduce((a, b) => a * b)
+}

package/src/constants.ts

@@ -19,3 +19,4 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 export const TOTAL_NUMBER_OF_GROUPS = 4
 export const MIN_UTXO_SET_AMOUNT = BigInt(1000000000000)
 export const ALPH_TOKEN_ID = ''.padStart(64, '0')
+export const ONE_ALPH = 10n ** 18n