@alephium/web3 0.5.0-rc.2 → 0.5.0-rc.21

package/src/api/explorer-provider.ts

@@ -0,0 +1,78 @@
+/*
+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 { ApiRequestArguments, ApiRequestHandler, forwardRequests, request } from './types'
+import { Api as ExplorerApi } from './api-explorer'
+
+function initializeExplorerApi(baseUrl: string, apiKey?: string): ExplorerApi<string> {
+  const explorerApi = new ExplorerApi<string>({
+    baseUrl: baseUrl,
+    baseApiParams: { secure: true },
+    securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
+  })
+  explorerApi.setSecurityData(apiKey ?? null)
+  return explorerApi
+}
+
+export class ExplorerProvider {
+  readonly blocks: ExplorerApi<string>['blocks']
+  readonly transactions: ExplorerApi<string>['transactions']
+  readonly addresses: ExplorerApi<string>['addresses']
+  readonly infos: ExplorerApi<string>['infos']
+  readonly mempool: ExplorerApi<string>['mempool']
+  readonly tokens: ExplorerApi<string>['tokens']
+  readonly charts: ExplorerApi<string>['charts']
+  readonly utils: ExplorerApi<string>['utils']
+
+  constructor(baseUrl: string, apiKey?: string)
+  constructor(provider: ExplorerProvider)
+  constructor(handler: ApiRequestHandler)
+  constructor(param0: string | ExplorerProvider | ApiRequestHandler, apiKey?: string) {
+    let explorerApi: ExplorerProvider
+    if (typeof param0 === 'string') {
+      explorerApi = initializeExplorerApi(param0, apiKey)
+    } else if (typeof param0 === 'function') {
+      explorerApi = new ExplorerProvider('https://1.2.3.4:0')
+      forwardRequests(explorerApi, param0 as ApiRequestHandler)
+    } else {
+      explorerApi = param0 as ExplorerProvider
+    }
+
+    this.blocks = { ...explorerApi.blocks }
+    this.transactions = { ...explorerApi.transactions }
+    this.addresses = { ...explorerApi.addresses }
+    this.infos = { ...explorerApi.infos }
+    this.mempool = { ...explorerApi.mempool }
+    this.tokens = { ...explorerApi.tokens }
+    this.charts = { ...explorerApi.charts }
+    this.utils = { ...explorerApi.utils }
+  }
+
+  request = (args: ApiRequestArguments): Promise<any> => {
+    return request(this, args)
+  }
+
+  // This can prevent the proxied explorer provider from being modified
+  static Proxy(explorerProvider: ExplorerProvider): ExplorerProvider {
+    return new ExplorerProvider(explorerProvider)
+  }
+
+  static Remote(handler: ApiRequestHandler): ExplorerProvider {
+    return new ExplorerProvider(handler)
+  }
+}

package/src/api/index.ts

@@ -16,152 +16,8 @@ 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 { Api as NodeApi } from './api-alephium'
-import { Api as ExplorerApi } from './api-explorer'
-
-export interface ApiRequestArguments {
-  path: string
-  method: string
-  params: any[]
-}
-export type ApiRequestHandler = (args: ApiRequestArguments) => Promise<any>
-
-function forwardRequests(api: Record<string, any>, handler: ApiRequestHandler): void {
-  // Update class properties to forward requests
-  for (const [path, pathObject] of Object.entries(api)) {
-    for (const method of Object.keys(pathObject)) {
-      pathObject[`${method}`] = async (...params: any): Promise<any> => {
-        return handler({ path, method, params })
-      }
-    }
-  }
-}
-
-async function request(provider: Record<string, any>, args: ApiRequestArguments): Promise<any> {
-  const call = provider[`${args.path}`][`${args.method}`] as (...any) => Promise<any>
-  return call(...args.params)
-}
-
-function initializeNodeApi(baseUrl: string, apiKey?: string): NodeApi<string> {
-  const nodeApi = new NodeApi<string>({
-    baseUrl: baseUrl,
-    baseApiParams: { secure: true },
-    securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
-  })
-  nodeApi.setSecurityData(apiKey ?? null)
-  return nodeApi
-}
-
-export class NodeProvider {
-  readonly wallets: NodeApi<string>['wallets']
-  readonly infos: NodeApi<string>['infos']
-  readonly blockflow: NodeApi<string>['blockflow']
-  readonly addresses: NodeApi<string>['addresses']
-  readonly transactions: NodeApi<string>['transactions']
-  readonly contracts: NodeApi<string>['contracts']
-  readonly multisig: NodeApi<string>['multisig']
-  readonly utils: NodeApi<string>['utils']
-  readonly miners: NodeApi<string>['miners']
-  readonly events: NodeApi<string>['events']
-
-  constructor(baseUrl: string, apiKey?: string)
-  constructor(provider: NodeProvider)
-  constructor(handler: ApiRequestHandler)
-  constructor(param0: string | NodeProvider | ApiRequestHandler, apiKey?: string) {
-    let nodeApi: NodeProvider
-    if (typeof param0 === 'string') {
-      nodeApi = initializeNodeApi(param0, apiKey)
-    } else if (typeof param0 === 'function') {
-      nodeApi = new NodeProvider('https://1.2.3.4:0')
-      forwardRequests(nodeApi, param0 as ApiRequestHandler)
-    } else {
-      nodeApi = param0 as NodeProvider
-    }
-
-    this.wallets = { ...nodeApi.wallets }
-    this.infos = { ...nodeApi.infos }
-    this.blockflow = { ...nodeApi.blockflow }
-    this.addresses = { ...nodeApi.addresses }
-    this.transactions = { ...nodeApi.transactions }
-    this.contracts = { ...nodeApi.contracts }
-    this.multisig = { ...nodeApi.multisig }
-    this.utils = { ...nodeApi.utils }
-    this.miners = { ...nodeApi.miners }
-    this.events = { ...nodeApi.events }
-  }
-
-  request = (args: ApiRequestArguments): Promise<any> => {
-    return request(this, args)
-  }
-
-  // This can prevent the proxied node provider from being modified
-  static Proxy(nodeProvider: NodeProvider): NodeProvider {
-    return new NodeProvider(nodeProvider)
-  }
-
-  static Remote(handler: ApiRequestHandler): NodeProvider {
-    return new NodeProvider(handler)
-  }
-}
-
-function initializeExplorerApi(baseUrl: string, apiKey?: string): ExplorerApi<string> {
-  const explorerApi = new ExplorerApi<string>({
-    baseUrl: baseUrl,
-    baseApiParams: { secure: true },
-    securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
-  })
-  explorerApi.setSecurityData(apiKey ?? null)
-  return explorerApi
-}
-
-export class ExplorerProvider {
-  readonly blocks = ExplorerApi['blocks']
-  readonly transactions = ExplorerApi['transactions']
-  readonly addresses = ExplorerApi['addresses']
-  readonly infos = ExplorerApi['infos']
-  readonly unconfirmedTransactions = ExplorerApi['unconfirmedTransactions']
-  readonly tokens = ExplorerApi['tokens']
-  readonly charts = ExplorerApi['charts']
-  readonly utils = ExplorerApi['utils']
-
-  constructor(baseUrl: string, apiKey?: string)
-  constructor(provider: ExplorerProvider)
-  constructor(handler: ApiRequestHandler)
-  constructor(param0: string | ExplorerProvider | ApiRequestHandler, apiKey?: string) {
-    let explorerApi: ExplorerProvider
-    if (typeof param0 === 'string') {
-      explorerApi = initializeExplorerApi(param0, apiKey)
-    } else if (typeof param0 === 'function') {
-      explorerApi = new ExplorerProvider('https://1.2.3.4:0')
-      forwardRequests(explorerApi, param0 as ApiRequestHandler)
-    } else {
-      explorerApi = param0 as ExplorerProvider
-    }
-
-    this.blocks = { ...explorerApi.blocks }
-    this.transactions = { ...explorerApi.transactions }
-    this.addresses = { ...explorerApi.addresses }
-    this.infos = { ...explorerApi.infos }
-    this.unconfirmedTransactions = { ...explorerApi.unconfirmedTransactions }
-    this.tokens = { ...explorerApi.tokens }
-    this.charts = { ...explorerApi.charts }
-    this.utils = { ...explorerApi.utils }
-  }
-
-  request = (args: ApiRequestArguments): Promise<any> => {
-    return request(this, args)
-  }
-
-  // This can prevent the proxied explorer provider from being modified
-  static Proxy(explorerProvider: ExplorerProvider): ExplorerProvider {
-    return new ExplorerProvider(explorerProvider)
-  }
-
-  static Remote(handler: ApiRequestHandler): ExplorerProvider {
-    return new ExplorerProvider(handler)
-  }
-}
-
+export * from './node-provider'
+export * from './explorer-provider'
 export * as node from './api-alephium'
 export * as explorer from './api-explorer'
 export * from './types'

package/src/api/node-provider.ts

@@ -0,0 +1,84 @@
+/*
+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 { ApiRequestArguments, ApiRequestHandler, forwardRequests, request } from './types'
+import { Api as NodeApi } from './api-alephium'
+
+function initializeNodeApi(baseUrl: string, apiKey?: string): NodeApi<string> {
+  const nodeApi = new NodeApi<string>({
+    baseUrl: baseUrl,
+    baseApiParams: { secure: true },
+    securityWorker: (accessToken) => (accessToken !== null ? { headers: { 'X-API-KEY': `${accessToken}` } } : {})
+  })
+  nodeApi.setSecurityData(apiKey ?? null)
+  return nodeApi
+}
+
+export class NodeProvider {
+  readonly wallets: NodeApi<string>['wallets']
+  readonly infos: NodeApi<string>['infos']
+  readonly blockflow: NodeApi<string>['blockflow']
+  readonly addresses: NodeApi<string>['addresses']
+  readonly transactions: NodeApi<string>['transactions']
+  readonly mempool: NodeApi<string>['mempool']
+  readonly contracts: NodeApi<string>['contracts']
+  readonly multisig: NodeApi<string>['multisig']
+  readonly utils: NodeApi<string>['utils']
+  readonly miners: NodeApi<string>['miners']
+  readonly events: NodeApi<string>['events']
+
+  constructor(baseUrl: string, apiKey?: string)
+  constructor(provider: NodeProvider)
+  constructor(handler: ApiRequestHandler)
+  constructor(param0: string | NodeProvider | ApiRequestHandler, apiKey?: string) {
+    let nodeApi: NodeProvider
+    if (typeof param0 === 'string') {
+      nodeApi = initializeNodeApi(param0, apiKey)
+    } else if (typeof param0 === 'function') {
+      nodeApi = new NodeProvider('https://1.2.3.4:0')
+      forwardRequests(nodeApi, param0 as ApiRequestHandler)
+    } else {
+      nodeApi = param0 as NodeProvider
+    }
+
+    this.wallets = { ...nodeApi.wallets }
+    this.infos = { ...nodeApi.infos }
+    this.blockflow = { ...nodeApi.blockflow }
+    this.addresses = { ...nodeApi.addresses }
+    this.transactions = { ...nodeApi.transactions }
+    this.mempool = { ...nodeApi.mempool }
+    this.contracts = { ...nodeApi.contracts }
+    this.multisig = { ...nodeApi.multisig }
+    this.utils = { ...nodeApi.utils }
+    this.miners = { ...nodeApi.miners }
+    this.events = { ...nodeApi.events }
+  }
+
+  request = (args: ApiRequestArguments): Promise<any> => {
+    return request(this, args)
+  }
+
+  // This can prevent the proxied node provider from being modified
+  static Proxy(nodeProvider: NodeProvider): NodeProvider {
+    return new NodeProvider(nodeProvider)
+  }
+
+  static Remote(handler: ApiRequestHandler): NodeProvider {
+    return new NodeProvider(handler)
+  }
+}

package/src/api/types.ts

@@ -19,7 +19,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 import { assertType, bs58, Eq } from '../utils'
 import * as node from './api-alephium'
 
-export type Number256 = bigint
+export type Number256 = bigint | string
 export type Val = Number256 | boolean | string | Val[]
 export type NamedVals = Record<string, Val>
 
@@ -162,7 +162,13 @@ function _fromApiVal(vals: node.Val[], valIndex: number, tpe: string): [result:
   }
 }
 
-export function fromApiVals(vals: node.Val[], names: string[], types: string[]): NamedVals {
+export function fromApiVals(
+  vals: node.Val[],
+  names: string[],
+  types: string[],
+  optionalNames: string[] = [],
+  optionalTypes: string[] = []
+): NamedVals {
   let valIndex = 0
   const result: NamedVals = {}
   types.forEach((currentType, index) => {
@@ -171,7 +177,11 @@ export function fromApiVals(vals: node.Val[], names: string[], types: string[]):
     valIndex = nextIndex
     result[`${currentName}`] = val
   })
-  return result
+  if (valIndex === vals.length) {
+    return result
+  }
+  const optionalFields = fromApiVals(vals.slice(valIndex), optionalNames, optionalTypes)
+  return { ...result, ...optionalFields }
 }
 
 export function fromApiArray(vals: node.Val[], types: string[]): Val[] {
@@ -235,3 +245,26 @@ export function typeLength(tpe: string): number {
   const [, dims] = decodeArrayType(tpe)
   return dims.reduce((a, b) => a * b)
 }
+
+export interface ApiRequestArguments {
+  path: string
+  method: string
+  params: any[]
+}
+export type ApiRequestHandler = (args: ApiRequestArguments) => Promise<any>
+
+export function forwardRequests(api: Record<string, any>, handler: ApiRequestHandler): void {
+  // Update class properties to forward requests
+  for (const [path, pathObject] of Object.entries(api)) {
+    for (const method of Object.keys(pathObject)) {
+      pathObject[`${method}`] = async (...params: any): Promise<any> => {
+        return handler({ path, method, params })
+      }
+    }
+  }
+}
+
+export async function request(provider: Record<string, any>, args: ApiRequestArguments): Promise<any> {
+  const call = provider[`${args.path}`][`${args.method}`] as (...any) => Promise<any>
+  return call(...args.params)
+}

package/src/contract/contract.ts

@@ -53,7 +53,8 @@ import {
   assertType,
   Eq,
   Optional,
-  groupOfAddress
+  groupOfAddress,
+  addressFromContractId
 } from '../utils'
 import { getCurrentNodeProvider } from '../global'
 import * as path from 'path'
@@ -848,38 +849,45 @@ export class Contract extends Artifact {
   }
 
   static ContractCreatedEventIndex = -1
-  static ContractCreatedEvent: EventSig = {
+  static ContractCreatedEvent: SystemEventSig = {
     name: 'ContractCreated',
     fieldNames: ['address'],
-    fieldTypes: ['Address']
+    fieldTypes: ['Address'],
+    optionalFieldNames: ['parentAddress'],
+    optionalFieldTypes: ['Address']
   }
 
   static ContractDestroyedEventIndex = -2
-  static ContractDestroyedEvent: EventSig = {
+  static ContractDestroyedEvent: SystemEventSig = {
     name: 'ContractDestroyed',
     fieldNames: ['address'],
     fieldTypes: ['Address']
   }
 
   static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined, txId: string): ContractEvent {
-    let eventSig: EventSig
+    let fields: Fields
+    let name: string
 
     if (event.eventIndex == Contract.ContractCreatedEventIndex) {
-      eventSig = this.ContractCreatedEvent
+      fields = fromApiSystemEventFields(event.fields, Contract.ContractCreatedEvent)
+      name = Contract.ContractCreatedEvent.name
     } else if (event.eventIndex == Contract.ContractDestroyedEventIndex) {
-      eventSig = this.ContractDestroyedEvent
+      fields = fromApiSystemEventFields(event.fields, Contract.ContractDestroyedEvent)
+      name = Contract.ContractDestroyedEvent.name
     } else {
       const contract = Project.currentProject.contractByCodeHash(codeHash!)
-      eventSig = contract.eventsSig[event.eventIndex]
+      const eventSig = contract.eventsSig[event.eventIndex]
+      fields = fromApiEventFields(event.fields, eventSig)
+      name = eventSig.name
     }
 
     return {
       txId: txId,
       blockHash: event.blockHash,
       contractAddress: event.contractAddress,
-      name: eventSig.name,
+      name: name,
       eventIndex: event.eventIndex,
-      fields: fromApiEventFields(event.fields, eventSig)
+      fields: fields
     }
   }
 
@@ -913,8 +921,10 @@ export class Contract extends Artifact {
     params: DeployContractParams<P>
   ): Promise<SignDeployContractTxParams> {
     const bytecode = this.buildByteCodeToDeploy(params.initialFields ?? {})
+    const selectedAccount = await signer.getSelectedAccount()
     const signerParams: SignDeployContractTxParams = {
-      signerAddress: await signer.getSelectedAddress(),
+      signerAddress: selectedAccount.address,
+      signerKeyType: selectedAccount.keyType,
       bytecode: bytecode,
       initialAttoAlphAmount: params?.initialAttoAlphAmount,
       issueTokenAmount: params?.issueTokenAmount,
@@ -1056,8 +1066,10 @@ export class Script extends Artifact {
     signer: SignerProvider,
     params: ExecuteScriptParams<P>
   ): Promise<SignExecuteScriptTxParams> {
+    const selectedAccount = await signer.getSelectedAccount()
     const signerParams: SignExecuteScriptTxParams = {
-      signerAddress: await signer.getSelectedAddress(),
+      signerAddress: selectedAccount.address,
+      signerKeyType: selectedAccount.keyType,
       bytecode: this.buildByteCodeToDeploy(params.initialFields ?? {}),
       attoAlphAmount: params.attoAlphAmount,
       tokens: params.tokens,
@@ -1095,6 +1107,16 @@ function fromApiEventFields(vals: node.Val[], eventSig: node.EventSig): Fields {
   return fromApiVals(vals, eventSig.fieldNames, eventSig.fieldTypes)
 }
 
+function fromApiSystemEventFields(vals: node.Val[], systemEventSig: SystemEventSig): Fields {
+  return fromApiVals(
+    vals,
+    systemEventSig.fieldNames,
+    systemEventSig.fieldTypes,
+    systemEventSig.optionalFieldNames ?? [],
+    systemEventSig.optionalFieldTypes ?? []
+  )
+}
+
 export interface Asset {
   alphAmount: Number256
   tokens?: Token[]
@@ -1272,7 +1294,7 @@ export interface DeployContractParams<P extends Fields = Fields> {
 assertType<
   Eq<
     Omit<DeployContractParams<undefined>, 'initialFields'>,
-    Omit<SignDeployContractTxParams, 'signerAddress' | 'bytecode'>
+    Omit<SignDeployContractTxParams, 'signerAddress' | 'signerKeyType' | 'bytecode'>
   >
 >
 export type DeployContractResult<T> = SignDeployContractTxResult & { instance: T }
@@ -1339,37 +1361,54 @@ export interface CallContractResult<R> {
   events: ContractEvent[]
 }
 
-export type ContractCreatedEvent = ContractEvent<{ address: HexString }>
-export type ContractDestroyedEvent = ContractEvent<{ address: HexString }>
+function specialContractAddress(n: number): string {
+  const bytes = new Uint8Array(32).fill(0)
+  bytes[31] = n
+  return addressFromContractId(binToHex(bytes))
+}
+
+export const CreateContractEventAddress = specialContractAddress(-1)
+export const DestroyContractEventAddress = specialContractAddress(-2)
 
-function decodeFields(event: node.ContractEvent, eventSig: EventSig, eventIndex: number): Fields {
+export interface SystemEventSig extends EventSig {
+  optionalFieldNames?: string[]
+  optionalFieldTypes?: string[]
+}
+
+export type ContractCreatedEvent = ContractEvent<{ address: Address; parentAddress?: Address }>
+export type ContractDestroyedEvent = ContractEvent<{ address: Address }>
+
+function decodeSystemEvent(event: node.ContractEvent, systemEventSig: SystemEventSig, eventIndex: number): Fields {
   if (event.eventIndex !== eventIndex) {
     throw new Error(`Invalid event index: ${event.eventIndex}, expected: ${eventIndex}`)
   }
-  return fromApiVals(event.fields, eventSig.fieldNames, eventSig.fieldTypes)
+  return fromApiSystemEventFields(event.fields, systemEventSig)
 }
 
 export function decodeContractCreatedEvent(event: node.ContractEvent): Omit<ContractCreatedEvent, 'contractAddress'> {
-  const fields = decodeFields(event, Contract.ContractCreatedEvent, Contract.ContractCreatedEventIndex)
+  const fields = decodeSystemEvent(event, Contract.ContractCreatedEvent, Contract.ContractCreatedEventIndex)
   return {
     blockHash: event.blockHash,
     txId: event.txId,
     eventIndex: event.eventIndex,
     name: Contract.ContractCreatedEvent.name,
-    fields: { address: fields['address'] as HexString }
+    fields: {
+      address: fields['address'] as Address,
+      parentAddress: fields['parentAddress'] === undefined ? undefined : (fields['parentAddress'] as Address)
+    }
   }
 }
 
 export function decodeContractDestroyedEvent(
   event: node.ContractEvent
 ): Omit<ContractDestroyedEvent, 'contractAddress'> {
-  const fields = decodeFields(event, Contract.ContractDestroyedEvent, Contract.ContractDestroyedEventIndex)
+  const fields = decodeSystemEvent(event, Contract.ContractDestroyedEvent, Contract.ContractDestroyedEventIndex)
   return {
     blockHash: event.blockHash,
     txId: event.txId,
     eventIndex: event.eventIndex,
     name: Contract.ContractDestroyedEvent.name,
-    fields: { address: fields['address'] as HexString }
+    fields: { address: fields['address'] as Address }
   }
 }
 
@@ -1443,18 +1482,17 @@ export async function fetchContractState<F extends Fields, I extends ContractIns
 }
 
 export function subscribeContractCreatedEvent(
-  instance: ContractInstance,
   options: SubscribeOptions<ContractCreatedEvent>,
   fromCount?: number
 ): EventSubscription {
   return subscribeEventsFromContract(
     options,
-    instance.address,
+    CreateContractEventAddress,
     Contract.ContractCreatedEventIndex,
     (event) => {
       return {
         ...decodeContractCreatedEvent(event),
-        contractAddress: instance.address
+        contractAddress: CreateContractEventAddress
       }
     },
     fromCount
@@ -1462,18 +1500,17 @@ export function subscribeContractCreatedEvent(
 }
 
 export function subscribeContractDestroyedEvent(
-  instance: ContractInstance,
   options: SubscribeOptions<ContractDestroyedEvent>,
   fromCount?: number
 ): EventSubscription {
   return subscribeEventsFromContract(
     options,
-    instance.address,
+    DestroyContractEventAddress,
     Contract.ContractDestroyedEventIndex,
     (event) => {
       return {
         ...decodeContractDestroyedEvent(event),
-        contractAddress: instance.address
+        contractAddress: DestroyContractEventAddress
       }
     },
     fromCount
@@ -1523,34 +1560,17 @@ export function subscribeContractEvent<F extends Fields, M extends ContractEvent
   )
 }
 
-export function subscribeAllEvents(
+export function subscribeContractEvents(
   contract: Contract,
   instance: ContractInstance,
   options: SubscribeOptions<ContractEvent<any>>,
   fromCount?: number
 ): EventSubscription {
   const messageCallback = (event: node.ContractEvent): Promise<void> => {
-    switch (event.eventIndex) {
-      case Contract.ContractCreatedEventIndex: {
-        return options.messageCallback({
-          ...decodeContractCreatedEvent(event),
-          contractAddress: instance.address
-        })
-      }
-
-      case Contract.ContractDestroyedEventIndex: {
-        return options.messageCallback({
-          ...decodeContractDestroyedEvent(event),
-          contractAddress: instance.address
-        })
-      }
-
-      default:
-        return options.messageCallback({
-          ...decodeEvent(contract, instance, event, event.eventIndex),
-          contractAddress: instance.address
-        })
-    }
+    return options.messageCallback({
+      ...decodeEvent(contract, instance, event, event.eventIndex),
+      contractAddress: instance.address
+    })
   }
   const errorCallback = (err: any, subscription: Subscription<node.ContractEvent>): Promise<void> => {
     return options.errorCallback(err, subscription as unknown as Subscription<ContractEvent<any>>)
@@ -1581,3 +1601,14 @@ export async function callMethod<I, F extends Fields, A extends Arguments, R>(
   const callResult = contract.contract.fromApiCallContractResult(result, txId, methodIndex)
   return callResult as CallContractResult<R>
 }
+
+export async function getContractEventsCurrentCount(contractAddress: Address): Promise<number> {
+  return getCurrentNodeProvider()
+    .events.getEventsContractContractaddressCurrentCount(contractAddress)
+    .catch((error) => {
+      if (error instanceof Error && error.message.includes(`${contractAddress} not found`)) {
+        return 0
+      }
+      throw error
+    })
+}