@alephium/web3 0.30.2 → 0.31.0

package/dist/src/utils/utils.js

@@ -20,14 +20,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertType = exports.isDevnet = exports.sleep = exports.hexToString = exports.stringToHex = exports.blockChainIndex = exports.subContractId = exports.contractIdFromTx = exports.addressFromTokenId = exports.addressFromContractId = exports.addressFromScript = exports.addressFromPublicKey = exports.publicKeyFromPrivateKey = exports.groupOfPrivateKey = exports.binToHex = exports.hexToBinUnsafe = exports.tokenIdFromAddress = exports.contractIdFromAddress = exports.groupOfAddress = exports.AddressType = exports.toNonNegativeBigInt = exports.isHexString = exports.xorByte = exports.signatureDecode = exports.encodeHexSignature = exports.encodeSignature = exports.networkIds = void 0;
+exports.assertType = exports.isDevnet = exports.sleep = exports.hexToString = exports.stringToHex = exports.blockChainIndex = exports.binToHex = exports.hexToBinUnsafe = exports.toNonNegativeBigInt = exports.isHexString = exports.signatureDecode = exports.encodeHexSignature = exports.encodeSignature = exports.networkIds = 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"));
 exports.networkIds = ['mainnet', 'testnet', 'devnet'];
 const ec = new elliptic_1.ec('secp256k1');
 function encodeSignature(signature) {
@@ -60,14 +57,6 @@ function signatureDecode(ec, signature) {
     }
 }
 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);
 }
@@ -82,80 +71,6 @@ function toNonNegativeBigInt(input) {
     }
 }
 exports.toNonNegativeBigInt = toNonNegativeBigInt;
-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 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');
 }
@@ -164,72 +79,6 @@ 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');
-        return addressFromScript(lockupScript);
-    }
-}
-exports.addressFromPublicKey = addressFromPublicKey;
-function addressFromScript(script) {
-    const scriptHash = blakejs_1.default.blake2b(script, undefined, 32);
-    const addressType = buffer_1.Buffer.from([AddressType.P2SH]);
-    return bs58_1.default.encode(buffer_1.Buffer.concat([addressType, scriptHash]));
-}
-exports.addressFromScript = addressFromScript;
-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}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.30.2",
+  "version": "0.31.0",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -27,7 +27,7 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "2.8.4",
+    "alephium_version": "2.8.5",
     "explorer_backend_version": "1.16.1"
   },
   "type": "commonjs",

package/src/api/api-alephium.ts

@@ -752,6 +752,11 @@ export interface Reachable {
   type: string
 }
 
+export interface Result {
+  /** @format bigint */
+  hashrate: string
+}
+
 export interface RevealMnemonic {
   password: string
 }
@@ -842,6 +847,11 @@ export interface SweepAddressTransaction {
   gasPrice: string
 }
 
+export interface TargetToHashrate {
+  /** @format hex-string */
+  target: string
+}
+
 export interface TestContract {
   /** @format int32 */
   group?: number
@@ -1282,7 +1292,7 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title Alephium API
- * @version 2.8.4
+ * @version 2.8.5
  * @baseUrl ../
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
@@ -2460,18 +2470,10 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      * @summary Get contract state
      * @request GET:/contracts/{address}/state
      */
-    getContractsAddressState: (
-      address: string,
-      query: {
-        /** @format int32 */
-        group: number
-      },
-      params: RequestParams = {}
-    ) =>
+    getContractsAddressState: (address: string, params: RequestParams = {}) =>
       this.request<ContractState, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
         path: `/contracts/${address}/state`,
         method: 'GET',
-        query: query,
         format: 'json',
         ...params
       }).then(convertHttpResponse),
@@ -2619,40 +2621,6 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse)
   }
-  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 = {}) =>
-      this.request<boolean, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/utils/verify-signature`,
-        method: 'POST',
-        body: data,
-        type: ContentType.Json,
-        format: 'json',
-        ...params
-      }).then(convertHttpResponse),
-
-    /**
-     * No description
-     *
-     * @tags Utils
-     * @name PutUtilsCheckHashIndexing
-     * @summary Check and repair the indexing of block hashes
-     * @request PUT:/utils/check-hash-indexing
-     */
-    putUtilsCheckHashIndexing: (params: RequestParams = {}) =>
-      this.request<void, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
-        path: `/utils/check-hash-indexing`,
-        method: 'PUT',
-        ...params
-      }).then(convertHttpResponse)
-  }
   miners = {
     /**
      * No description
@@ -2833,4 +2801,56 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse)
   }
+  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 = {}) =>
+      this.request<boolean, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/utils/verify-signature`,
+        method: 'POST',
+        body: data,
+        type: ContentType.Json,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * No description
+     *
+     * @tags Utils
+     * @name PostUtilsTargetToHashrate
+     * @summary Convert a target to hashrate
+     * @request POST:/utils/target-to-hashrate
+     */
+    postUtilsTargetToHashrate: (data: TargetToHashrate, params: RequestParams = {}) =>
+      this.request<Result, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/utils/target-to-hashrate`,
+        method: 'POST',
+        body: data,
+        type: ContentType.Json,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
+    /**
+     * No description
+     *
+     * @tags Utils
+     * @name PutUtilsCheckHashIndexing
+     * @summary Check and repair the indexing of block hashes
+     * @request PUT:/utils/check-hash-indexing
+     */
+    putUtilsCheckHashIndexing: (params: RequestParams = {}) =>
+      this.request<void, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/utils/check-hash-indexing`,
+        method: 'PUT',
+        ...params
+      }).then(convertHttpResponse)
+  }
 }

package/src/api/node-provider.ts

@@ -220,8 +220,7 @@ export class NodeProvider implements NodeProviderApis {
 
   guessStdInterfaceId = async (tokenId: HexString): Promise<HexString | undefined> => {
     const address = addressFromTokenId(tokenId)
-    const group = groupOfAddress(address)
-    const rawState = await this.contracts.getContractsAddressState(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/src/contract/contract.ts

@@ -36,6 +36,7 @@ import {
   typeLength,
   getDefaultValue
 } from '../api'
+import { CompileProjectResult } from '../api/api-alephium'
 import {
   SignDeployContractTxParams,
   SignDeployContractTxResult,
@@ -53,16 +54,17 @@ import {
   Eq,
   Optional,
   groupOfAddress,
-  addressFromContractId,
   WebCrypto,
   hexToBinUnsafe,
-  isDevnet
+  isDevnet,
+  addressFromContractId
 } from '../utils'
 import { getCurrentNodeProvider } from '../global'
 import * as path from 'path'
 import { EventSubscribeOptions, EventSubscription, subscribeToEvents } from './events'
 import { ONE_ALPH } from '../constants'
 import * as blake from 'blakejs'
+import { parseError } from '../utils/error'
 
 const crypto = new WebCrypto()
 
@@ -190,6 +192,28 @@ type CodeInfo = {
   warnings: string[]
 }
 
+type SourceInfoIndexes = {
+  sourceInfo: SourceInfo
+  startIndex: number
+  endIndex: number
+}
+
+function findSourceInfoAtLineNumber(sources: SourceInfo[], line: number): SourceInfoIndexes | undefined {
+  let currentLine = 0
+  const sourceInfosWithLine: SourceInfoIndexes[] = 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
+}
+
 export class ProjectArtifact {
   static readonly artifactFileName = '.project.json'
 
@@ -431,6 +455,38 @@ export class Project {
     return contract.artifact
   }
 
+  private static async getCompileResult(
+    provider: NodeProvider,
+    compilerOptions: node.CompilerOptions,
+    sources: SourceInfo[]
+  ): Promise<CompileProjectResult> {
+    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 = 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)
+    }
+  }
+
   private static async compile(
     fullNodeVersion: string,
     provider: NodeProvider,
@@ -447,11 +503,8 @@ export 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<string, Compiled<Contract>>()
     const scripts = new Map<string, Compiled<Script>>()
     result.contracts.forEach((contractResult) => {
@@ -1522,6 +1575,7 @@ export interface CallContractResult<R> {
 function specialContractAddress(n: number): string {
   const bytes = new Uint8Array(32).fill(0)
   bytes[31] = n
+  console.log(addressFromContractId)
   return addressFromContractId(binToHex(bytes))
 }
 
@@ -1651,9 +1705,7 @@ export async function fetchContractState<F extends Fields, I extends ContractIns
   contract: ContractFactory<I, F>,
   instance: ContractInstance
 ): Promise<ContractState<F>> {
-  const contractState = await getCurrentNodeProvider().contracts.getContractsAddressState(instance.address, {
-    group: instance.groupIndex
-  })
+  const contractState = await getCurrentNodeProvider().contracts.getContractsAddressState(instance.address)
   const state = contract.contract.fromApiContractState(contractState)
   return {
     ...state,

package/src/utils/address.ts

@@ -16,24 +16,179 @@ 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/>.
 */
 
+import { ec as EC } from 'elliptic'
+import BN from 'bn.js'
+import { TOTAL_NUMBER_OF_GROUPS } from '../constants'
+import blake from 'blakejs'
 import bs58 from './bs58'
 import djb2 from './djb2'
+import { binToHex, hexToBinUnsafe } from './utils'
+import { KeyType } from '../signer'
 
-export function addressToGroup(address: string, totalNumberOfGroups: number): number {
-  const bytes = bs58.decode(address).slice(1)
-  const value = djb2(bytes) | 1
-  const hash = toPosInt(xorByte(value))
-  const group = hash % totalNumberOfGroups
+const ec = new EC('secp256k1')
+
+export enum AddressType {
+  P2PKH = 0x00,
+  P2MPKH = 0x01,
+  P2SH = 0x02,
+  P2C = 0x03
+}
+
+export function validateAddress(address: string) {
+  let decoded: Uint8Array
+  try {
+    decoded = bs58.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}`)
+}
+
+export function groupOfAddress(address: string): number {
+  validateAddress(address)
+
+  const decoded = bs58.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}`]
+  }
+}
+
+function groupOfAddressBytes(bytes: Uint8Array): number {
+  const hint = djb2(bytes) | 1
+  const hash = xorByte(hint)
+  const group = hash % TOTAL_NUMBER_OF_GROUPS
   return group
 }
 
-function xorByte(value: number): number {
-  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: Uint8Array): number {
+  return groupOfAddressBytes(address)
+}
+
+// Pay to multiple public key hash address
+function groupOfP2mpkhAddress(address: Uint8Array): number {
+  return groupOfAddressBytes(address.slice(1, 33))
+}
+
+// Pay to script hash address
+function groupOfP2shAddress(address: Uint8Array): number {
+  return groupOfAddressBytes(address)
+}
+
+export function contractIdFromAddress(address: string): Uint8Array {
+  return idFromAddress(address)
+}
+
+export function tokenIdFromAddress(address: string): Uint8Array {
+  return idFromAddress(address)
+}
+
+function idFromAddress(address: string): Uint8Array {
+  const decoded = bs58.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}`)
+  }
+}
+
+export function groupOfPrivateKey(privateKey: string, keyType?: KeyType): number {
+  return groupOfAddress(addressFromPublicKey(publicKeyFromPrivateKey(privateKey, keyType), keyType))
+}
+
+export function publicKeyFromPrivateKey(privateKey: string, _keyType?: KeyType): string {
+  const keyType = _keyType ?? 'default'
+
+  if (keyType === 'default') {
+    const key = ec.keyFromPrivate(privateKey)
+    return key.getPublic(true, 'hex')
+  } else {
+    return ec.g.mul(new BN(privateKey, 16)).encode('hex', true).slice(2)
+  }
+}
+
+export function addressFromPublicKey(publicKey: string, _keyType?: KeyType): string {
+  const keyType = _keyType ?? 'default'
+
+  if (keyType === 'default') {
+    const addressType = Buffer.from([AddressType.P2PKH])
+    const hash = Buffer.from(blake.blake2b(Buffer.from(publicKey, 'hex'), undefined, 32))
+    const bytes = Buffer.concat([addressType, hash])
+    return bs58.encode(bytes)
+  } else {
+    const lockupScript = Buffer.from(`0101000000000458144020${publicKey}8685`, 'hex')
+    return addressFromScript(lockupScript)
+  }
+}
+
+export function addressFromScript(script: Uint8Array): string {
+  const scriptHash = blake.blake2b(script, undefined, 32)
+  const addressType = Buffer.from([AddressType.P2SH])
+  return bs58.encode(Buffer.concat([addressType, scriptHash]))
+}
+
+export function addressFromContractId(contractId: string): string {
+  const addressType = Buffer.from([AddressType.P2C])
+  const hash = Buffer.from(hexToBinUnsafe(contractId))
+  const bytes = Buffer.concat([addressType, hash])
+  return bs58.encode(bytes)
+}
+
+export function addressFromTokenId(tokenId: string): string {
+  const contractId = tokenId // contract ID is the same as token ID
+  return addressFromContractId(contractId)
+}
+
+export function contractIdFromTx(txId: string, outputIndex: number): string {
+  const txIdBin = hexToBinUnsafe(txId)
+  const data = Buffer.concat([txIdBin, Buffer.from([outputIndex])])
+  const hash = blake.blake2b(data, undefined, 32)
+  return binToHex(hash)
+}
+
+export function subContractId(parentContractId: string, pathInHex: string, group: number): string {
+  if (group < 0 || group >= TOTAL_NUMBER_OF_GROUPS) {
+    throw new Error(`Invalid group ${group}`)
+  }
+  const data = Buffer.concat([hexToBinUnsafe(parentContractId), hexToBinUnsafe(pathInHex)])
+  const bytes = Buffer.concat([
+    blake.blake2b(blake.blake2b(data, undefined, 32), undefined, 32).slice(0, -1),
+    Buffer.from([group])
+  ])
+  return binToHex(bytes)
 }
 
-function toPosInt(byte: number): number {
-  return byte & 0xff
+export function xorByte(intValue: number): number {
+  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
 }