@alephium/web3 0.39.3 → 0.41.0

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>

package/src/contract/contract.ts

@@ -34,7 +34,8 @@ import {
   getDefaultPrimitiveValue,
   PrimitiveTypes,
   decodeArrayType,
-  fromApiPrimitiveVal
+  fromApiPrimitiveVal,
+  tryGetCallResult
 } from '../api'
 import { CompileProjectResult } from '../api/api-alephium'
 import {
@@ -87,7 +88,7 @@ const crypto = new WebCrypto()
 export type FieldsSig = node.FieldsSig
 export type MapsSig = node.MapsSig
 export type EventSig = node.EventSig
-export type FunctionSig = node.FunctionSig
+export type FunctionSig = Omit<node.FunctionSig, 'isPublic' | 'usePreapprovedAssets' | 'useAssetsInContract'>
 export type Fields = NamedVals
 export type Arguments = NamedVals
 export type Constant = node.Constant
@@ -280,7 +281,18 @@ export class ProjectArtifact {
     return fsPromises.writeFile(filepath, content)
   }
 
-  needToReCompile(compilerOptions: node.CompilerOptions, sourceInfos: SourceInfo[], fullNodeVersion: string): boolean {
+  getChangedSources(sourceInfos: SourceInfo[]): SourceInfo[] {
+    const result: SourceInfo[] = []
+    for (const sourceInfo of sourceInfos) {
+      const info = this.infos.get(sourceInfo.name)
+      if (typeof info === 'undefined' || info.sourceCodeHash !== sourceInfo.sourceCodeHash) {
+        result.push(sourceInfo)
+      }
+    }
+    return result
+  }
+
+  needToReCompile(compilerOptions: node.CompilerOptions, fullNodeVersion: string): boolean {
     ProjectArtifact.checkCompilerOptionsParameter(compilerOptions)
     if (this.fullNodeVersion !== fullNodeVersion) {
       return true
@@ -294,16 +306,6 @@ export class ProjectArtifact {
       return true
     }
 
-    if (sourceInfos.length !== this.infos.size) {
-      return true
-    }
-    for (const sourceInfo of sourceInfos) {
-      const info = this.infos.get(sourceInfo.name)
-      if (typeof info === 'undefined' || info.sourceCodeHash !== sourceInfo.sourceCodeHash) {
-        return true
-      }
-    }
-
     return false
   }
 
@@ -326,15 +328,22 @@ export class ProjectArtifact {
   }
 }
 
-function removeOldArtifacts(dir: string) {
+function removeOldArtifacts(dir: string, sourceFiles: SourceInfo[]) {
   const files = fs.readdirSync(dir)
   files.forEach((file) => {
     const filePath = path.join(dir, file)
     const stat = fs.statSync(filePath)
     if (stat.isDirectory()) {
-      removeOldArtifacts(filePath)
+      removeOldArtifacts(filePath, sourceFiles)
     } else if (filePath.endsWith('.ral.json') || filePath.endsWith('.ral')) {
-      fs.unlinkSync(filePath)
+      const filename = path.basename(filePath)
+      const artifactName = filename.slice(0, filename.indexOf('.'))
+      const sourceFile = sourceFiles.find(
+        (s) => s.name === artifactName && (s.type === SourceKind.Contract || s.type === SourceKind.Script)
+      )
+      if (sourceFile === undefined) {
+        fs.unlinkSync(filePath)
+      }
     }
   })
 
@@ -521,7 +530,11 @@ export class Project {
     return fsPromises.writeFile(filePath, JSON.stringify(structs, null, 2))
   }
 
-  private async saveArtifactsToFile(projectRootDir: string): Promise<void> {
+  private async saveArtifactsToFile(
+    projectRootDir: string,
+    skipSaveArtifacts: boolean,
+    changedSources: SourceInfo[]
+  ): Promise<void> {
     const artifactsRootDir = this.artifactsRootDir
     const saveToFile = async function (compiled: Compiled<Artifact>): Promise<void> {
       const artifactPath = compiled.sourceInfo.getArtifactPath(artifactsRootDir)
@@ -531,9 +544,32 @@ export class Project {
       }
       return fsPromises.writeFile(artifactPath, compiled.artifact.toString())
     }
-    this.contracts.forEach((contract) => saveToFile(contract))
-    this.scripts.forEach((script) => saveToFile(script))
-    this.saveStructsToFile()
+    for (const [_, contract] of this.contracts) {
+      if (!skipSaveArtifacts || changedSources.find((s) => s.name === contract.sourceInfo.name) !== undefined) {
+        await saveToFile(contract)
+      }
+    }
+    for (const [_, script] of this.scripts) {
+      await saveToFile(script)
+    }
+    await this.saveStructsToFile()
+    await this.saveProjectArtifact(projectRootDir, skipSaveArtifacts, changedSources)
+  }
+
+  private async saveProjectArtifact(projectRootDir: string, skipSaveArtifacts: boolean, changedSources: SourceInfo[]) {
+    if (skipSaveArtifacts) {
+      // we should not update the `codeHashDebug` if the `skipSaveArtifacts` is enabled
+      const prevProjectArtifact = await ProjectArtifact.from(projectRootDir)
+      if (prevProjectArtifact !== undefined) {
+        for (const [name, info] of this.projectArtifact.infos) {
+          if (changedSources.find((s) => s.name === name) === undefined) {
+            const prevInfo = prevProjectArtifact.infos.get(name)
+            info.bytecodeDebugPatch = prevInfo?.bytecodeDebugPatch ?? info.bytecodeDebugPatch
+            info.codeHashDebug = prevInfo?.codeHashDebug ?? info.codeHashDebug
+          }
+        }
+      }
+    }
     await this.projectArtifact.saveToFile(projectRootDir)
   }
 
@@ -587,7 +623,9 @@ export class Project {
     contractsRootDir: string,
     artifactsRootDir: string,
     errorOnWarnings: boolean,
-    compilerOptions: node.CompilerOptions
+    compilerOptions: node.CompilerOptions,
+    changedSources: SourceInfo[],
+    skipSaveArtifacts = false
   ): Promise<Project> {
     const removeDuplicates = sourceInfos.reduce((acc: SourceInfo[], sourceInfo: SourceInfo) => {
       if (acc.find((info) => info.sourceCodeHash === sourceInfo.sourceCodeHash) === undefined) {
@@ -639,20 +677,23 @@ export class Project {
       errorOnWarnings,
       projectArtifact
     )
-    await project.saveArtifactsToFile(projectRootDir)
+    await project.saveArtifactsToFile(projectRootDir, skipSaveArtifacts, changedSources)
     return project
   }
 
   private static async loadArtifacts(
     provider: NodeProvider,
     sourceInfos: SourceInfo[],
-    projectArtifact: ProjectArtifact,
     projectRootDir: string,
     contractsRootDir: string,
     artifactsRootDir: string,
     errorOnWarnings: boolean,
     compilerOptions: node.CompilerOptions
   ): Promise<Project> {
+    const projectArtifact = await ProjectArtifact.from(projectRootDir)
+    if (projectArtifact === undefined) {
+      throw Error('Failed to load project artifact')
+    }
     try {
       const contracts = new Map<string, Compiled<Contract>>()
       const scripts = new Map<string, Compiled<Script>>()
@@ -698,7 +739,8 @@ export class Project {
         contractsRootDir,
         artifactsRootDir,
         errorOnWarnings,
-        compilerOptions
+        compilerOptions,
+        sourceInfos
       )
     }
   }
@@ -821,19 +863,22 @@ export class Project {
     projectRootDir = '.',
     contractsRootDir = Project.DEFAULT_CONTRACTS_DIR,
     artifactsRootDir = Project.DEFAULT_ARTIFACTS_DIR,
-    defaultFullNodeVersion: string | undefined = undefined
+    defaultFullNodeVersion: string | undefined = undefined,
+    skipSaveArtifacts = false
   ): Promise<void> {
     const provider = getCurrentNodeProvider()
     const fullNodeVersion = defaultFullNodeVersion ?? (await provider.infos.getInfosVersion()).version
     const sourceFiles = await Project.loadSourceFiles(projectRootDir, contractsRootDir)
     const { errorOnWarnings, ...nodeCompilerOptions } = { ...DEFAULT_COMPILER_OPTIONS, ...compilerOptionsPartial }
     const projectArtifact = await ProjectArtifact.from(projectRootDir)
+    const changedSources = projectArtifact?.getChangedSources(sourceFiles) ?? sourceFiles
     if (
       projectArtifact === undefined ||
-      projectArtifact.needToReCompile(nodeCompilerOptions, sourceFiles, fullNodeVersion)
+      projectArtifact.needToReCompile(nodeCompilerOptions, fullNodeVersion) ||
+      changedSources.length > 0
     ) {
       if (fs.existsSync(artifactsRootDir)) {
-        removeOldArtifacts(artifactsRootDir)
+        removeOldArtifacts(artifactsRootDir, sourceFiles)
       }
       console.log(`Compiling contracts in folder "${contractsRootDir}"`)
       Project.currentProject = await Project.compile(
@@ -844,21 +889,21 @@ export class Project {
         contractsRootDir,
         artifactsRootDir,
         errorOnWarnings,
-        nodeCompilerOptions
-      )
-    } else {
-      console.log(`Contracts are compiled already. Loading them from folder "${artifactsRootDir}"`)
-      Project.currentProject = await Project.loadArtifacts(
-        provider,
-        sourceFiles,
-        projectArtifact,
-        projectRootDir,
-        contractsRootDir,
-        artifactsRootDir,
-        errorOnWarnings,
-        nodeCompilerOptions
+        nodeCompilerOptions,
+        changedSources,
+        skipSaveArtifacts
       )
     }
+    // we need to reload those contracts that did not regenerate bytecode
+    Project.currentProject = await Project.loadArtifacts(
+      provider,
+      sourceFiles,
+      projectRootDir,
+      contractsRootDir,
+      artifactsRootDir,
+      errorOnWarnings,
+      nodeCompilerOptions
+    )
   }
 }
 
@@ -875,18 +920,6 @@ export abstract class Artifact {
 
   abstract buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean): string
 
-  publicFunctions(): string[] {
-    return this.functions.filter((func) => func.isPublic).map((func) => func.name)
-  }
-
-  usingPreapprovedAssetsFunctions(): string[] {
-    return this.functions.filter((func) => func.usePreapprovedAssets).map((func) => func.name)
-  }
-
-  usingAssetsInContractFunctions(): string[] {
-    return this.functions.filter((func) => func.useAssetsInContract).map((func) => func.name)
-  }
-
   async isDevnet(signer: SignerProvider): Promise<boolean> {
     if (!signer.nodeProvider) {
       return false
@@ -896,6 +929,16 @@ export abstract class Artifact {
   }
 }
 
+function fromFunctionSig(sig: node.FunctionSig): FunctionSig {
+  return {
+    name: sig.name,
+    paramNames: sig.paramNames,
+    paramTypes: sig.paramTypes,
+    paramIsMutable: sig.paramIsMutable,
+    returnTypes: sig.returnTypes
+  }
+}
+
 export class Contract extends Artifact {
   readonly bytecode: string
   readonly bytecodeDebugPatch: string
@@ -910,6 +953,7 @@ export class Contract extends Artifact {
 
   readonly bytecodeDebug: string
   readonly codeHashDebug: string
+  readonly decodedMethods: Method[]
 
   constructor(
     version: string,
@@ -941,6 +985,20 @@ export class Contract extends Artifact {
 
     this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch)
     this.codeHashDebug = codeHashDebug
+
+    this.decodedMethods = contract.contractCodec.decodeContract(Buffer.from(bytecode, 'hex')).methods
+  }
+
+  publicFunctions(): FunctionSig[] {
+    return this.functions.filter((_, index) => this.decodedMethods[`${index}`].isPublic)
+  }
+
+  usingPreapprovedAssetsFunctions(): FunctionSig[] {
+    return this.functions.filter((_, index) => this.decodedMethods[`${index}`].usePreapprovedAssets)
+  }
+
+  usingAssetsInContractFunctions(): FunctionSig[] {
+    return this.functions.filter((_, index) => this.decodedMethods[`${index}`].useContractAssets)
   }
 
   // TODO: safely parse json
@@ -987,7 +1045,7 @@ export class Contract extends Artifact {
       result.codeHashDebug,
       result.fields,
       result.events,
-      result.functions,
+      result.functions.map(fromFunctionSig),
       result.constants,
       result.enums,
       structs,
@@ -1348,7 +1406,7 @@ export class Script extends Artifact {
       result.bytecodeTemplate,
       result.bytecodeDebugPatch,
       result.fields,
-      result.functions,
+      result.functions.map(fromFunctionSig),
       structs
     )
   }
@@ -1831,14 +1889,14 @@ export function subscribeEventsFromContract<T extends Fields, M extends Contract
   decodeFunc: (event: node.ContractEvent) => M,
   fromCount?: number
 ): EventSubscription {
-  const messageCallback = (event: node.ContractEvent): Promise<void> => {
+  const messageCallback = (event: node.ContractEvent) => {
     if (event.eventIndex !== eventIndex) {
       return Promise.resolve()
     }
     return options.messageCallback(decodeFunc(event))
   }
 
-  const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>): Promise<void> => {
+  const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>) => {
     return options.errorCallback(err, subscription as unknown as Subscription<M>)
   }
   const opt: EventSubscribeOptions<node.ContractEvent> = {
@@ -1877,7 +1935,9 @@ function genCodeForType(type: string, structs: Struct[]): { bytecode: string; co
   const { immFields, mutFields } = ralph.calcFieldSize(type, true, structs)
   const loadImmFieldByIndex: Method = {
     isPublic: true,
-    assetModifier: 0,
+    usePreapprovedAssets: false,
+    useContractAssets: false,
+    usePayToContractOnly: false,
     argsLength: 1,
     localsLength: 1,
     returnLength: 1,
@@ -1905,7 +1965,9 @@ function genCodeForType(type: string, structs: Struct[]): { bytecode: string; co
   }
   const destroy: Method = {
     isPublic: true,
-    assetModifier: 2,
+    usePreapprovedAssets: false,
+    useContractAssets: true,
+    usePayToContractOnly: false,
     argsLength: 1,
     localsLength: 1,
     returnLength: 0,
@@ -2007,6 +2069,62 @@ export async function testMethod<
   } as TestContractResult<R, M>
 }
 
+export class RalphMap<K extends Val, V extends Val> {
+  private readonly groupIndex: number
+  constructor(
+    private readonly parentContract: Contract,
+    private readonly parentContractId: HexString,
+    private readonly mapName: string
+  ) {
+    this.groupIndex = groupOfAddress(addressFromContractId(parentContractId))
+  }
+
+  async get(key: K): Promise<V | undefined> {
+    return getMapItem(this.parentContract, this.parentContractId, this.groupIndex, this.mapName, key)
+  }
+
+  async contains(key: K): Promise<boolean> {
+    return this.get(key).then((v) => v !== undefined)
+  }
+
+  toJSON() {
+    return {
+      parentContractId: this.parentContractId,
+      mapName: this.mapName,
+      groupIndex: this.groupIndex
+    }
+  }
+}
+
+export async function getMapItem<R extends Val>(
+  parentContract: Contract,
+  parentContractId: HexString,
+  groupIndex: number,
+  mapName: string,
+  key: Val
+): Promise<R | undefined> {
+  const index = parentContract.mapsSig?.names.findIndex((name) => name === mapName)
+  const mapType = index === undefined ? undefined : parentContract.mapsSig?.types[`${index}`]
+  if (mapType === undefined) {
+    throw new Error(`Map ${mapName} does not exist in contract ${parentContract.name}`)
+  }
+  const [keyType, valueType] = ralph.parseMapType(mapType)
+  const mapItemContractId = calcWrapperContractId(parentContractId, index!, key, keyType, groupIndex)
+  const mapItemAddress = addressFromContractId(mapItemContractId)
+  try {
+    const state = await getCurrentNodeProvider().contracts.getContractsAddressState(mapItemAddress)
+    const fieldsSig = getContractFieldsSig(valueType)
+    const fields = fromApiFields(state.immFields, state.mutFields, fieldsSig, parentContract.structs)
+    return fields['value'] as R
+  } catch (error) {
+    if (error instanceof Error && error.message.includes('KeyNotFound')) {
+      // the map item contract does not exist
+      return undefined
+    }
+    throw error
+  }
+}
+
 interface MapInfo {
   name: string
   value: Map<Val, Val>
@@ -2221,13 +2339,13 @@ export function subscribeContractEvents(
   options: EventSubscribeOptions<ContractEvent<any>>,
   fromCount?: number
 ): EventSubscription {
-  const messageCallback = (event: node.ContractEvent): Promise<void> => {
+  const messageCallback = (event: node.ContractEvent) => {
     return options.messageCallback({
       ...decodeEvent(contract, instance, event, event.eventIndex),
       contractAddress: instance.address
     })
   }
-  const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>): Promise<void> => {
+  const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>) => {
     return options.errorCallback(err, subscription as unknown as Subscription<ContractEvent<any>>)
   }
   const opt: EventSubscribeOptions<node.ContractEvent> = {
@@ -2319,10 +2437,3 @@ export const getContractIdFromUnsignedTx = async (
 
 // This function only works in the simple case where a single non-subcontract is created in the tx
 export const getTokenIdFromUnsignedTx = getContractIdFromUnsignedTx
-
-export function tryGetCallResult(result: node.CallContractResult): node.CallContractSucceeded {
-  if (result.type === 'CallContractFailed') {
-    throw new Error(`Failed to call contract, error: ${(result as node.CallContractFailed).error}`)
-  }
-  return result as node.CallContractSucceeded
-}

package/src/contract/events.ts

@@ -16,33 +16,24 @@ 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 { web3 } from '..'
+import * as web3 from '../global'
 import { node } from '../api'
 import { Subscription, SubscribeOptions } from '../utils'
 
 export interface EventSubscribeOptions<Message> extends SubscribeOptions<Message> {
-  onEventCountChanged?: (eventCount: number) => Promise<void>
+  onEventCountChanged?: (eventCount: number) => Promise<void> | void
 }
 
 export class EventSubscription extends Subscription<node.ContractEvent> {
   readonly contractAddress: string
   private fromCount: number
-  private onEventCountChanged?: (eventCount: number) => Promise<void>
+  private onEventCountChanged?: (eventCount: number) => Promise<void> | void
 
   constructor(options: EventSubscribeOptions<node.ContractEvent>, contractAddress: string, fromCount?: number) {
     super(options)
     this.contractAddress = contractAddress
     this.fromCount = typeof fromCount === 'undefined' ? 0 : fromCount
     this.onEventCountChanged = options.onEventCountChanged
-
-    this.startPolling()
-  }
-
-  override startPolling(): void {
-    this.eventEmitter.on('tick', async () => {
-      await this.polling()
-    })
-    this.eventEmitter.emit('tick')
   }
 
   currentEventCount(): number {
@@ -54,12 +45,7 @@ export class EventSubscription extends Subscription<node.ContractEvent> {
       const events = await web3.getCurrentNodeProvider().events.getEventsContractContractaddress(this.contractAddress, {
         start: this.fromCount
       })
-      if (this.cancelled) {
-        return
-      }
-
       if (this.fromCount === events.nextStart) {
-        this.task = setTimeout(() => this.eventEmitter.emit('tick'), this.pollingInterval)
         return
       }
 
@@ -83,5 +69,7 @@ export function subscribeToEvents(
   contractAddress: string,
   fromCount?: number
 ): EventSubscription {
-  return new EventSubscription(options, contractAddress, fromCount)
+  const subscription = new EventSubscription(options, contractAddress, fromCount)
+  subscription.subscribe()
+  return subscription
 }

package/src/index.ts

@@ -32,3 +32,4 @@ export * as web3 from './global'
 export * as codec from './codec'
 export * as utils from './utils'
 export * from './debug'
+export * from './block'

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 { utils } from '..'
+import { binToHex, contractIdFromAddress } from '../utils'
 import { fromApiNumber256, node, NodeProvider, toApiNumber256Optional, toApiTokens } from '../api'
 import { addressFromPublicKey } from '../utils'
 import { toApiDestinations } from './signer'
@@ -90,7 +90,7 @@ export abstract class TransactionBuilder {
       ...rest
     }
     const response = await this.nodeProvider.contracts.postContractsUnsignedTxDeployContract(data)
-    const contractId = utils.binToHex(utils.contractIdFromAddress(response.contractAddress))
+    const contractId = binToHex(contractIdFromAddress(response.contractAddress))
     return { ...response, groupIndex: response.fromGroup, contractId, gasPrice: fromApiNumber256(response.gasPrice) }
   }
 

package/src/transaction/status.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 { web3 } from '..'
+import * as web3 from '../global'
 import { node } from '../api'
 import { Subscription, SubscribeOptions } from '../utils'
 
@@ -40,8 +40,6 @@ export class TxStatusSubscription extends Subscription<TxStatus> {
     this.fromGroup = fromGroup
     this.toGroup = toGroup
     this.confirmations = confirmations ?? 1
-
-    this.startPolling()
   }
 
   override async polling(): Promise<void> {
@@ -69,5 +67,7 @@ export function subscribeToTxStatus(
   toGroup?: number,
   confirmations?: number
 ): TxStatusSubscription {
-  return new TxStatusSubscription(options, txId, fromGroup, toGroup, confirmations)
+  const subscription = new TxStatusSubscription(options, txId, fromGroup, toGroup, confirmations)
+  subscription.subscribe()
+  return subscription
 }

package/src/utils/address.ts

@@ -24,6 +24,9 @@ import bs58 from './bs58'
 import djb2 from './djb2'
 import { binToHex, hexToBinUnsafe } from './utils'
 import { KeyType } from '../signer'
+import { MultiSig, lockupScriptCodec } from '../codec/lockup-script-codec'
+import { Buffer } from 'buffer/'
+import { compactSignedIntCodec } from '../codec'
 
 const ec = new EC('secp256k1')
 
@@ -49,8 +52,18 @@ function decodeAndValidateAddress(address: string): Uint8Array {
   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 decoded
+    let multisig: MultiSig
+    try {
+      multisig = lockupScriptCodec.decode(Buffer.from(decoded)).script as MultiSig
+    } catch (_) {
+      throw new Error(`Invalid multisig address: ${address}`)
+    }
+    const n = multisig.publicKeyHashes.value.length
+    const m = compactSignedIntCodec.toI32(multisig.m)
+    if (n < m) {
+      throw new Error(`Invalid multisig address, n: ${n}, m: ${m}`)
+    }
+    return decoded
   } else if (addressType === AddressType.P2PKH || addressType === AddressType.P2SH || addressType === AddressType.P2C) {
     // [type, ...hash]
     if (decoded.length === 33) return decoded