@alephium/web3 0.30.2 → 0.31.0

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

@@ -655,6 +655,10 @@ export interface Reachable {
     peers: string[];
     type: string;
 }
+export interface Result {
+    /** @format bigint */
+    hashrate: string;
+}
 export interface RevealMnemonic {
     password: string;
 }
@@ -732,6 +736,10 @@ export interface SweepAddressTransaction {
     /** @format uint256 */
     gasPrice: string;
 }
+export interface TargetToHashrate {
+    /** @format hex-string */
+    target: string;
+}
 export interface TestContract {
     /** @format int32 */
     group?: number;
@@ -987,7 +995,7 @@ export declare class HttpClient<SecurityDataType = unknown> {
 }
 /**
  * @title Alephium API
- * @version 2.8.4
+ * @version 2.8.5
  * @baseUrl ../
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
@@ -1617,10 +1625,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Get contract state
          * @request GET:/contracts/{address}/state
          */
-        getContractsAddressState: (address: string, query: {
-            /** @format int32 */
-            group: number;
-        }, params?: RequestParams) => Promise<ContractState>;
+        getContractsAddressState: (address: string, params?: RequestParams) => Promise<ContractState>;
         /**
          * No description
          *
@@ -1687,26 +1692,6 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          */
         postMultisigSubmit: (data: SubmitMultisig, params?: RequestParams) => Promise<SubmitTxResult>;
     };
-    utils: {
-        /**
-         * No description
-         *
-         * @tags Utils
-         * @name PostUtilsVerifySignature
-         * @summary Verify the SecP256K1 signature of some data
-         * @request POST:/utils/verify-signature
-         */
-        postUtilsVerifySignature: (data: VerifySignature, params?: RequestParams) => Promise<boolean>;
-        /**
-         * No description
-         *
-         * @tags Utils
-         * @name PutUtilsCheckHashIndexing
-         * @summary Check and repair the indexing of block hashes
-         * @request PUT:/utils/check-hash-indexing
-         */
-        putUtilsCheckHashIndexing: (params?: RequestParams) => Promise<void>;
-    };
     miners: {
         /**
          * No description
@@ -1803,5 +1788,34 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
             group?: number;
         }, params?: RequestParams) => Promise<ContractEventsByBlockHash>;
     };
+    utils: {
+        /**
+         * No description
+         *
+         * @tags Utils
+         * @name PostUtilsVerifySignature
+         * @summary Verify the SecP256K1 signature of some data
+         * @request POST:/utils/verify-signature
+         */
+        postUtilsVerifySignature: (data: VerifySignature, params?: RequestParams) => Promise<boolean>;
+        /**
+         * No description
+         *
+         * @tags Utils
+         * @name PostUtilsTargetToHashrate
+         * @summary Convert a target to hashrate
+         * @request POST:/utils/target-to-hashrate
+         */
+        postUtilsTargetToHashrate: (data: TargetToHashrate, params?: RequestParams) => Promise<Result>;
+        /**
+         * No description
+         *
+         * @tags Utils
+         * @name PutUtilsCheckHashIndexing
+         * @summary Check and repair the indexing of block hashes
+         * @request PUT:/utils/check-hash-indexing
+         */
+        putUtilsCheckHashIndexing: (params?: RequestParams) => Promise<void>;
+    };
 }
 export {};

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

@@ -151,7 +151,7 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 2.8.4
+ * @version 2.8.5
  * @baseUrl ../
  */
 class Api extends HttpClient {
@@ -1051,10 +1051,9 @@ class Api extends HttpClient {
              * @summary Get contract state
              * @request GET:/contracts/{address}/state
              */
-            getContractsAddressState: (address, query, params = {}) => this.request({
+            getContractsAddressState: (address, params = {}) => this.request({
                 path: `/contracts/${address}/state`,
                 method: 'GET',
-                query: query,
                 format: 'json',
                 ...params
             }).then(utils_1.convertHttpResponse),
@@ -1173,37 +1172,6 @@ class Api extends HttpClient {
                 ...params
             }).then(utils_1.convertHttpResponse)
         };
-        this.utils = {
-            /**
-             * No description
-             *
-             * @tags Utils
-             * @name PostUtilsVerifySignature
-             * @summary Verify the SecP256K1 signature of some data
-             * @request POST:/utils/verify-signature
-             */
-            postUtilsVerifySignature: (data, params = {}) => this.request({
-                path: `/utils/verify-signature`,
-                method: 'POST',
-                body: data,
-                type: ContentType.Json,
-                format: 'json',
-                ...params
-            }).then(utils_1.convertHttpResponse),
-            /**
-             * No description
-             *
-             * @tags Utils
-             * @name PutUtilsCheckHashIndexing
-             * @summary Check and repair the indexing of block hashes
-             * @request PUT:/utils/check-hash-indexing
-             */
-            putUtilsCheckHashIndexing: (params = {}) => this.request({
-                path: `/utils/check-hash-indexing`,
-                method: 'PUT',
-                ...params
-            }).then(utils_1.convertHttpResponse)
-        };
         this.miners = {
             /**
              * No description
@@ -1326,6 +1294,53 @@ class Api extends HttpClient {
                 ...params
             }).then(utils_1.convertHttpResponse)
         };
+        this.utils = {
+            /**
+             * No description
+             *
+             * @tags Utils
+             * @name PostUtilsVerifySignature
+             * @summary Verify the SecP256K1 signature of some data
+             * @request POST:/utils/verify-signature
+             */
+            postUtilsVerifySignature: (data, params = {}) => this.request({
+                path: `/utils/verify-signature`,
+                method: 'POST',
+                body: data,
+                type: ContentType.Json,
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
+            /**
+             * No description
+             *
+             * @tags Utils
+             * @name PostUtilsTargetToHashrate
+             * @summary Convert a target to hashrate
+             * @request POST:/utils/target-to-hashrate
+             */
+            postUtilsTargetToHashrate: (data, params = {}) => this.request({
+                path: `/utils/target-to-hashrate`,
+                method: 'POST',
+                body: data,
+                type: ContentType.Json,
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse),
+            /**
+             * No description
+             *
+             * @tags Utils
+             * @name PutUtilsCheckHashIndexing
+             * @summary Check and repair the indexing of block hashes
+             * @request PUT:/utils/check-hash-indexing
+             */
+            putUtilsCheckHashIndexing: (params = {}) => this.request({
+                path: `/utils/check-hash-indexing`,
+                method: 'PUT',
+                ...params
+            }).then(utils_1.convertHttpResponse)
+        };
     }
 }
 exports.Api = Api;

package/dist/src/api/node-provider.js

@@ -134,8 +134,7 @@ class NodeProvider {
         };
         this.guessStdInterfaceId = async (tokenId) => {
             const address = (0, utils_1.addressFromTokenId)(tokenId);
-            const group = (0, utils_1.groupOfAddress)(address);
-            const rawState = await this.contracts.getContractsAddressState((0, utils_1.addressFromTokenId)(tokenId), { group });
+            const rawState = await this.contracts.getContractsAddressState(address);
             const lastImmField = rawState.immFields.slice(-1).pop()?.value;
             const interfaceIdPrefix = '414c5048'; // the hex of 'ALPH'
             if (typeof lastImmField === 'string' && lastImmField.startsWith(interfaceIdPrefix)) {

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

@@ -84,6 +84,7 @@ export declare class Project {
     static script(name: string): Script;
     private saveArtifactsToFile;
     contractByCodeHash(codeHash: string): Contract;
+    private static getCompileResult;
     private static compile;
     private static loadArtifacts;
     private static getImportSourcePath;

package/dist/src/contract/contract.js

@@ -55,6 +55,7 @@ const path = __importStar(require("path"));
 const events_1 = require("./events");
 const constants_1 = require("../constants");
 const blake = __importStar(require("blakejs"));
+const error_1 = require("../utils/error");
 const crypto = new utils_1.WebCrypto();
 exports.StdIdFieldName = '__stdInterfaceId';
 var SourceKind;
@@ -125,6 +126,19 @@ class Compiled {
         this.warnings = warnings;
     }
 }
+function findSourceInfoAtLineNumber(sources, line) {
+    let currentLine = 0;
+    const sourceInfosWithLine = sources.map((source) => {
+        const startIndex = currentLine + 1;
+        currentLine += source.sourceCode.split('\n').length;
+        const endIndex = currentLine;
+        return { sourceInfo: source, startIndex: startIndex, endIndex: endIndex };
+    });
+    const sourceInfo = sourceInfosWithLine.find((sourceInfoWithLine) => {
+        return line >= sourceInfoWithLine.startIndex && line <= sourceInfoWithLine.endIndex;
+    });
+    return sourceInfo;
+}
 class ProjectArtifact {
     static checkCompilerOptionsParameter(compilerOptions) {
         if (Object.keys(compilerOptions).length != Object.keys(exports.DEFAULT_NODE_COMPILER_OPTIONS).length) {
@@ -302,6 +316,31 @@ class Project {
         }
         return contract.artifact;
     }
+    static async getCompileResult(provider, compilerOptions, sources) {
+        try {
+            const sourceStr = sources.map((f) => f.sourceCode).join('\n');
+            return await provider.contracts.postContractsCompileProject({
+                code: sourceStr,
+                compilerOptions: compilerOptions
+            });
+        }
+        catch (error) {
+            if (!(error instanceof Error)) {
+                throw error;
+            }
+            const parsed = (0, error_1.parseError)(error.message);
+            if (!parsed) {
+                throw error;
+            }
+            const sourceInfo = findSourceInfoAtLineNumber(sources, parsed.lineStart);
+            if (!sourceInfo) {
+                throw error;
+            }
+            const shiftIndex = parsed.lineStart - sourceInfo.startIndex + 1;
+            const newError = parsed.reformat(shiftIndex, sourceInfo.sourceInfo.contractRelativePath);
+            throw new Error(newError);
+        }
+    }
     static async compile(fullNodeVersion, provider, sourceInfos, projectRootDir, contractsRootDir, artifactsRootDir, errorOnWarnings, compilerOptions) {
         const removeDuplicates = sourceInfos.reduce((acc, sourceInfo) => {
             if (acc.find((info) => info.sourceCodeHash === sourceInfo.sourceCodeHash) === undefined) {
@@ -309,11 +348,7 @@ class Project {
             }
             return acc;
         }, []);
-        const sourceStr = removeDuplicates.map((f) => f.sourceCode).join('\n');
-        const result = await provider.contracts.postContractsCompileProject({
-            code: sourceStr,
-            compilerOptions: compilerOptions
-        });
+        const result = await Project.getCompileResult(provider, compilerOptions, removeDuplicates);
         const contracts = new Map();
         const scripts = new Map();
         result.contracts.forEach((contractResult) => {
@@ -996,6 +1031,7 @@ exports.ExecutableScript = ExecutableScript;
 function specialContractAddress(n) {
     const bytes = new Uint8Array(32).fill(0);
     bytes[31] = n;
+    console.log(utils_1.addressFromContractId);
     return (0, utils_1.addressFromContractId)((0, utils_1.binToHex)(bytes));
 }
 exports.CreateContractEventAddress = specialContractAddress(-1);
@@ -1087,9 +1123,7 @@ class ContractInstance {
 }
 exports.ContractInstance = ContractInstance;
 async function fetchContractState(contract, instance) {
-    const contractState = await (0, global_1.getCurrentNodeProvider)().contracts.getContractsAddressState(instance.address, {
-        group: instance.groupIndex
-    });
+    const contractState = await (0, global_1.getCurrentNodeProvider)().contracts.getContractsAddressState(instance.address);
     const state = contract.contract.fromApiContractState(contractState);
     return {
         ...state,

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

@@ -1 +1,20 @@
-export declare function addressToGroup(address: string, totalNumberOfGroups: number): number;
+import { KeyType } from '../signer';
+export declare enum AddressType {
+    P2PKH = 0,
+    P2MPKH = 1,
+    P2SH = 2,
+    P2C = 3
+}
+export declare function validateAddress(address: string): void;
+export declare function groupOfAddress(address: string): number;
+export declare function contractIdFromAddress(address: string): Uint8Array;
+export declare function tokenIdFromAddress(address: string): Uint8Array;
+export declare function groupOfPrivateKey(privateKey: string, keyType?: KeyType): number;
+export declare function publicKeyFromPrivateKey(privateKey: string, _keyType?: KeyType): string;
+export declare function addressFromPublicKey(publicKey: string, _keyType?: KeyType): string;
+export declare function addressFromScript(script: Uint8Array): string;
+export declare function addressFromContractId(contractId: string): string;
+export declare function addressFromTokenId(tokenId: string): string;
+export declare function contractIdFromTx(txId: string, outputIndex: number): string;
+export declare function subContractId(parentContractId: string, pathInHex: string, group: number): string;
+export declare function xorByte(intValue: number): number;

package/dist/src/utils/address.js

@@ -20,23 +20,177 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addressToGroup = void 0;
+exports.xorByte = exports.subContractId = exports.contractIdFromTx = exports.addressFromTokenId = exports.addressFromContractId = exports.addressFromScript = exports.addressFromPublicKey = exports.publicKeyFromPrivateKey = exports.groupOfPrivateKey = exports.tokenIdFromAddress = exports.contractIdFromAddress = exports.groupOfAddress = exports.validateAddress = exports.AddressType = void 0;
+const elliptic_1 = require("elliptic");
+const bn_js_1 = __importDefault(require("bn.js"));
+const constants_1 = require("../constants");
+const blakejs_1 = __importDefault(require("blakejs"));
 const bs58_1 = __importDefault(require("./bs58"));
 const djb2_1 = __importDefault(require("./djb2"));
-function addressToGroup(address, totalNumberOfGroups) {
-    const bytes = bs58_1.default.decode(address).slice(1);
-    const value = (0, djb2_1.default)(bytes) | 1;
-    const hash = toPosInt(xorByte(value));
-    const group = hash % totalNumberOfGroups;
+const utils_1 = require("./utils");
+const ec = new elliptic_1.ec('secp256k1');
+var AddressType;
+(function (AddressType) {
+    AddressType[AddressType["P2PKH"] = 0] = "P2PKH";
+    AddressType[AddressType["P2MPKH"] = 1] = "P2MPKH";
+    AddressType[AddressType["P2SH"] = 2] = "P2SH";
+    AddressType[AddressType["P2C"] = 3] = "P2C";
+})(AddressType = exports.AddressType || (exports.AddressType = {}));
+function validateAddress(address) {
+    let decoded;
+    try {
+        decoded = bs58_1.default.decode(address);
+    }
+    catch (_) {
+        throw new Error('Invalid base58 string');
+    }
+    if (decoded.length === 0)
+        throw new Error('Address is empty');
+    const addressType = decoded[0];
+    if (addressType === AddressType.P2MPKH) {
+        // [1, n, ...hashes, m]
+        if ((decoded.length - 3) % 32 === 0)
+            return;
+    }
+    else if (addressType === AddressType.P2PKH || addressType === AddressType.P2SH || addressType === AddressType.P2C) {
+        // [type, ...hash]
+        if (decoded.length === 33)
+            return;
+    }
+    throw new Error(`Invalid address: ${address}`);
+}
+exports.validateAddress = validateAddress;
+function groupOfAddress(address) {
+    validateAddress(address);
+    const decoded = bs58_1.default.decode(address);
+    const addressType = decoded[0];
+    const addressBody = decoded.slice(1);
+    if (addressType == AddressType.P2PKH) {
+        return groupOfP2pkhAddress(addressBody);
+    }
+    else if (addressType == AddressType.P2MPKH) {
+        return groupOfP2mpkhAddress(addressBody);
+    }
+    else if (addressType == AddressType.P2SH) {
+        return groupOfP2shAddress(addressBody);
+    }
+    else {
+        // Contract Address
+        const id = contractIdFromAddress(address);
+        return id[`${id.length - 1}`];
+    }
+}
+exports.groupOfAddress = groupOfAddress;
+function groupOfAddressBytes(bytes) {
+    const hint = (0, djb2_1.default)(bytes) | 1;
+    const hash = xorByte(hint);
+    const group = hash % constants_1.TOTAL_NUMBER_OF_GROUPS;
     return group;
 }
-exports.addressToGroup = addressToGroup;
-function xorByte(value) {
-    const byte0 = value >> 24;
-    const byte1 = value >> 16;
-    const byte2 = value >> 8;
-    return byte0 ^ byte1 ^ byte2 ^ value;
+// Pay to public key hash address
+function groupOfP2pkhAddress(address) {
+    return groupOfAddressBytes(address);
+}
+// Pay to multiple public key hash address
+function groupOfP2mpkhAddress(address) {
+    return groupOfAddressBytes(address.slice(1, 33));
+}
+// Pay to script hash address
+function groupOfP2shAddress(address) {
+    return groupOfAddressBytes(address);
+}
+function contractIdFromAddress(address) {
+    return idFromAddress(address);
+}
+exports.contractIdFromAddress = contractIdFromAddress;
+function tokenIdFromAddress(address) {
+    return idFromAddress(address);
+}
+exports.tokenIdFromAddress = tokenIdFromAddress;
+function idFromAddress(address) {
+    const decoded = bs58_1.default.decode(address);
+    if (decoded.length == 0)
+        throw new Error('Address string is empty');
+    const addressType = decoded[0];
+    const addressBody = decoded.slice(1);
+    if (addressType == AddressType.P2C) {
+        return addressBody;
+    }
+    else {
+        throw new Error(`Invalid contract address type: ${addressType}`);
+    }
+}
+function groupOfPrivateKey(privateKey, keyType) {
+    return groupOfAddress(addressFromPublicKey(publicKeyFromPrivateKey(privateKey, keyType), keyType));
+}
+exports.groupOfPrivateKey = groupOfPrivateKey;
+function publicKeyFromPrivateKey(privateKey, _keyType) {
+    const keyType = _keyType ?? 'default';
+    if (keyType === 'default') {
+        const key = ec.keyFromPrivate(privateKey);
+        return key.getPublic(true, 'hex');
+    }
+    else {
+        return ec.g.mul(new bn_js_1.default(privateKey, 16)).encode('hex', true).slice(2);
+    }
+}
+exports.publicKeyFromPrivateKey = publicKeyFromPrivateKey;
+function addressFromPublicKey(publicKey, _keyType) {
+    const keyType = _keyType ?? 'default';
+    if (keyType === 'default') {
+        const addressType = Buffer.from([AddressType.P2PKH]);
+        const hash = Buffer.from(blakejs_1.default.blake2b(Buffer.from(publicKey, 'hex'), undefined, 32));
+        const bytes = Buffer.concat([addressType, hash]);
+        return bs58_1.default.encode(bytes);
+    }
+    else {
+        const lockupScript = Buffer.from(`0101000000000458144020${publicKey}8685`, 'hex');
+        return addressFromScript(lockupScript);
+    }
+}
+exports.addressFromPublicKey = addressFromPublicKey;
+function addressFromScript(script) {
+    const scriptHash = blakejs_1.default.blake2b(script, undefined, 32);
+    const addressType = Buffer.from([AddressType.P2SH]);
+    return bs58_1.default.encode(Buffer.concat([addressType, scriptHash]));
+}
+exports.addressFromScript = addressFromScript;
+function addressFromContractId(contractId) {
+    const addressType = Buffer.from([AddressType.P2C]);
+    const hash = Buffer.from((0, utils_1.hexToBinUnsafe)(contractId));
+    const bytes = Buffer.concat([addressType, hash]);
+    return bs58_1.default.encode(bytes);
+}
+exports.addressFromContractId = addressFromContractId;
+function addressFromTokenId(tokenId) {
+    const contractId = tokenId; // contract ID is the same as token ID
+    return addressFromContractId(contractId);
+}
+exports.addressFromTokenId = addressFromTokenId;
+function contractIdFromTx(txId, outputIndex) {
+    const txIdBin = (0, utils_1.hexToBinUnsafe)(txId);
+    const data = Buffer.concat([txIdBin, Buffer.from([outputIndex])]);
+    const hash = blakejs_1.default.blake2b(data, undefined, 32);
+    return (0, utils_1.binToHex)(hash);
+}
+exports.contractIdFromTx = contractIdFromTx;
+function subContractId(parentContractId, pathInHex, group) {
+    if (group < 0 || group >= constants_1.TOTAL_NUMBER_OF_GROUPS) {
+        throw new Error(`Invalid group ${group}`);
+    }
+    const data = Buffer.concat([(0, utils_1.hexToBinUnsafe)(parentContractId), (0, utils_1.hexToBinUnsafe)(pathInHex)]);
+    const bytes = Buffer.concat([
+        blakejs_1.default.blake2b(blakejs_1.default.blake2b(data, undefined, 32), undefined, 32).slice(0, -1),
+        Buffer.from([group])
+    ]);
+    return (0, utils_1.binToHex)(bytes);
 }
-function toPosInt(byte) {
-    return byte & 0xff;
+exports.subContractId = subContractId;
+function xorByte(intValue) {
+    const byte0 = (intValue >> 24) & 0xff;
+    const byte1 = (intValue >> 16) & 0xff;
+    const byte2 = (intValue >> 8) & 0xff;
+    const byte3 = intValue & 0xff;
+    return (byte0 ^ byte1 ^ byte2 ^ byte3) & 0xff;
 }
+exports.xorByte = xorByte;

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

@@ -0,0 +1,15 @@
+declare class CompilationError {
+    lineStart: number;
+    column: number;
+    errorType: string;
+    line: number;
+    codeLine: string;
+    errorIndicator: string;
+    message: string;
+    additionalLine1?: string | undefined;
+    additionalLine2?: string | undefined;
+    constructor(lineStart: number, column: number, errorType: string, line: number, codeLine: string, errorIndicator: string, message: string, additionalLine1?: string | undefined, additionalLine2?: string | undefined);
+    reformat(line: number, file: string): string;
+}
+export declare function parseError(error: string): CompilationError | undefined;
+export {};

package/dist/src/utils/error.js

@@ -0,0 +1,66 @@
+"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.parseError = void 0;
+class CompilationError {
+    constructor(lineStart, column, errorType, line, codeLine, errorIndicator, message, additionalLine1, additionalLine2) {
+        this.lineStart = lineStart;
+        this.column = column;
+        this.errorType = errorType;
+        this.line = line;
+        this.codeLine = codeLine;
+        this.errorIndicator = errorIndicator;
+        this.message = message;
+        this.additionalLine1 = additionalLine1;
+        this.additionalLine2 = additionalLine2;
+    }
+    reformat(line, file) {
+        const spaces = `${line}`.replace(/\d/g, ' ');
+        const newError = `${file} (${line}:${this.column}): ${this.errorType}
+${line} |${this.codeLine}
+${spaces} |${this.errorIndicator}
+${spaces} |${this.message}`;
+        if (this.additionalLine1 && this.additionalLine2) {
+            return `${newError}\n${spaces} |${this.additionalLine1}\n${spaces} |${this.additionalLine2}`;
+        }
+        else {
+            return newError;
+        }
+    }
+}
+const errorRegex = /error \((\d+):(\d+)\):\s*(.*)\n\s*(\d+)\s*\|(.*)\n.*\|(.*)\n\s*\|(.*)(?:\n\s*\|(.*)\n\s*\|(.*))?/;
+function parseError(error) {
+    const match = error.match(errorRegex);
+    if (match) {
+        const lineStart = parseInt(match[1]);
+        const column = parseInt(match[2]);
+        const errorType = match[3];
+        const line = parseInt(match[4]);
+        const codeLine = match[5];
+        const errorIndicator = match[6];
+        const message = match[7];
+        const additionalLine1 = match[8];
+        const additionalLine2 = match[9];
+        return new CompilationError(lineStart, column, errorType, line, codeLine, errorIndicator, message, additionalLine1, additionalLine2);
+    }
+    else {
+        undefined;
+    }
+}
+exports.parseError = parseError;

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

@@ -1,6 +1,5 @@
 import { ec as EC, SignatureInput } from 'elliptic';
 import BN from 'bn.js';
-import { KeyType } from '../signer';
 import { HexString } from '../contract';
 export declare const networkIds: readonly ["mainnet", "testnet", "devnet"];
 export type NetworkId = (typeof networkIds)[number];
@@ -10,28 +9,10 @@ export declare function encodeSignature(signature: EC.Signature | {
 }): string;
 export declare function encodeHexSignature(rHex: string, sHex: string): string;
 export declare function signatureDecode(ec: EC, signature: string): SignatureInput;
-export declare function xorByte(intValue: number): number;
 export declare function isHexString(input: string): boolean;
 export declare function toNonNegativeBigInt(input: string): bigint | undefined;
-export declare enum AddressType {
-    P2PKH = 0,
-    P2MPKH = 1,
-    P2SH = 2,
-    P2C = 3
-}
-export declare function groupOfAddress(address: string): number;
-export declare function contractIdFromAddress(address: string): Uint8Array;
-export declare function tokenIdFromAddress(address: string): Uint8Array;
 export declare function hexToBinUnsafe(hex: string): Uint8Array;
 export declare function binToHex(bin: Uint8Array): string;
-export declare function groupOfPrivateKey(privateKey: string, keyType?: KeyType): number;
-export declare function publicKeyFromPrivateKey(privateKey: string, _keyType?: KeyType): string;
-export declare function addressFromPublicKey(publicKey: string, _keyType?: KeyType): string;
-export declare function addressFromScript(script: Uint8Array): string;
-export declare function addressFromContractId(contractId: string): string;
-export declare function addressFromTokenId(tokenId: string): string;
-export declare function contractIdFromTx(txId: string, outputIndex: number): string;
-export declare function subContractId(parentContractId: string, pathInHex: string, group: number): string;
 export declare function blockChainIndex(blockHash: HexString): {
     fromGroup: number;
     toGroup: number;