@alephium/web3 0.40.0 → 0.42.0

package/src/block/block.ts

@@ -0,0 +1,139 @@
+/*
+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/>.
+*/
+
+import { Subscription, SubscribeOptions } from '../utils/subscription'
+import * as node from '../api/api-alephium'
+import { NodeProvider } from '../api'
+import * as web3 from '../global'
+
+export type ReorgCallback = (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> {
+  abstract readonly reorgCallback?: ReorgCallback
+  abstract readonly fromGroup: number
+  abstract readonly toGroup: number
+
+  abstract getHashesAtHeight(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
+    return block.deps[index]
+  }
+
+  protected async handleReorg(blockHash: string, blockHeight: number) {
+    console.info(`reorg occur, hash: ${blockHash}, height: ${blockHeight}`)
+    if (this.reorgCallback === undefined) return
+
+    const orphans: string[] = []
+    const newHashes: string[] = []
+    let fromHash = blockHash
+    let fromHeight = blockHeight
+    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 {
+        break
+      }
+    }
+
+    const orphanBlocks: node.BlockEntry[] = []
+    for (const hash of orphans.reverse()) {
+      const block = await this.getBlockByHash(hash)
+      orphanBlocks.push(block)
+    }
+
+    const newBlocks: node.BlockEntry[] = []
+    for (const hash of newHashes.reverse()) {
+      const block = await this.getBlockByHash(hash)
+      newBlocks.push(block)
+    }
+    console.info(`orphan hashes: ${orphanBlocks.map((b) => b.hash)}, new hashes: ${newBlocks.map((b) => b.hash)}`)
+    await this.reorgCallback(orphanBlocks, newBlocks)
+  }
+}
+
+export class BlockSubscription extends BlockSubscriptionBase {
+  readonly nodeProvider: NodeProvider
+  readonly fromGroup: number
+  readonly toGroup: number
+  readonly reorgCallback?: ReorgCallback
+  private currentBlockHeight: number
+  private parentBlockHash: string | undefined
+
+  constructor(
+    options: BlockSubscribeOptions,
+    fromGroup: number,
+    toGroup: number,
+    fromBlockHeight: 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
+  }
+
+  override async getHashesAtHeight(height: number): Promise<string[]> {
+    const result = await this.nodeProvider.blockflow.getBlockflowHashes({
+      fromGroup: this.fromGroup,
+      toGroup: this.toGroup,
+      height
+    })
+    return result.headers
+  }
+
+  override async getBlockByHash(hash: string): Promise<node.BlockEntry> {
+    return await this.nodeProvider.blockflow.getBlockflowBlocksBlockHash(hash)
+  }
+
+  override async polling(): Promise<void> {
+    try {
+      const chainInfo = await this.nodeProvider.blockflow.getBlockflowChainInfo({
+        fromGroup: this.fromGroup,
+        toGroup: this.toGroup
+      })
+
+      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]
+      }
+    } catch (err) {
+      await this.errorCallback(err, this)
+    }
+  }
+}

package/src/block/index.ts

@@ -0,0 +1,19 @@
+/*
+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/>.
+*/
+
+export { ReorgCallback, BlockSubscribeOptions, BlockSubscription } from './block'

package/src/codec/contract-output-codec.ts

@@ -24,7 +24,7 @@ import { Codec } from './codec'
 import { Token, tokensCodec } from './token-codec'
 import { ContractOutput as ApiContractOutput } from '../api/api-alephium'
 import { blakeHash, createHint } from './hash'
-import { binToHex, bs58 } from '..'
+import { binToHex, bs58 } from '../utils'
 import { signedIntCodec } from './signed-int-codec'
 import { lockupScriptCodec } from './lockup-script-codec'
 

package/src/codec/lockup-script-codec.ts

@@ -17,7 +17,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
-import { DecodedCompactInt, compactUnsignedIntCodec } from './compact-int-codec'
+import { DecodedCompactInt, compactSignedIntCodec } from './compact-int-codec'
 import { Codec } from './codec'
 import { ArrayCodec, DecodedArray } from './array-codec'
 
@@ -41,7 +41,7 @@ const publicKeyHashCodec = new PublicKeyHashCodec()
 const publicKeyHashesCodec = new ArrayCodec(publicKeyHashCodec)
 const multiSigParser = Parser.start()
   .nest('publicKeyHashes', { type: publicKeyHashesCodec.parser })
-  .nest('m', { type: compactUnsignedIntCodec.parser })
+  .nest('m', { type: compactSignedIntCodec.parser })
 export interface MultiSig {
   publicKeyHashes: DecodedArray<PublicKeyHash>
   m: DecodedCompactInt
@@ -79,7 +79,7 @@ export class LockupScriptCodec implements Codec<LockupScript> {
       result.push(...(input.script as PublicKeyHash).publicKeyHash)
     } else if (input.scriptType === 1) {
       result.push(...publicKeyHashesCodec.encode((input.script as MultiSig).publicKeyHashes.value))
-      result.push(...compactUnsignedIntCodec.encode((input.script as MultiSig).m))
+      result.push(...compactSignedIntCodec.encode((input.script as MultiSig).m))
     } else if (input.scriptType === 2) {
       result.push(...(input.script as P2SH).scriptHash)
     } else if (input.scriptType === 3) {

package/src/codec/method-codec.ts

@@ -33,13 +33,51 @@ export interface DecodedMethod {
 
 export interface Method {
   isPublic: boolean
-  assetModifier: number
+  usePreapprovedAssets: boolean
+  useContractAssets: boolean
+  usePayToContractOnly: boolean
   argsLength: number
   localsLength: number
   returnLength: number
   instrs: Instr[]
 }
 
+function decodeAssetModifier(encoded: number): {
+  usePreapprovedAssets: boolean
+  useContractAssets: boolean
+  usePayToContractOnly: boolean
+} {
+  const usePayToContractOnly = (encoded & 4) !== 0
+  switch (encoded & 3) {
+    case 0:
+      return { usePayToContractOnly, usePreapprovedAssets: false, useContractAssets: false }
+    case 1:
+      return { usePayToContractOnly, usePreapprovedAssets: true, useContractAssets: true }
+    case 2:
+      return { usePayToContractOnly, usePreapprovedAssets: false, useContractAssets: true }
+    case 3:
+      return { usePayToContractOnly, usePreapprovedAssets: true, useContractAssets: false }
+    default:
+      throw new Error(`Invalid asset modifier: ${encoded}`)
+  }
+}
+
+function encodeAssetModifier(arg: {
+  usePreapprovedAssets: boolean
+  useContractAssets: boolean
+  usePayToContractOnly: boolean
+}): number {
+  const encoded =
+    !arg.usePreapprovedAssets && !arg.useContractAssets
+      ? 0
+      : arg.usePreapprovedAssets && arg.useContractAssets
+      ? 1
+      : !arg.usePreapprovedAssets && arg.useContractAssets
+      ? 2
+      : 3
+  return encoded | (arg.usePayToContractOnly ? 4 : 0)
+}
+
 export class MethodCodec implements Codec<DecodedMethod> {
   parser = Parser.start()
     .uint8('isPublic')
@@ -73,7 +111,7 @@ export class MethodCodec implements Codec<DecodedMethod> {
   static toMethod(decodedMethod: DecodedMethod): Method {
     return {
       isPublic: decodedMethod.isPublic === 1,
-      assetModifier: decodedMethod.assetModifier,
+      ...decodeAssetModifier(decodedMethod.assetModifier),
       argsLength: compactUnsignedIntCodec.toU32(decodedMethod.argsLength),
       localsLength: compactUnsignedIntCodec.toU32(decodedMethod.localsLength),
       returnLength: compactUnsignedIntCodec.toU32(decodedMethod.returnLength),
@@ -84,7 +122,7 @@ export class MethodCodec implements Codec<DecodedMethod> {
   static fromMethod(method: Method): DecodedMethod {
     return {
       isPublic: method.isPublic ? 1 : 0,
-      assetModifier: method.assetModifier,
+      assetModifier: encodeAssetModifier(method),
       argsLength: compactUnsignedIntCodec.fromU32(method.argsLength),
       localsLength: compactUnsignedIntCodec.fromU32(method.localsLength),
       returnLength: compactUnsignedIntCodec.fromU32(method.returnLength),

package/src/codec/script-codec.ts

@@ -15,30 +15,48 @@ 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/>.
 */
+
 import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { DecodedArray } from './array-codec'
 import { Codec } from './codec'
-import { DecodedMethod, methodsCodec } from './method-codec'
+import { DecodedMethod, methodsCodec, Method, MethodCodec } from './method-codec'
 import { OptionCodec } from './option-codec'
+import { compactUnsignedIntCodec } from './compact-int-codec'
 
-export interface Script {
+export interface DecodedScript {
   methods: DecodedArray<DecodedMethod>
 }
 
-export class ScriptCodec implements Codec<Script> {
+export interface Script {
+  methods: Method[]
+}
+
+export class ScriptCodec implements Codec<DecodedScript> {
   parser = Parser.start().nest('methods', {
     type: methodsCodec.parser
   })
 
-  encode(input: Script): Buffer {
+  encode(input: DecodedScript): Buffer {
     const script = methodsCodec.encode(input.methods.value)
     return Buffer.from(script)
   }
 
-  decode(input: Buffer): Script {
+  decode(input: Buffer): DecodedScript {
     return this.parser.parse(input)
   }
+
+  decodeScript(input: Buffer): Script {
+    const decodedTxScript = this.decode(input)
+    const methods = decodedTxScript.methods.value.map((decodedMethod) => MethodCodec.toMethod(decodedMethod))
+    return { methods }
+  }
+
+  encodeScript(inputTxScript: Script): Buffer {
+    const methodLength = compactUnsignedIntCodec.fromU32(inputTxScript.methods.length)
+    const decodedMethods = inputTxScript.methods.map((method) => MethodCodec.fromMethod(method))
+    return this.encode({ methods: { value: decodedMethods, length: methodLength } })
+  }
 }
 
 export const scriptCodec = new ScriptCodec()

package/src/codec/transaction-codec.ts

@@ -27,7 +27,7 @@ import { Either } from './either-codec'
 import { AssetOutput, AssetOutputCodec } from './asset-output-codec'
 import { ContractOutput, ContractOutputCodec } from './contract-output-codec'
 import { FixedAssetOutput, Transaction as ApiTransaction } from '../api/api-alephium'
-import { hexToBinUnsafe } from '..'
+import { hexToBinUnsafe } from '../utils'
 import { ContractOutput as ApiContractOutput } from '../api/api-alephium'
 import { Codec } from './codec'
 import { Output, outputCodec, outputsCodec } from './output-codec'

package/src/codec/unlock-script-codec.ts

@@ -20,7 +20,7 @@ import { Parser } from 'binary-parser'
 import { ArrayCodec, DecodedArray } from './array-codec'
 import { compactUnsignedIntCodec, compactSignedIntCodec, DecodedCompactInt } from './compact-int-codec'
 import { Codec } from './codec'
-import { Script, scriptCodec } from './script-codec'
+import { DecodedScript, Script, scriptCodec } from './script-codec'
 import { ByteString, byteStringCodec } from './bytestring-codec'
 import { LockupScript, lockupScriptCodec } from './lockup-script-codec'
 
@@ -122,7 +122,7 @@ const valCodec = new ValCodec()
 const valsCodec = new ArrayCodec(valCodec)
 
 export interface P2SH {
-  script: Script
+  script: DecodedScript
   params: DecodedArray<Val>
 }
 

package/src/codec/unsigned-tx-codec.ts

@@ -19,7 +19,7 @@ import { Buffer } from 'buffer/'
 import { Parser } from 'binary-parser'
 import { UnsignedTx as ApiUnsignedTx } from '../api/api-alephium'
 import { binToHex, hexToBinUnsafe } from '../utils'
-import { Script, scriptCodec, statefulScriptCodecOpt } from './script-codec'
+import { DecodedScript, scriptCodec, statefulScriptCodecOpt } from './script-codec'
 import { Option } from './option-codec'
 import { DecodedCompactInt, compactSignedIntCodec, compactUnsignedIntCodec } from './compact-int-codec'
 import { Input, InputCodec, inputsCodec } from './input-codec'
@@ -31,7 +31,7 @@ import { Codec } from './codec'
 export interface UnsignedTx {
   version: number
   networkId: number
-  statefulScript: Option<Script>
+  statefulScript: Option<DecodedScript>
   gasAmount: DecodedCompactInt
   gasPrice: DecodedCompactInt
   inputs: DecodedArray<Input>