@alephium/web3 0.44.0 → 1.0.0

package/src/api/api-explorer.ts

@@ -97,6 +97,23 @@ export interface BlockEntryLite {
   hashRate: string
 }
 
+export interface ContractLiveness {
+  /** @format address */
+  parent?: string
+  creation: ContractLivenessLocation
+  destruction?: ContractLivenessLocation
+  interfaceId?: StdInterfaceId
+}
+
+export interface ContractLivenessLocation {
+  /** @format block-hash */
+  blockHash: string
+  /** @format 32-byte-hash */
+  txHash: string
+  /** @format int64 */
+  timestamp: number
+}
+
 export interface ContractOutput {
   /** @format int32 */
   hint: number
@@ -140,6 +157,10 @@ export interface ExplorerInfo {
   lastFinalizedInputTime: number
 }
 
+export interface FungibleToken {
+  type: string
+}
+
 export interface FungibleTokenMetadata {
   /** @format 32-byte-hash */
   id: string
@@ -207,12 +228,24 @@ export interface MempoolTransaction {
   lastSeen: number
 }
 
+export interface NFT {
+  type: string
+}
+
+export interface NFTCollection {
+  type: string
+}
+
 export interface NFTCollectionMetadata {
   /** @format address */
   address: string
   collectionUri: string
 }
 
+export interface NFTCollectionWithRoyalty {
+  type: string
+}
+
 export interface NFTMetadata {
   /** @format 32-byte-hash */
   id: string
@@ -223,6 +256,10 @@ export interface NFTMetadata {
   nftIndex: string
 }
 
+export interface NonStandard {
+  type: string
+}
+
 export interface NotFound {
   detail: string
   resource: string
@@ -296,6 +333,8 @@ export interface ServiceUnavailable {
   detail: string
 }
 
+export type StdInterfaceId = FungibleToken | NFT | NFTCollection | NFTCollectionWithRoyalty | NonStandard | Unknown
+
 export interface SubContracts {
   subContracts?: string[]
 }
@@ -377,6 +416,11 @@ export interface Unauthorized {
   detail: string
 }
 
+export interface Unknown {
+  id: string
+  type: string
+}
+
 export type Val = ValAddress | ValArray | ValBool | ValByteVec | ValI256 | ValU256
 
 export interface ValAddress {
@@ -988,6 +1032,21 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse),
 
+    /**
+     * @description Get public key of p2pkh addresses, the address needs to have at least one input.
+     *
+     * @tags Addresses
+     * @name GetAddressesAddressPublicKey
+     * @request GET:/addresses/{address}/public-key
+     */
+    getAddressesAddressPublicKey: (address: string, params: RequestParams = {}) =>
+      this.request<string, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/addresses/${address}/public-key`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * @description Get address tokens with balance
      *
@@ -1674,6 +1733,21 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
       }).then(convertHttpResponse)
   }
   contracts = {
+    /**
+     * @description Get contract liveness
+     *
+     * @tags Contracts
+     * @name GetContractsContractAddressCurrentLiveness
+     * @request GET:/contracts/{contract_address}/current-liveness
+     */
+    getContractsContractAddressCurrentLiveness: (contractAddress: string, params: RequestParams = {}) =>
+      this.request<ContractLiveness, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
+        path: `/contracts/${contractAddress}/current-liveness`,
+        method: 'GET',
+        format: 'json',
+        ...params
+      }).then(convertHttpResponse),
+
     /**
      * @description Get contract parent address if exist
      *

package/src/block/block.ts

@@ -20,94 +20,90 @@ import { Subscription, SubscribeOptions } from '../utils/subscription'
 import * as node from '../api/api-alephium'
 import { NodeProvider } from '../api'
 import * as web3 from '../global'
+import { TOTAL_NUMBER_OF_CHAINS } from '../constants'
 
-export type ReorgCallback = (orphanBlocks: node.BlockEntry[], newBlocks: node.BlockEntry[]) => Promise<void> | void
+const DEFAULT_INTERVAL = 60 * 1000 // 60 seconds
+const EXPIRE_DURATION = 20 * 1000 // 20 seconds
 
-export interface BlockSubscribeOptions extends SubscribeOptions<node.BlockEntry> {
+export type ReorgCallback = (
+  fromGroup: number,
+  toGroup: number,
+  orphanBlocks: node.BlockEntry[],
+  newBlocks: node.BlockEntry[]
+) => Promise<void> | void
+
+export interface BlockSubscribeOptions extends SubscribeOptions<node.BlockEntry[]> {
   reorgCallback?: ReorgCallback
 }
 
-export abstract class BlockSubscriptionBase extends Subscription<node.BlockEntry> {
+export abstract class BlockSubscriptionBase extends Subscription<node.BlockEntry[]> {
   abstract readonly reorgCallback?: ReorgCallback
-  abstract readonly fromGroup: number
-  abstract readonly toGroup: number
 
-  abstract getHashesAtHeight(height: number): Promise<string[]>
+  abstract getHashesAtHeight(fromGroup: number, toGroup: number, height: number): Promise<string[]>
   abstract getBlockByHash(hash: string): Promise<node.BlockEntry>
 
   protected getParentHash(block: node.BlockEntry): string {
-    const index = Math.floor(block.deps.length / 2) + this.toGroup
+    const index = Math.floor(block.deps.length / 2) + block.chainTo
     return block.deps[index]
   }
 
-  protected async handleReorg(blockHash: string, blockHeight: number) {
-    console.info(`reorg occur, hash: ${blockHash}, height: ${blockHeight}`)
+  protected async handleReorg(fromGroup: number, toGroup: number, orphanBlockHash: string, newBlockHash: string) {
+    console.info(
+      `reorg occur in chain ${fromGroup} -> ${toGroup}, orphan hash: ${orphanBlockHash}, new hash: ${newBlockHash}`
+    )
     if (this.reorgCallback === undefined) return
 
-    const orphans: string[] = []
-    const newHashes: string[] = []
-    let fromHash = blockHash
-    let fromHeight = blockHeight
+    const orphanBlocks: node.BlockEntry[] = []
+    let fromHash = orphanBlockHash
+    let canonicalHash: string | undefined = undefined
     while (true) {
-      const hashes = await this.getHashesAtHeight(fromHeight)
-      const canonicalHash = hashes[0]
-      if (canonicalHash !== fromHash) {
-        orphans.push(fromHash)
-        newHashes.push(canonicalHash)
-        const block = await this.getBlockByHash(fromHash)
-        fromHash = this.getParentHash(block)
-        fromHeight -= 1
-      } else {
+      const orphanBlock = await this.getBlockByHash(fromHash)
+      orphanBlocks.push(orphanBlock)
+      const hashes = await this.getHashesAtHeight(fromGroup, toGroup, orphanBlock.height - 1)
+      const parentHash = this.getParentHash(orphanBlock)
+      if (hashes[0] === parentHash) {
+        canonicalHash = hashes[0]
         break
       }
-    }
-
-    const orphanBlocks: node.BlockEntry[] = []
-    for (const hash of orphans.reverse()) {
-      const block = await this.getBlockByHash(hash)
-      orphanBlocks.push(block)
+      fromHash = parentHash
     }
 
     const newBlocks: node.BlockEntry[] = []
-    for (const hash of newHashes.reverse()) {
-      const block = await this.getBlockByHash(hash)
-      newBlocks.push(block)
+    fromHash = newBlockHash
+    while (fromHash !== canonicalHash) {
+      const newBlock = await this.getBlockByHash(fromHash)
+      newBlocks.push(newBlock)
+      fromHash = this.getParentHash(newBlock)
     }
-    console.info(`orphan hashes: ${orphanBlocks.map((b) => b.hash)}, new hashes: ${newBlocks.map((b) => b.hash)}`)
-    await this.reorgCallback(orphanBlocks, newBlocks)
+    const orphans = orphanBlocks.reverse()
+    const news = newBlocks.reverse()
+    console.info(`orphan hashes: ${orphans.map((b) => b.hash)}, new hashes: ${news.map((b) => b.hash)}`)
+    await this.reorgCallback(fromGroup, toGroup, orphans, news)
   }
 }
 
 export class BlockSubscription extends BlockSubscriptionBase {
   readonly nodeProvider: NodeProvider
-  readonly fromGroup: number
-  readonly toGroup: number
   readonly reorgCallback?: ReorgCallback
-  private currentBlockHeight: number
-  private parentBlockHash: string | undefined
+  private fromTimeStamp: number
+  private parents: ({ hash: string; height: number } | undefined)[]
+  private cache: Map<string, number>
 
   constructor(
     options: BlockSubscribeOptions,
-    fromGroup: number,
-    toGroup: number,
-    fromBlockHeight: number,
+    fromTimeStamp: number,
     nodeProvider: NodeProvider | undefined = undefined
   ) {
     super(options)
     this.nodeProvider = nodeProvider ?? web3.getCurrentNodeProvider()
-    this.fromGroup = fromGroup
-    this.toGroup = toGroup
     this.reorgCallback = options.reorgCallback
-    this.currentBlockHeight = fromBlockHeight
-    this.parentBlockHash = undefined
+    this.fromTimeStamp = fromTimeStamp
+    this.parents = new Array(TOTAL_NUMBER_OF_CHAINS).fill(undefined)
+    this.cache = new Map()
   }
 
-  override async getHashesAtHeight(height: number): Promise<string[]> {
-    const result = await this.nodeProvider.blockflow.getBlockflowHashes({
-      fromGroup: this.fromGroup,
-      toGroup: this.toGroup,
-      height
-    })
+  override async getHashesAtHeight(fromGroup: number, toGroup: number, height: number): Promise<string[]> {
+    const result = await this.nodeProvider.blockflow.getBlockflowHashes({ fromGroup, toGroup, height })
     return result.headers
   }
 
@@ -115,25 +111,72 @@ export class BlockSubscription extends BlockSubscriptionBase {
     return await this.nodeProvider.blockflow.getBlockflowBlocksBlockHash(hash)
   }
 
-  override async polling(): Promise<void> {
+  private async getMissingBlocksAndHandleReorg(fromHash: string, fromHeight: number, toBlock: node.BlockEntry) {
+    const blocks: node.BlockEntry[] = []
+    let lastBlock = toBlock
+    while (lastBlock.height - 1 > fromHeight) {
+      const parentHash = this.getParentHash(lastBlock)
+      const block = await this.getBlockByHash(parentHash)
+      blocks.push(block)
+      lastBlock = block
+    }
+    const parentHash = this.getParentHash(lastBlock)
+    if (parentHash !== fromHash) {
+      await this.handleReorg(toBlock.chainFrom, toBlock.chainTo, fromHash, parentHash)
+    }
+    return blocks.reverse()
+  }
+
+  private async handleBlocks(blocks: node.BlockEntry[][], now: number) {
+    const allBlocks: node.BlockEntry[] = []
+    for (let index = 0; index < blocks.length; index += 1) {
+      const blocksPerChain = blocks[index].filter((b) => !this.cache.has(b.hash))
+      if (blocksPerChain.length === 0) continue
+
+      allBlocks.push(...blocksPerChain)
+      const parent = this.parents[index]
+      if (parent !== undefined) {
+        const missingBlocks = await this.getMissingBlocksAndHandleReorg(parent.hash, parent.height, blocksPerChain[0])
+        allBlocks.push(...missingBlocks)
+      }
+      const latestBlock = blocksPerChain[blocksPerChain.length - 1]
+      this.parents[index] = { hash: latestBlock.hash, height: latestBlock.height }
+    }
+
+    const sortedBlocks = allBlocks.sort((a, b) => a.timestamp - b.timestamp)
     try {
-      const chainInfo = await this.nodeProvider.blockflow.getBlockflowChainInfo({
-        fromGroup: this.fromGroup,
-        toGroup: this.toGroup
+      await this.messageCallback(sortedBlocks)
+    } finally {
+      const threshold = now - EXPIRE_DURATION
+      Array.from(this.cache.entries()).forEach(([hash, ts]) => {
+        if (ts < threshold) this.cache.delete(hash)
       })
+      const index = sortedBlocks.findIndex((b) => b.timestamp >= threshold)
+      if (index !== -1) {
+        sortedBlocks.slice(index).forEach((b) => this.cache.set(b.hash, b.timestamp))
+      }
+    }
+  }
 
-      while (this.currentBlockHeight <= chainInfo.currentHeight) {
-        const hashes = await this.getHashesAtHeight(this.currentBlockHeight)
-        const block = await this.getBlockByHash(hashes[0])
-        if (this.parentBlockHash !== undefined && this.getParentHash(block) !== this.parentBlockHash) {
-          await this.handleReorg(this.parentBlockHash, this.currentBlockHeight - 1)
-        }
-        await this.messageCallback(block)
-        this.currentBlockHeight += 1
-        this.parentBlockHash = hashes[0]
+  override async polling(): Promise<void> {
+    const now = Date.now()
+    if (this.fromTimeStamp >= now) return
+
+    while (this.fromTimeStamp < now) {
+      if (this.isCancelled()) return
+      const toTs = Math.min(this.fromTimeStamp + DEFAULT_INTERVAL, now)
+      try {
+        const result = await this.nodeProvider.blockflow.getBlockflowBlocks({ fromTs: this.fromTimeStamp, toTs })
+        await this.handleBlocks(result.blocks, now)
+      } catch (err) {
+        await this.errorCallback(err, this)
+      }
+
+      if (this.fromTimeStamp + EXPIRE_DURATION < now) {
+        this.fromTimeStamp = Math.min(toTs + 1, now - EXPIRE_DURATION)
+      } else {
+        return
       }
-    } catch (err) {
-      await this.errorCallback(err, this)
     }
   }
 }