@alephium/web3 1.7.2 → 1.7.4

package/src/address/address.ts

@@ -21,11 +21,12 @@ import BN from 'bn.js'
 import { TOTAL_NUMBER_OF_GROUPS } from '../constants'
 import blake from 'blakejs'
 import bs58 from '../utils/bs58'
-import djb2 from '../utils/djb2'
-import { binToHex, concatBytes, hexToBinUnsafe, isHexString } from '../utils'
+import { binToHex, concatBytes, hexToBinUnsafe, isHexString, xorByte } from '../utils'
 import { KeyType } from '../signer'
 import { P2MPKH, lockupScriptCodec } from '../codec/lockup-script-codec'
 import { i32Codec } from '../codec'
+import { LockupScript } from '../codec/lockup-script-codec'
+import djb2 from '../utils/djb2'
 
 const ec = new EC('secp256k1')
 const PublicKeyHashSize = 32
@@ -112,26 +113,19 @@ export function groupOfAddress(address: string): number {
   }
 }
 
-function groupOfAddressBytes(bytes: Uint8Array): number {
-  const hint = djb2(bytes) | 1
-  const hash = xorByte(hint)
-  const group = hash % TOTAL_NUMBER_OF_GROUPS
-  return group
-}
-
 // Pay to public key hash address
 function groupOfP2pkhAddress(address: Uint8Array): number {
-  return groupOfAddressBytes(address)
+  return groupFromBytesForAssetAddress(address)
 }
 
 // Pay to multiple public key hash address
 function groupOfP2mpkhAddress(address: Uint8Array): number {
-  return groupOfAddressBytes(address.slice(1, 33))
+  return groupFromBytesForAssetAddress(address.slice(1, 33))
 }
 
 // Pay to script hash address
 function groupOfP2shAddress(address: Uint8Array): number {
-  return groupOfAddressBytes(address)
+  return groupFromBytesForAssetAddress(address)
 }
 
 export function contractIdFromAddress(address: string): Uint8Array {
@@ -225,10 +219,22 @@ export function subContractId(parentContractId: string, pathInHex: string, group
   return binToHex(bytes)
 }
 
-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
+export function groupOfLockupScript(lockupScript: LockupScript): number {
+  if (lockupScript.kind === 'P2PKH') {
+    return groupFromBytesForAssetAddress(lockupScript.value)
+  } else if (lockupScript.kind === 'P2MPKH') {
+    return groupFromBytesForAssetAddress(lockupScript.value.publicKeyHashes[0])
+  } else if (lockupScript.kind === 'P2SH') {
+    return groupFromBytesForAssetAddress(lockupScript.value)
+  } else {
+    // P2C
+    const contractId = lockupScript.value
+    return contractId[`${contractId.length - 1}`]
+  }
+}
+
+function groupFromBytesForAssetAddress(bytes: Uint8Array): number {
+  const hint = djb2(bytes) | 1
+  const hash = xorByte(hint)
+  return hash % TOTAL_NUMBER_OF_GROUPS
 }

package/src/api/api-alephium.ts

@@ -926,6 +926,97 @@ export interface RevealMnemonicResult {
   mnemonic: string
 }
 
+/** RichAssetInput */
+export interface RichAssetInput {
+  /** @format int32 */
+  hint: number
+  /** @format 32-byte-hash */
+  key: string
+  /** @format hex-string */
+  unlockScript: string
+  /** @format uint256 */
+  attoAlphAmount: string
+  /** @format address */
+  address: string
+  tokens: Token[]
+}
+
+/** RichBlockAndEvents */
+export interface RichBlockAndEvents {
+  block: RichBlockEntry
+  events: ContractEventByBlockHash[]
+}
+
+/** RichBlockEntry */
+export interface RichBlockEntry {
+  /** @format block-hash */
+  hash: string
+  /** @format int64 */
+  timestamp: number
+  /** @format int32 */
+  chainFrom: number
+  /** @format int32 */
+  chainTo: number
+  /** @format int32 */
+  height: number
+  deps: string[]
+  transactions: RichTransaction[]
+  /** @format hex-string */
+  nonce: string
+  version: number
+  /** @format 32-byte-hash */
+  depStateHash: string
+  /** @format 32-byte-hash */
+  txsHash: string
+  /** @format hex-string */
+  target: string
+  ghostUncles: GhostUncleBlockEntry[]
+}
+
+/** RichBlocksAndEventsPerTimeStampRange */
+export interface RichBlocksAndEventsPerTimeStampRange {
+  blocksAndEvents: RichBlockAndEvents[][]
+}
+
+/** RichContractInput */
+export interface RichContractInput {
+  /** @format int32 */
+  hint: number
+  /** @format 32-byte-hash */
+  key: string
+  /** @format uint256 */
+  attoAlphAmount: string
+  /** @format address */
+  address: string
+  tokens: Token[]
+}
+
+/** RichTransaction */
+export interface RichTransaction {
+  unsigned: RichUnsignedTx
+  scriptExecutionOk: boolean
+  contractInputs: RichContractInput[]
+  generatedOutputs: Output[]
+  inputSignatures: string[]
+  scriptSignatures: string[]
+}
+
+/** RichUnsignedTx */
+export interface RichUnsignedTx {
+  /** @format 32-byte-hash */
+  txId: string
+  version: number
+  networkId: number
+  /** @format script */
+  scriptOpt?: string
+  /** @format int32 */
+  gasAmount: number
+  /** @format uint256 */
+  gasPrice: string
+  inputs: RichAssetInput[]
+  fixedOutputs: FixedAssetOutput[]
+}
+
 /** Script */
 export interface Script {
   code: string
@@ -1512,7 +1603,7 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title Alephium API
- * @version 3.6.2
+ * @version 3.7.0
  * @baseUrl ../
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
@@ -2169,6 +2260,40 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * No description
+     *
+     * @tags Blockflow
+     * @name GetBlockflowRichBlocks
+     * @summary Given a time interval, list blocks containing events and transactions with enriched input information when node indexes are enabled.
+     * @request GET:/blockflow/rich-blocks
+     */
+    getBlockflowRichBlocks: (
+      query: {
+        /**
+         * @format int64
+         * @min 0
+         */
+        fromTs: number
+        /**
+         * @format int64
+         * @min 0
+         */
+        toTs?: number
+      },
+      params: RequestParams = {}
+    ) =>
+      this.request<
+        RichBlocksAndEventsPerTimeStampRange,
+        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable
+      >({
+        path: `/blockflow/rich-blocks`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * No description
      *
@@ -2217,6 +2342,24 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * No description
+     *
+     * @tags Blockflow
+     * @name GetBlockflowRichBlocksBlockHash
+     * @summary Get a block containing events and transactions with enriched input information when node indexes are enabled.
+     * @request GET:/blockflow/rich-blocks/{block_hash}
+     */
+    getBlockflowRichBlocksBlockHash: (blockHash: string, params: RequestParams = {}) =>
+      this.request<RichBlockAndEvents, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>(
+        {
+          path: `/blockflow/rich-blocks/${blockHash}`,
+          method: 'GET',
+          format: 'json',
+          ...params
+        }
+      ).then(convertHttpResponse),
+
     /**
      * No description
      *

package/src/api/api-explorer.ts

@@ -190,6 +190,7 @@ export interface AssetOutput {
 
 /** NFT */
 export interface NFT {
+  id: string
   type: string
 }
 
@@ -217,6 +218,14 @@ export interface AcceptedTransaction {
   timestamp: number
 }
 
+/** HolderInfo */
+export interface HolderInfo {
+  /** @format address */
+  address: string
+  /** @format uint256 */
+  balance: string
+}
+
 /** TokenSupply */
 export interface TokenSupply {
   /** @format uint256 */
@@ -317,6 +326,8 @@ export enum TokenStdInterfaceId {
 export interface ExplorerInfo {
   releaseVersion: string
   commit: string
+  /** @format int64 */
+  lastHoldersUpdate: number
   /** @format int32 */
   migrationsVersion: number
   /** @format int64 */
@@ -367,6 +378,7 @@ export interface Transaction {
 
 /** FungibleToken */
 export interface FungibleToken {
+  id: string
   type: string
 }
 
@@ -1588,6 +1600,40 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * @description Get a sorted list of top addresses by {token_id} balance. Updates once per day.
+     *
+     * @tags Tokens
+     * @name GetTokensHoldersTokenTokenId
+     * @request GET:/tokens/holders/token/{token_id}
+     */
+    getTokensHoldersTokenTokenId: (
+      tokenId: string,
+      query?: {
+        /**
+         * Page number
+         * @format int32
+         * @min 1
+         */
+        page?: number
+        /**
+         * Number of items per page
+         * @format int32
+         * @min 0
+         * @max 100
+         */
+        limit?: number
+      },
+      params: RequestParams = {}
+    ) =>
+      this.request<HolderInfo[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/tokens/holders/token/${tokenId}`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * @description List token transactions
      *
@@ -1676,6 +1722,39 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * @description Get a sorted list of top addresses by ALPH balance. Updates once per day.
+     *
+     * @tags Tokens
+     * @name GetTokensHoldersAlph
+     * @request GET:/tokens/holders/alph
+     */
+    getTokensHoldersAlph: (
+      query?: {
+        /**
+         * Page number
+         * @format int32
+         * @min 1
+         */
+        page?: number
+        /**
+         * Number of items per page
+         * @format int32
+         * @min 0
+         * @max 100
+         */
+        limit?: number
+      },
+      params: RequestParams = {}
+    ) =>
+      this.request<HolderInfo[], BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/tokens/holders/alph`,
+        method: 'GET',
+        query: query,
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * @description Return metadata for the given nft tokens, if metadata doesn't exist or token isn't a nft, it won't be in the output list
      *

package/src/contract/contract.ts

@@ -2046,12 +2046,14 @@ function toFieldsSig(contractName: string, functionSig: FunctionSig): FieldsSig
   }
 }
 
+type Calls = Record<string, Optional<CallContractParams<any>, 'args'>>
 export async function multicallMethods<I extends ContractInstance, F extends Fields>(
   contract: ContractFactory<I, F>,
   instance: ContractInstance,
-  callss: Record<string, Optional<CallContractParams<any>, 'args'>>[],
+  _callss: Calls | Calls[],
   getContractByCodeHash: (codeHash: string) => Contract
 ): Promise<Record<string, CallContractResult<any>>[] | Record<string, CallContractResult<any>>> {
+  const callss = Array.isArray(_callss) ? _callss : [_callss]
   const callEntries = callss.map((calls) => Object.entries(calls))
   const callsParams = callEntries.map((entries) => {
     return entries.map((entry) => {
@@ -2068,7 +2070,7 @@ export async function multicallMethods<I extends ContractInstance, F extends Fie
   })
   const result = await getCurrentNodeProvider().contracts.postContractsMulticallContract({ calls: callsParams.flat() })
   let callResultIndex = 0
-  return callsParams.map((calls, index0) => {
+  const results = callsParams.map((calls, index0) => {
     const callsResult: Record<string, CallContractResult<any>> = {}
     const entries = callEntries[`${index0}`]
     calls.forEach((call, index1) => {
@@ -2085,6 +2087,7 @@ export async function multicallMethods<I extends ContractInstance, F extends Fie
     })
     return callsResult
   })
+  return Array.isArray(_callss) ? results : results[0]
 }
 
 export async function getContractEventsCurrentCount(contractAddress: Address): Promise<number> {

package/src/signer/tx-builder.ts

@@ -16,7 +16,7 @@ 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 { binToHex } from '../utils'
+import { binToHex, hexToBinUnsafe } from '../utils'
 import { fromApiNumber256, node, NodeProvider, toApiNumber256Optional, toApiTokens } from '../api'
 import { addressFromPublicKey, contractIdFromAddress } from '../address'
 import { toApiDestinations } from './signer'
@@ -32,6 +32,9 @@ import {
   SignUnsignedTxParams,
   SignUnsignedTxResult
 } from './types'
+import { unsignedTxCodec, UnsignedTxCodec } from '../codec'
+import { groupIndexOfTransaction } from '../transaction'
+import { blakeHash } from '../codec/hash'
 
 export abstract class TransactionBuilder {
   abstract get nodeProvider(): NodeProvider
@@ -113,16 +116,18 @@ export abstract class TransactionBuilder {
     return { ...response, groupIndex: response.fromGroup, gasPrice: fromApiNumber256(response.gasPrice) }
   }
 
-  async buildUnsignedTx(params: SignUnsignedTxParams): Promise<Omit<SignUnsignedTxResult, 'signature'>> {
-    const data = { unsignedTx: params.unsignedTx }
-    const decoded = await this.nodeProvider.transactions.postTransactionsDecodeUnsignedTx(data)
+  buildUnsignedTx(params: SignUnsignedTxParams): Omit<SignUnsignedTxResult, 'signature'> {
+    const unsignedTxBin = hexToBinUnsafe(params.unsignedTx)
+    const decoded = unsignedTxCodec.decode(unsignedTxBin)
+    const txId = binToHex(blakeHash(unsignedTxBin))
+    const [fromGroup, toGroup] = groupIndexOfTransaction(decoded)
     return {
-      fromGroup: decoded.fromGroup,
-      toGroup: decoded.toGroup,
+      fromGroup: fromGroup,
+      toGroup: toGroup,
       unsignedTx: params.unsignedTx,
-      txId: decoded.unsignedTx.txId,
-      gasAmount: decoded.unsignedTx.gasAmount,
-      gasPrice: fromApiNumber256(decoded.unsignedTx.gasPrice)
+      txId: txId,
+      gasAmount: decoded.gasAmount,
+      gasPrice: decoded.gasPrice
     }
   }
 }

package/src/transaction/utils.ts

@@ -16,8 +16,12 @@ 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 { groupOfLockupScript } from '../address'
 import { node } from '../api'
+import { UnsignedTx } from '../codec'
+import { TOTAL_NUMBER_OF_GROUPS } from '../constants'
 import { getCurrentNodeProvider } from '../global'
+import { xorByte } from '../utils'
 
 function isConfirmed(txStatus: node.TxStatus): txStatus is node.Confirmed {
   return txStatus.type === 'Confirmed'
@@ -36,3 +40,25 @@ export async function waitForTxConfirmation(
   await new Promise((r) => setTimeout(r, requestInterval))
   return waitForTxConfirmation(txId, confirmations, requestInterval)
 }
+
+export function groupIndexOfTransaction(unsignedTx: UnsignedTx): [number, number] {
+  if (unsignedTx.inputs.length === 0) throw new Error('Empty inputs for unsignedTx')
+
+  const fromGroup = groupFromHint(unsignedTx.inputs[0].hint)
+
+  let toGroup = fromGroup
+  for (const output of unsignedTx.fixedOutputs) {
+    const outputGroup = groupOfLockupScript(output.lockupScript)
+    if (outputGroup !== fromGroup) {
+      toGroup = outputGroup
+      break
+    }
+  }
+
+  return [fromGroup, toGroup]
+}
+
+function groupFromHint(hint: number): number {
+  const hash = xorByte(hint)
+  return hash % TOTAL_NUMBER_OF_GROUPS
+}

package/src/utils/utils.ts

@@ -156,8 +156,24 @@ export function concatBytes(arrays: Uint8Array[]): Uint8Array {
   return result
 }
 
+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
+}
+
 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] }>
 // eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars
 export function assertType<T extends true>(): void {}
 export type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>
+
+export type Narrow<type> =
+  | (unknown extends type ? unknown : never)
+  // eslint-disable-next-line @typescript-eslint/ban-types
+  | (type extends Function ? type : never)
+  | (type extends bigint | boolean | number | string ? type : never)
+  | (type extends [] ? [] : never)
+  | { [K in keyof type]: Narrow<type[K]> }