@alephium/web3 0.1.0-rc.3-hc → 0.2.0-rc.1

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

@@ -129,7 +129,10 @@ export interface BrokerInfo {
     /** @format int32 */
     brokerNum: number;
     /** @format inet-socket-address */
-    address: string;
+    address: {
+        addr: string;
+        port: number;
+    };
 }
 export interface BuildDeployContractTx {
     /** @format public-key */
@@ -145,6 +148,8 @@ export interface BuildDeployContractTx {
     gasAmount?: number;
     /** @format uint256 */
     gasPrice?: string;
+    /** @format block-hash */
+    targetBlockHash?: string;
 }
 export interface BuildDeployContractTxResult {
     /** @format int32 */
@@ -173,6 +178,8 @@ export interface BuildExecuteScriptTx {
     gasAmount?: number;
     /** @format uint256 */
     gasPrice?: string;
+    /** @format block-hash */
+    targetBlockHash?: string;
 }
 export interface BuildExecuteScriptTxResult {
     /** @format int32 */
@@ -221,6 +228,8 @@ export interface BuildSweepAddressTransactions {
     gasAmount?: number;
     /** @format uint256 */
     gasPrice?: string;
+    /** @format block-hash */
+    targetBlockHash?: string;
 }
 export interface BuildSweepAddressTransactionsResult {
     unsignedTxs: SweepAddressTransaction[];
@@ -238,6 +247,8 @@ export interface BuildTransaction {
     gasAmount?: number;
     /** @format uint256 */
     gasPrice?: string;
+    /** @format block-hash */
+    targetBlockHash?: string;
 }
 export interface BuildTransactionResult {
     unsignedTx: string;
@@ -447,7 +458,10 @@ export interface InterCliquePeerInfo {
     /** @format int32 */
     groupNumPerBroker: number;
     /** @format inet-socket-address */
-    address: string;
+    address: {
+        addr: string;
+        port: number;
+    };
     isSynced: boolean;
     clientVersion: string;
 }
@@ -468,7 +482,10 @@ export interface NodeInfo {
     buildInfo: BuildInfo;
     upnp: boolean;
     /** @format inet-socket-address */
-    externalAddress?: string;
+    externalAddress?: {
+        addr: string;
+        port: number;
+    };
 }
 export interface NodeVersion {
     version: ReleaseVersion;
@@ -571,6 +588,8 @@ export interface Sweep {
     gasPrice?: string;
     /** @format int32 */
     utxosLimit?: number;
+    /** @format block-hash */
+    targetBlockHash?: string;
 }
 export interface SweepAddressTransaction {
     /** @format 32-byte-hash */
@@ -836,8 +855,8 @@ export declare class HttpClient<SecurityDataType = unknown> {
 }
 /**
  * @title Alephium API
- * @version 1.4.1
- * @baseUrl {protocol}://{host}:{port}
+ * @version 1.5.0
+ * @baseUrl ../
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
     wallets: {

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

@@ -28,7 +28,7 @@ var ContentType;
 })(ContentType = exports.ContentType || (exports.ContentType = {}));
 class HttpClient {
     constructor(apiConfig = {}) {
-        this.baseUrl = '{protocol}://{host}:{port}';
+        this.baseUrl = '../';
         this.securityData = null;
         this.abortControllers = new Map();
         this.customFetch = (...fetchParams) => fetch(...fetchParams);
@@ -158,8 +158,8 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 1.4.1
- * @baseUrl {protocol}://{host}:{port}
+ * @version 1.5.0
+ * @baseUrl ../
  */
 class Api extends HttpClient {
     constructor() {

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

@@ -470,6 +470,22 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @request PUT:/utils/sanity-check
          */
         putUtilsSanityCheck: (params?: RequestParams) => Promise<void>;
+        /**
+         * @description Update global log level, accepted: TRACE, DEBUG, INFO, WARN, ERROR
+         *
+         * @tags Utils
+         * @name PutUtilsUpdateGlobalLoglevel
+         * @request PUT:/utils/update-global-loglevel
+         */
+        putUtilsUpdateGlobalLoglevel: (data: 'TRACE' | 'DEBUG' | 'INFO' | 'WARN' | 'ERROR', params?: RequestParams) => Promise<void>;
+        /**
+         * @description Update logging file, only logback.xml is accepted
+         *
+         * @tags Utils
+         * @name PutUtilsUpdateLogConfig
+         * @request PUT:/utils/update-log-config
+         */
+        putUtilsUpdateLogConfig: (data: string, params?: RequestParams) => Promise<void>;
     };
 }
 export {};

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

@@ -450,6 +450,32 @@ class Api extends HttpClient {
                 path: `/utils/sanity-check`,
                 method: 'PUT',
                 ...params
+            }).then(convertHttpResponse),
+            /**
+             * @description Update global log level, accepted: TRACE, DEBUG, INFO, WARN, ERROR
+             *
+             * @tags Utils
+             * @name PutUtilsUpdateGlobalLoglevel
+             * @request PUT:/utils/update-global-loglevel
+             */
+            putUtilsUpdateGlobalLoglevel: (data, params = {}) => this.request({
+                path: `/utils/update-global-loglevel`,
+                method: 'PUT',
+                body: data,
+                ...params
+            }).then(convertHttpResponse),
+            /**
+             * @description Update logging file, only logback.xml is accepted
+             *
+             * @tags Utils
+             * @name PutUtilsUpdateLogConfig
+             * @request PUT:/utils/update-log-config
+             */
+            putUtilsUpdateLogConfig: (data, params = {}) => this.request({
+                path: `/utils/update-log-config`,
+                method: 'PUT',
+                body: data,
+                ...params
             }).then(convertHttpResponse)
         };
     }

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

@@ -1,6 +1,13 @@
 import { NodeProvider } from '../api';
 import { node } from '../api';
 import { SignDeployContractTxParams, SignExecuteScriptTxParams, SignerWithNodeProvider } from '../signer';
+declare class SourceFile {
+    readonly dirs: string[];
+    readonly dirPath: string;
+    readonly contractPath: string;
+    readonly artifactPath: string;
+    constructor(dirs: string[], fileName: string);
+}
 export declare abstract class Common {
     readonly sourceCodeSha256: string;
     readonly functions: node.FunctionSig[];
@@ -13,16 +20,15 @@ export declare abstract class Common {
     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 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, 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>;
+    }>(provider: NodeProvider, sourceFile: SourceFile, loadContractStr: (sourceFile: SourceFile, importsCache: string[]) => Promise<string>, compile: (provider: NodeProvider, sourceFile: SourceFile, contractStr: string, contractHash: string) => Promise<T>): Promise<T>;
+    protected _saveToFile(sourceFile: SourceFile): Promise<void>;
     abstract buildByteCodeToDeploy(initialFields?: Fields): string;
 }
 export declare class Contract extends Common {
@@ -33,10 +39,11 @@ export declare class Contract extends Common {
     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>;
+    static fromSource(provider: NodeProvider, path: string): Promise<Contract>;
     private static compile;
     static fromJson(artifact: any): Contract;
-    static fromArtifactFile(fileName: string): Promise<Contract>;
+    static fromArtifactFile(path: string): Promise<Contract>;
+    fetchState(provider: NodeProvider, address: string, group: number): Promise<ContractState>;
     toString(): string;
     toState(fields: Fields, asset: Asset, address?: string): ContractState;
     static randomAddress(): string;
@@ -65,10 +72,10 @@ export declare class Script extends Common {
     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>;
+    static fromSource(provider: NodeProvider, path: string): Promise<Script>;
     private static compile;
     static fromJson(artifact: any): Script;
-    static fromArtifactFile(fileName: string): Promise<Script>;
+    static fromArtifactFile(path: string): Promise<Script>;
     toString(): string;
     paramsForDeployment(params: BuildExecuteScriptTx): Promise<SignExecuteScriptTxParams>;
     transactionForDeployment(signer: SignerWithNodeProvider, params: Omit<BuildExecuteScriptTx, 'signerAddress'>): Promise<BuildScriptTxResult>;
@@ -180,3 +187,4 @@ export interface BuildScriptTxResult {
     unsignedTx: string;
     txId: string;
 }
+export {};

package/dist/src/contract/contract.js

@@ -47,6 +47,20 @@ const fs_1 = __importDefault(require("fs"));
 const fs_2 = require("fs");
 const ralph = __importStar(require("./ralph"));
 const utils_1 = require("../utils");
+class SourceFile {
+    constructor(dirs, fileName) {
+        this.dirs = dirs;
+        this.dirPath = dirs.length === 0 ? '' : dirs.join('/') + '/';
+        if (fileName.endsWith('.json')) {
+            this.contractPath = './contracts/' + this.dirPath + fileName.slice(0, -5);
+            this.artifactPath = './artifacts/' + this.dirPath + fileName;
+        }
+        else {
+            this.contractPath = './contracts/' + this.dirPath + fileName;
+            this.artifactPath = './artifacts/' + this.dirPath + fileName + '.json';
+        }
+    }
+}
 class Common {
     constructor(sourceCodeSha256, functions) {
         this.sourceCodeSha256 = sourceCodeSha256;
@@ -64,73 +78,86 @@ class Common {
             this._artifactCache.set(contract.codeHash, contract);
         }
     }
-    static _contractPath(fileName) {
-        if (fileName.endsWith('.json')) {
-            return `./contracts/${fileName.slice(0, -5)}`;
-        }
-        else {
-            return `./contracts/${fileName}`;
-        }
-    }
-    static _artifactPath(fileName) {
-        if (fileName.endsWith('.json')) {
-            return `./artifacts/${fileName}`;
-        }
-        else {
-            return `./artifacts/${fileName}.json`;
-        }
-    }
     static _artifactsFolder() {
         return './artifacts/';
     }
-    static async _handleImports(contractStr, importsCache) {
+    static getSourceFile(path, _dirs) {
+        const parts = path.split('/');
+        const dirs = Array.from(_dirs);
+        if (parts.length === 1) {
+            return new SourceFile(dirs, path);
+        }
+        parts.slice(0, parts.length - 1).forEach((part) => {
+            switch (part) {
+                case '.': {
+                    break;
+                }
+                case '..': {
+                    if (dirs.length === 0) {
+                        throw new Error('Invalid file path: ' + path);
+                    }
+                    dirs.pop();
+                    break;
+                }
+                default: {
+                    dirs.push(part);
+                }
+            }
+        });
+        return new SourceFile(dirs, parts[parts.length - 1]);
+    }
+    static async _handleImports(pathes, contractStr, importsCache) {
         const localImportsCache = [];
         let result = contractStr.replace(Common.importRegex, (match) => {
             localImportsCache.push(match);
             return '';
         });
         for (const myImport of localImportsCache) {
-            const fileName = myImport.slice(8, -1);
-            if (!importsCache.includes(fileName)) {
-                importsCache.push(fileName);
-                const importContractStr = await Common._loadContractStr(fileName, importsCache, (code) => Contract.checkCodeType(fileName, code));
+            const relativePath = myImport.slice(8, -1);
+            const importSourceFile = this.getSourceFile(relativePath, pathes);
+            if (!importsCache.includes(importSourceFile.contractPath)) {
+                importsCache.push(importSourceFile.contractPath);
+                const importContractStr = await Common._loadContractStr(importSourceFile, importsCache, (code) => Contract.checkCodeType(importSourceFile.contractPath, code));
                 result = result.concat('\n', importContractStr);
             }
         }
         return result;
     }
-    static async _loadContractStr(fileName, importsCache, validate) {
-        const contractPath = this._contractPath(fileName);
+    static async _loadContractStr(sourceFile, importsCache, validate) {
+        const contractPath = sourceFile.contractPath;
         const contractBuffer = await fs_2.promises.readFile(contractPath);
         const contractStr = contractBuffer.toString();
         validate(contractStr);
-        return Common._handleImports(contractStr, importsCache);
+        return Common._handleImports(sourceFile.dirs, contractStr, importsCache);
     }
     static checkFileNameExtension(fileName) {
         if (!fileName.endsWith('.ral')) {
             throw new Error('Smart contract file name should end with ".ral"');
         }
     }
-    static async _from(provider, fileName, loadContractStr, compile) {
-        Common.checkFileNameExtension(fileName);
-        const contractStr = await loadContractStr(fileName, []);
+    static async _from(provider, sourceFile, loadContractStr, compile) {
+        Common.checkFileNameExtension(sourceFile.contractPath);
+        const contractStr = await loadContractStr(sourceFile, []);
         const contractHash = cryptojs.SHA256(contractStr).toString();
         const existingContract = this._getArtifactFromCache(contractHash);
         if (typeof existingContract !== 'undefined') {
             return existingContract;
         }
         else {
-            return compile(provider, fileName, contractStr, contractHash);
+            return compile(provider, sourceFile, contractStr, contractHash);
         }
     }
-    _saveToFile(fileName) {
-        const artifactPath = Common._artifactPath(fileName);
-        return fs_2.promises.writeFile(artifactPath, this.toString());
+    _saveToFile(sourceFile) {
+        const folder = Common._artifactsFolder() + sourceFile.dirPath;
+        if (!fs_1.default.existsSync(folder)) {
+            fs_1.default.mkdirSync(folder, { recursive: true });
+        }
+        return fs_2.promises.writeFile(sourceFile.artifactPath, this.toString());
     }
 }
 exports.Common = Common;
-Common.importRegex = new RegExp('^import "[a-z][a-z_0-9]*.ral"', 'mg');
-Common.contractRegex = new RegExp('^TxContract [A-Z][a-zA-Z0-9]*', 'mg');
+Common.importRegex = new RegExp('^import "([^"/]+/(([^"]+)/)?)?[a-z][a-z_0-9]*.ral"', 'mg');
+Common.contractRegex = new RegExp('^(Abstract[ ]+)?Contract [A-Z][a-zA-Z0-9]*', 'mg');
 Common.interfaceRegex = new RegExp('^Interface [A-Z][a-zA-Z0-9]* \\{', 'mg');
 Common.scriptRegex = new RegExp('^TxScript [A-Z][a-zA-Z0-9]*', 'mg');
 Common._artifactCache = new Map();
@@ -145,35 +172,40 @@ class Contract extends Common {
     }
     static checkCodeType(fileName, contractStr) {
         const interfaceMatches = contractStr.match(Contract.interfaceRegex);
-        if (interfaceMatches) {
-            return;
-        }
         const contractMatches = contractStr.match(Contract.contractRegex);
-        if (contractMatches === null) {
+        if (interfaceMatches === null && contractMatches === null) {
             throw new Error(`No contract found in: ${fileName}`);
         }
-        else if (contractMatches.length > 1) {
-            throw new Error(`Multiple contracts in: ${fileName}`);
+        if (interfaceMatches && contractMatches) {
+            throw new Error(`Multiple contracts and interfaces in: ${fileName}`);
         }
-        else {
-            return;
+        if (interfaceMatches === null) {
+            if (contractMatches !== null && contractMatches.length > 1) {
+                throw new Error(`Multiple contracts in: ${fileName}`);
+            }
+        }
+        if (contractMatches === null) {
+            if (interfaceMatches !== null && interfaceMatches.length > 1) {
+                throw new Error(`Multiple interfaces in: ${fileName}`);
+            }
         }
     }
-    static async loadContractStr(fileName, importsCache) {
-        return Common._loadContractStr(fileName, importsCache, (code) => Contract.checkCodeType(fileName, code));
+    static async loadContractStr(sourceFile) {
+        return Common._loadContractStr(sourceFile, [], (code) => Contract.checkCodeType(sourceFile.contractPath, code));
     }
-    static async fromSource(provider, fileName) {
+    static async fromSource(provider, path) {
         if (!fs_1.default.existsSync(Common._artifactsFolder())) {
             fs_1.default.mkdirSync(Common._artifactsFolder(), { recursive: true });
         }
-        const contract = await Common._from(provider, fileName, (fileName, importCaches) => Contract.loadContractStr(fileName, importCaches), Contract.compile);
+        const sourceFile = this.getSourceFile(path, []);
+        const contract = await Common._from(provider, sourceFile, (sourceFile) => Contract.loadContractStr(sourceFile), Contract.compile);
         this._putArtifactToCache(contract);
         return contract;
     }
-    static async compile(provider, fileName, contractStr, contractHash) {
+    static async compile(provider, sourceFile, contractStr, contractHash) {
         const compiled = await provider.contracts.postContractsCompileContract({ code: contractStr });
         const artifact = new Contract(contractHash, compiled.bytecode, compiled.codeHash, compiled.fields, compiled.events, compiled.functions);
-        await artifact._saveToFile(fileName);
+        await artifact._saveToFile(sourceFile);
         return artifact;
     }
     // TODO: safely parse json
@@ -191,12 +223,17 @@ class Contract extends Common {
         return contract;
     }
     // support both 'code.ral' and 'code.ral.json'
-    static async fromArtifactFile(fileName) {
-        const artifactPath = Contract._artifactPath(fileName);
+    static async fromArtifactFile(path) {
+        const sourceFile = this.getSourceFile(path, []);
+        const artifactPath = sourceFile.artifactPath;
         const content = await fs_2.promises.readFile(artifactPath);
         const artifact = JSON.parse(content.toString());
         return Contract.fromJson(artifact);
     }
+    async fetchState(provider, address, group) {
+        const state = await provider.contracts.getContractsAddressState(address, { group: group });
+        return this.fromApiContractState(state);
+    }
     toString() {
         return JSON.stringify({
             sourceCodeSha256: this.sourceCodeSha256,
@@ -415,16 +452,17 @@ class Script extends Common {
             return;
         }
     }
-    static async loadContractStr(fileName, importsCache) {
-        return Common._loadContractStr(fileName, importsCache, (code) => Script.checkCodeType(fileName, code));
+    static async loadContractStr(sourceFile) {
+        return Common._loadContractStr(sourceFile, [], (code) => Script.checkCodeType(sourceFile.contractPath, code));
     }
-    static async fromSource(provider, fileName) {
-        return Common._from(provider, fileName, (fileName, importsCache) => Script.loadContractStr(fileName, importsCache), Script.compile);
+    static async fromSource(provider, path) {
+        const sourceFile = this.getSourceFile(path, []);
+        return Common._from(provider, sourceFile, (sourceFile) => Script.loadContractStr(sourceFile), Script.compile);
     }
-    static async compile(provider, fileName, scriptStr, contractHash) {
+    static async compile(provider, sourceFile, scriptStr, contractHash) {
         const compiled = await provider.contracts.postContractsCompileScript({ code: scriptStr });
         const artifact = new Script(contractHash, compiled.bytecodeTemplate, compiled.fields, compiled.functions);
-        await artifact._saveToFile(fileName);
+        await artifact._saveToFile(sourceFile);
         return artifact;
     }
     // TODO: safely parse json
@@ -437,8 +475,9 @@ class Script extends Common {
         }
         return new Script(artifact.sourceCodeSha256, artifact.bytecodeTemplate, artifact.fieldsSig, artifact.functions);
     }
-    static async fromArtifactFile(fileName) {
-        const artifactPath = Common._artifactPath(fileName);
+    static async fromArtifactFile(path) {
+        const sourceFile = this.getSourceFile(path, []);
+        const artifactPath = sourceFile.artifactPath;
         const content = await fs_2.promises.readFile(artifactPath);
         const artifact = JSON.parse(content.toString());
         return this.fromJson(artifact);

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

@@ -20,6 +20,8 @@ export declare function addressFromContractId(contractId: string): string;
 export declare function contractIdFromTx(txId: string, outputIndex: number): string;
 export declare function subContractId(parentContractId: string, pathInHex: string): string;
 export declare function stringToHex(str: string): string;
+export declare function hexToString(str: any): string;
+export declare function timeout(ms: number): Promise<unknown>;
 declare type _Eq<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
 export declare type Eq<X, Y> = _Eq<{
     [P in keyof X]: X[P];

package/dist/src/utils/utils.js

@@ -20,7 +20,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertType = exports.stringToHex = exports.subContractId = exports.contractIdFromTx = exports.addressFromContractId = exports.addressFromPublicKey = exports.publicKeyFromPrivateKey = exports.binToHex = exports.hexToBinUnsafe = exports.tokenIdFromAddress = exports.contractIdFromAddress = exports.groupOfAddress = exports.isHexString = exports.signatureDecode = exports.signatureEncode = exports.convertHttpResponse = void 0;
+exports.assertType = exports.timeout = exports.hexToString = exports.stringToHex = exports.subContractId = exports.contractIdFromTx = exports.addressFromContractId = exports.addressFromPublicKey = exports.publicKeyFromPrivateKey = exports.binToHex = exports.hexToBinUnsafe = exports.tokenIdFromAddress = exports.contractIdFromAddress = exports.groupOfAddress = exports.isHexString = exports.signatureDecode = exports.signatureEncode = exports.convertHttpResponse = void 0;
 const elliptic_1 = require("elliptic");
 const bn_js_1 = __importDefault(require("bn.js"));
 const blakejs_1 = __importDefault(require("blakejs"));
@@ -182,7 +182,7 @@ function contractIdFromTx(txId, outputIndex) {
 }
 exports.contractIdFromTx = contractIdFromTx;
 function subContractId(parentContractId, pathInHex) {
-    const data = buffer_1.Buffer.concat([hexToBinUnsafe(pathInHex), hexToBinUnsafe(parentContractId)]);
+    const data = buffer_1.Buffer.concat([hexToBinUnsafe(parentContractId), hexToBinUnsafe(pathInHex)]);
     return binToHex(blakejs_1.default.blake2b(blakejs_1.default.blake2b(data, undefined, 32), undefined, 32));
 }
 exports.subContractId = subContractId;
@@ -194,6 +194,14 @@ function stringToHex(str) {
     return hex;
 }
 exports.stringToHex = stringToHex;
+function hexToString(str) {
+    return buffer_1.Buffer.from(str.toString(), 'hex').toString();
+}
+exports.hexToString = hexToString;
+function timeout(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+exports.timeout = timeout;
 // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars
 function assertType() { }
 exports.assertType = assertType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.1.0-rc.3-hc",
+  "version": "0.2.0-rc.1",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -27,14 +27,14 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "token-balance",
-    "explorer_backend_version": "1.7.0"
+    "alephium_version": "1.5.0-rc2",
+    "explorer_backend_version": "1.7.1"
   },
   "scripts": {
     "build": "rm -rf dist/* && npx tsc --build . && webpack",
     "bundle": "webpack",
     "update-schemas": "npm run update-schema:alephium && npm run update-schema:explorer",
-    "update-schema:alephium": "npx swagger-typescript-api -t ./configs -o ./src/api -n api-alephium.ts -p https://raw.githubusercontent.com/alephium/alephium/${npm_package_config_alephium_version}/api/src/main/resources/openapi.json",
+    "update-schema:alephium": "npx swagger-typescript-api -t ./configs -o ./src/api -n api-alephium.ts -p https://raw.githubusercontent.com/alephium/alephium/v${npm_package_config_alephium_version}/api/src/main/resources/openapi.json",
     "update-schema:explorer": "npx swagger-typescript-api -t ./configs -o ./src/api -n api-explorer.ts -p https://raw.githubusercontent.com/alephium/explorer-backend/v${npm_package_config_explorer_backend_version}/app/src/main/resources/explorer-backend-openapi.json",
     "check-versions": "node scripts/check-versions.js ${npm_package_config_alephium_version} ${npm_package_config_explorer_backend_version}",
     "dev": "tsnd --respawn lib/index.ts",

package/src/api/api-alephium.ts

@@ -185,7 +185,7 @@ export interface BrokerInfo {
   brokerNum: number
 
   /** @format inet-socket-address */
-  address: string
+  address: { addr: string; port: number }
 }
 
 export interface BuildDeployContractTx {
@@ -207,6 +207,9 @@ export interface BuildDeployContractTx {
 
   /** @format uint256 */
   gasPrice?: string
+
+  /** @format block-hash */
+  targetBlockHash?: string
 }
 
 export interface BuildDeployContractTxResult {
@@ -246,6 +249,9 @@ export interface BuildExecuteScriptTx {
 
   /** @format uint256 */
   gasPrice?: string
+
+  /** @format block-hash */
+  targetBlockHash?: string
 }
 
 export interface BuildExecuteScriptTxResult {
@@ -311,6 +317,9 @@ export interface BuildSweepAddressTransactions {
 
   /** @format uint256 */
   gasPrice?: string
+
+  /** @format block-hash */
+  targetBlockHash?: string
 }
 
 export interface BuildSweepAddressTransactionsResult {
@@ -334,6 +343,9 @@ export interface BuildTransaction {
 
   /** @format uint256 */
   gasPrice?: string
+
+  /** @format block-hash */
+  targetBlockHash?: string
 }
 
 export interface BuildTransactionResult {
@@ -613,7 +625,7 @@ export interface InterCliquePeerInfo {
   groupNumPerBroker: number
 
   /** @format inet-socket-address */
-  address: string
+  address: { addr: string; port: number }
   isSynced: boolean
   clientVersion: string
 }
@@ -641,7 +653,7 @@ export interface NodeInfo {
   upnp: boolean
 
   /** @format inet-socket-address */
-  externalAddress?: string
+  externalAddress?: { addr: string; port: number }
 }
 
 export interface NodeVersion {
@@ -778,6 +790,9 @@ export interface Sweep {
 
   /** @format int32 */
   utxosLimit?: number
+
+  /** @format block-hash */
+  targetBlockHash?: string
 }
 
 export interface SweepAddressTransaction {
@@ -1099,7 +1114,7 @@ export enum ContentType {
 }
 
 export class HttpClient<SecurityDataType = unknown> {
-  public baseUrl: string = '{protocol}://{host}:{port}'
+  public baseUrl: string = '../'
   private securityData: SecurityDataType | null = null
   private securityWorker?: ApiConfig<SecurityDataType>['securityWorker']
   private abortControllers = new Map<CancelToken, AbortController>()
@@ -1264,8 +1279,8 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title Alephium API
- * @version 1.4.1
- * @baseUrl {protocol}://{host}:{port}
+ * @version 1.5.0
+ * @baseUrl ../
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
   wallets = {