@alephium/web3 0.9.0-rc.0 → 0.9.0-rc.1

package/dist/src/utils/number.js

@@ -0,0 +1,149 @@
+"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/>.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.number256ToBigint = exports.convertAlphAmountWithDecimals = exports.convertAmountWithDecimals = exports.prettifyNumber = exports.prettifyExactAmount = exports.prettifyTokenAmount = exports.prettifyAttoAlphAmount = exports.prettifyNumberConfig = exports.isNumeric = void 0;
+// Credits:
+// 1. https://github.com/argentlabs/argent-x/blob/e63affa7f28b27333dca4081a3dcd375bb2da40b/packages/extension/src/shared/utils/number.ts
+// 2. https://github.com/ethers-io/ethers.js/blob/724881f34d428406488a1c9f9dbebe54b6edecda/src.ts/utils/fixednumber.ts
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const isNumeric = (numToCheck) => !isNaN(parseFloat(numToCheck)) && isFinite(numToCheck);
+exports.isNumeric = isNumeric;
+exports.prettifyNumberConfig = {
+    ALPH: {
+        minDecimalPlaces: 2,
+        maxDecimalPlaces: 10,
+        minDecimalSignificantDigits: 2,
+        decimalPlacesWhenZero: 2
+    },
+    TOKEN: {
+        minDecimalPlaces: 4,
+        maxDecimalPlaces: 16,
+        minDecimalSignificantDigits: 2,
+        decimalPlacesWhenZero: 1
+    },
+    Exact: {
+        minDecimalPlaces: 18,
+        maxDecimalPlaces: 18,
+        minDecimalSignificantDigits: 0,
+        decimalPlacesWhenZero: 0
+    }
+};
+function prettifyAttoAlphAmount(amount) {
+    return prettifyNumber(amount, 18, exports.prettifyNumberConfig.ALPH);
+}
+exports.prettifyAttoAlphAmount = prettifyAttoAlphAmount;
+function prettifyTokenAmount(amount, decimals) {
+    return prettifyNumber(amount, decimals, exports.prettifyNumberConfig.TOKEN);
+}
+exports.prettifyTokenAmount = prettifyTokenAmount;
+function prettifyExactAmount(amount, decimals) {
+    return prettifyNumber(amount, decimals, exports.prettifyNumberConfig.Exact);
+}
+exports.prettifyExactAmount = prettifyExactAmount;
+function prettifyNumber(amount, decimals, config) {
+    const number = toFixedNumber(number256ToBigint(amount), decimals);
+    if (!(0, exports.isNumeric)(number)) {
+        return undefined;
+    }
+    const numberBN = new bignumber_js_1.default(number);
+    let untrimmed;
+    if (numberBN.gte(1)) {
+        /** simplest case, formatting to minDecimalPlaces will look good */
+        untrimmed = numberBN.toFormat(config.minDecimalPlaces);
+    }
+    else {
+        /** now need to interrogate the appearance of decimal number < 1 */
+        /** longest case - max decimal places e.g. 0.0008923088123 -> 0.0008923088 */
+        const maxDecimalPlacesString = numberBN.toFormat(config.maxDecimalPlaces);
+        /** count the zeros, which will then allow us to know the final length with desired significant digits */
+        const decimalPart = maxDecimalPlacesString.split('.')[1];
+        const zeroMatches = decimalPart?.match(/^0+/);
+        const leadingZerosInDecimalPart = zeroMatches && zeroMatches.length ? zeroMatches[0].length : 0;
+        /** now we can re-format with leadingZerosInDecimalPart + maxDecimalSignificanDigits to give us the pretty version */
+        /** e.g. 0.0008923088123 -> 0.00089 */
+        const prettyDecimalPlaces = Math.max(leadingZerosInDecimalPart + config.minDecimalSignificantDigits, config.minDecimalPlaces);
+        untrimmed = numberBN.toFormat(prettyDecimalPlaces);
+    }
+    /** the untrimmed string may have trailing zeros, e.g. 0.0890 */
+    /** trim to a minimum specified by the config, e.g. we may want to display $0.00 or 0.0 ETH */
+    let trimmed = untrimmed.replace(/0+$/, '');
+    const minLength = 1 + untrimmed.indexOf('.') + config.decimalPlacesWhenZero;
+    if (trimmed.length < minLength) {
+        trimmed = untrimmed.substring(0, minLength);
+    }
+    if (trimmed[trimmed.length - 1] === '.') {
+        trimmed = trimmed.slice(0, -1);
+    }
+    return trimmed;
+}
+exports.prettifyNumber = prettifyNumber;
+const BN_N1 = BigInt(-1);
+const BN_0 = BigInt(0);
+// Constant to pull zeros from for multipliers
+const Zeros = '0000';
+function toFixedNumber(val, decimals) {
+    let negative = '';
+    if (val < BN_0) {
+        negative = '-';
+        val *= BN_N1;
+    }
+    let str = val.toString();
+    // No decimal point for whole values
+    if (decimals === 0) {
+        return negative + str;
+    }
+    // Pad out to the whole component (including a whole digit)
+    while (str.length <= decimals) {
+        str = Zeros + str;
+    }
+    // Insert the decimal point
+    const index = str.length - decimals;
+    str = str.substring(0, index) + '.' + str.substring(index);
+    // Trim the whole component (leaving at least one 0)
+    while (str[0] === '0' && str[1] !== '.') {
+        str = str.substring(1);
+    }
+    // Trim the decimal component (leaving at least one 0)
+    while (str[str.length - 1] === '0' && str[str.length - 2] !== '.') {
+        str = str.substring(0, str.length - 1);
+    }
+    return negative + str;
+}
+function convertAmountWithDecimals(amount, decimals) {
+    try {
+        const result = new bignumber_js_1.default(amount).multipliedBy(Math.pow(10, decimals));
+        return BigInt(result.toFormat(0, { groupSeparator: '' }));
+    }
+    catch (e) {
+        return undefined;
+    }
+}
+exports.convertAmountWithDecimals = convertAmountWithDecimals;
+// E.g. `1.23 ALPH` will be converted to `1230000000000000000`
+function convertAlphAmountWithDecimals(amount) {
+    return convertAmountWithDecimals(amount, 18);
+}
+exports.convertAlphAmountWithDecimals = convertAlphAmountWithDecimals;
+function number256ToBigint(number) {
+    return typeof number === 'string' ? BigInt(number) : number;
+}
+exports.number256ToBigint = number256ToBigint;

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

@@ -0,0 +1,3 @@
+import { KeyType } from '../signer';
+export declare function sign(hash: string, privateKey: string, _keyType?: KeyType): string;
+export declare function verifySignature(hash: string, publicKey: string, signature: string, _keyType?: KeyType): boolean;

package/dist/src/utils/sign.js

@@ -0,0 +1,89 @@
+"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/>.
+*/
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifySignature = exports.sign = void 0;
+const elliptic_1 = require("elliptic");
+const __1 = require("..");
+const necc = __importStar(require("@noble/secp256k1"));
+const crypto_1 = require("crypto");
+const ec = new elliptic_1.ec('secp256k1');
+necc.utils.sha256Sync = (...messages) => {
+    const sha256 = (0, crypto_1.createHash)('sha256');
+    for (const message of messages)
+        sha256.update(message);
+    return sha256.digest();
+};
+necc.utils.hmacSha256Sync = (key, ...messages) => {
+    const hash = (0, crypto_1.createHmac)('sha256', Buffer.from(key));
+    messages.forEach((m) => hash.update(m));
+    return Uint8Array.from(hash.digest());
+};
+// hash has to be 32 bytes
+function sign(hash, privateKey, _keyType) {
+    const keyType = _keyType ?? 'default';
+    if (keyType === 'default') {
+        const key = ec.keyFromPrivate(privateKey);
+        const signature = key.sign(hash);
+        return (0, __1.encodeSignature)(signature);
+    }
+    else {
+        const signature = necc.schnorr.signSync((0, __1.hexToBinUnsafe)(hash), (0, __1.hexToBinUnsafe)(privateKey));
+        return (0, __1.binToHex)(signature);
+    }
+}
+exports.sign = sign;
+function verifySignature(hash, publicKey, signature, _keyType) {
+    const keyType = _keyType ?? 'default';
+    try {
+        if (keyType === 'default') {
+            const key = ec.keyFromPublic(publicKey, 'hex');
+            return key.verify(hash, (0, __1.signatureDecode)(ec, signature));
+        }
+        else {
+            return necc.schnorr.verifySync((0, __1.hexToBinUnsafe)(signature), (0, __1.hexToBinUnsafe)(hash), (0, __1.hexToBinUnsafe)(publicKey));
+        }
+    }
+    catch (error) {
+        return false;
+    }
+}
+exports.verifySignature = verifySignature;

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

@@ -0,0 +1,21 @@
+import EventEmitter from 'eventemitter3';
+type MessageCallback<Message> = (message: Message) => Promise<void>;
+type ErrorCallback<Message> = (error: any, subscription: Subscription<Message>) => Promise<void>;
+export interface SubscribeOptions<Message> {
+    pollingInterval: number;
+    messageCallback: MessageCallback<Message>;
+    errorCallback: ErrorCallback<Message>;
+}
+export declare abstract class Subscription<Message> {
+    pollingInterval: number;
+    protected messageCallback: MessageCallback<Message>;
+    protected errorCallback: ErrorCallback<Message>;
+    protected task: ReturnType<typeof setTimeout> | undefined;
+    protected eventEmitter: EventEmitter;
+    protected cancelled: boolean;
+    constructor(options: SubscribeOptions<Message>);
+    startPolling(): void;
+    unsubscribe(): void;
+    abstract polling(): Promise<void>;
+}
+export {};

package/dist/src/utils/subscription.js

@@ -0,0 +1,51 @@
+"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/>.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subscription = void 0;
+const eventemitter3_1 = __importDefault(require("eventemitter3"));
+class Subscription {
+    constructor(options) {
+        this.pollingInterval = options.pollingInterval;
+        this.messageCallback = options.messageCallback;
+        this.errorCallback = options.errorCallback;
+        this.task = undefined;
+        this.cancelled = false;
+        this.eventEmitter = new eventemitter3_1.default();
+    }
+    startPolling() {
+        this.eventEmitter.on('tick', async () => {
+            await this.polling();
+            if (!this.cancelled) {
+                this.task = setTimeout(() => this.eventEmitter.emit('tick'), this.pollingInterval);
+            }
+        });
+        this.eventEmitter.emit('tick');
+    }
+    unsubscribe() {
+        this.eventEmitter.removeAllListeners();
+        this.cancelled = true;
+        if (typeof this.task !== 'undefined') {
+            clearTimeout(this.task);
+        }
+    }
+}
+exports.Subscription = Subscription;

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

@@ -0,0 +1,40 @@
+import { ec as EC, SignatureInput } from 'elliptic';
+import BN from 'bn.js';
+import { KeyType } from '../signer';
+import { HexString } from '../contract';
+export declare function encodeSignature(signature: EC.Signature | {
+    r: BN;
+    s: BN;
+}): 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 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 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;
+};
+export declare function stringToHex(str: string): string;
+export declare function hexToString(str: string): string;
+export declare function sleep(ms: number): Promise<void>;
+type _Eq<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false;
+export type Eq<X, Y> = _Eq<{
+    [P in keyof X]: X[P];
+}, {
+    [P in keyof Y]: Y[P];
+}>;
+export declare function assertType<T extends true>(): void;
+export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+export {};

package/dist/src/utils/utils.js

@@ -0,0 +1,244 @@
+"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/>.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertType = exports.sleep = exports.hexToString = exports.stringToHex = exports.blockChainIndex = exports.subContractId = exports.contractIdFromTx = exports.addressFromTokenId = exports.addressFromContractId = exports.addressFromPublicKey = exports.publicKeyFromPrivateKey = exports.groupOfPrivateKey = exports.binToHex = exports.hexToBinUnsafe = exports.tokenIdFromAddress = exports.contractIdFromAddress = exports.groupOfAddress = exports.isHexString = exports.xorByte = exports.signatureDecode = exports.encodeHexSignature = exports.encodeSignature = void 0;
+const elliptic_1 = require("elliptic");
+const bn_js_1 = __importDefault(require("bn.js"));
+const blakejs_1 = __importDefault(require("blakejs"));
+const bs58_1 = __importDefault(require("./bs58"));
+const buffer_1 = require("buffer/");
+const constants_1 = require("../constants");
+const djb2_1 = __importDefault(require("./djb2"));
+const ec = new elliptic_1.ec('secp256k1');
+function encodeSignature(signature) {
+    let sNormalized = signature.s;
+    if (ec.n && signature.s.cmp(ec.nh) === 1) {
+        sNormalized = ec.n.sub(signature.s);
+    }
+    const r = signature.r.toString('hex', 66).slice(2);
+    const s = sNormalized.toString('hex', 66).slice(2);
+    return r + s;
+}
+exports.encodeSignature = encodeSignature;
+function encodeHexSignature(rHex, sHex) {
+    return encodeSignature({ r: new bn_js_1.default(rHex, 'hex'), s: new bn_js_1.default(sHex, 'hex') });
+}
+exports.encodeHexSignature = encodeHexSignature;
+// the signature should be in hex string format for 64 bytes
+function signatureDecode(ec, signature) {
+    if (signature.length !== 128) {
+        throw new Error('Invalid signature length');
+    }
+    const sHex = signature.slice(64, 128);
+    const s = new bn_js_1.default(sHex, 'hex');
+    if (ec.n && s.cmp(ec.nh) < 1) {
+        const decoded = { r: signature.slice(0, 64), s: sHex };
+        return decoded;
+    }
+    else {
+        throw new Error('The signature is not normalized');
+    }
+}
+exports.signatureDecode = signatureDecode;
+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;
+function isHexString(input) {
+    return input.length % 2 === 0 && /^[0-9a-fA-F]*$/.test(input);
+}
+exports.isHexString = isHexString;
+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 || (AddressType = {}));
+function groupOfAddress(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.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;
+}
+// Pay to public key hash address
+function groupOfP2pkhAddress(address) {
+    if (address.length != 32) {
+        throw new Error(`Invalid p2pkh address length: ${address.length}`);
+    }
+    return groupOfAddressBytes(address);
+}
+// Pay to multiple public key hash address
+function groupOfP2mpkhAddress(address) {
+    if ((address.length - 2) % 32 != 0) {
+        throw new Error(`Invalid p2mpkh address length: ${address.length}`);
+    }
+    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 hexToBinUnsafe(hex) {
+    return buffer_1.Buffer.from(hex, 'hex');
+}
+exports.hexToBinUnsafe = hexToBinUnsafe;
+function binToHex(bin) {
+    return buffer_1.Buffer.from(bin).toString('hex');
+}
+exports.binToHex = binToHex;
+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_1.Buffer.from([AddressType.P2PKH]);
+        const hash = buffer_1.Buffer.from(blakejs_1.default.blake2b(buffer_1.Buffer.from(publicKey, 'hex'), undefined, 32));
+        const bytes = buffer_1.Buffer.concat([addressType, hash]);
+        return bs58_1.default.encode(bytes);
+    }
+    else {
+        const lockupScript = buffer_1.Buffer.from(`0101000000000458144020${publicKey}8685`, 'hex');
+        const lockupScriptHash = blakejs_1.default.blake2b(lockupScript, undefined, 32);
+        const addressType = buffer_1.Buffer.from([AddressType.P2SH]);
+        return bs58_1.default.encode(buffer_1.Buffer.concat([addressType, lockupScriptHash]));
+    }
+}
+exports.addressFromPublicKey = addressFromPublicKey;
+function addressFromContractId(contractId) {
+    const addressType = buffer_1.Buffer.from([AddressType.P2C]);
+    const hash = buffer_1.Buffer.from(hexToBinUnsafe(contractId));
+    const bytes = buffer_1.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 = hexToBinUnsafe(txId);
+    const data = buffer_1.Buffer.concat([txIdBin, buffer_1.Buffer.from([outputIndex])]);
+    const hash = blakejs_1.default.blake2b(data, undefined, 32);
+    return 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_1.Buffer.concat([hexToBinUnsafe(parentContractId), hexToBinUnsafe(pathInHex)]);
+    const bytes = buffer_1.Buffer.concat([
+        blakejs_1.default.blake2b(blakejs_1.default.blake2b(data, undefined, 32), undefined, 32).slice(0, -1),
+        buffer_1.Buffer.from([group])
+    ]);
+    return binToHex(bytes);
+}
+exports.subContractId = subContractId;
+function blockChainIndex(blockHash) {
+    if (blockHash.length != 64) {
+        throw Error(`Invalid block hash: ${blockHash}`);
+    }
+    const rawIndex = Number('0x' + blockHash.slice(-4)) % constants_1.TOTAL_NUMBER_OF_CHAINS;
+    return { fromGroup: Math.floor(rawIndex / constants_1.TOTAL_NUMBER_OF_GROUPS), toGroup: rawIndex % constants_1.TOTAL_NUMBER_OF_GROUPS };
+}
+exports.blockChainIndex = blockChainIndex;
+function stringToHex(str) {
+    let hex = '';
+    for (let i = 0; i < str.length; i++) {
+        hex += '' + str.charCodeAt(i).toString(16);
+    }
+    return hex;
+}
+exports.stringToHex = stringToHex;
+function hexToString(str) {
+    return buffer_1.Buffer.from(str, 'hex').toString();
+}
+exports.hexToString = hexToString;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+exports.sleep = sleep;
+// 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.9.0-rc.0",
+  "version": "0.9.0-rc.1",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",