@alephium/web3 0.5.0-rc.13 → 0.5.0-rc.14

package/dist/src/contract/contract.d.ts

@@ -257,6 +257,8 @@ export interface CallContractResult<R> {
     txOutputs: Output[];
     events: ContractEvent[];
 }
+export declare const CreateContractEventAddress: string;
+export declare const DestroyContractEventAddress: string;
 export interface SystemEventSig extends EventSig {
     optionalFieldNames?: string[];
     optionalFieldTypes?: string[];
@@ -279,10 +281,11 @@ export declare abstract class ContractInstance {
     constructor(address: Address);
 }
 export declare function fetchContractState<F extends Fields, I extends ContractInstance>(contract: ContractFactory<I, F>, instance: ContractInstance): Promise<ContractState<F>>;
-export declare function subscribeContractCreatedEvent(instance: ContractInstance, options: SubscribeOptions<ContractCreatedEvent>, fromCount?: number): EventSubscription;
-export declare function subscribeContractDestroyedEvent(instance: ContractInstance, options: SubscribeOptions<ContractDestroyedEvent>, fromCount?: number): EventSubscription;
+export declare function subscribeContractCreatedEvent(options: SubscribeOptions<ContractCreatedEvent>, fromCount?: number): EventSubscription;
+export declare function subscribeContractDestroyedEvent(options: SubscribeOptions<ContractDestroyedEvent>, fromCount?: number): EventSubscription;
 export declare function decodeEvent<F extends Fields, M extends ContractEvent<F>>(contract: Contract, instance: ContractInstance, event: node.ContractEvent, targetEventIndex: number): M;
 export declare function subscribeContractEvent<F extends Fields, M extends ContractEvent<F>>(contract: Contract, instance: ContractInstance, options: SubscribeOptions<M>, eventName: string, fromCount?: number): EventSubscription;
-export declare function subscribeAllEvents(contract: Contract, instance: ContractInstance, options: SubscribeOptions<ContractEvent<any>>, fromCount?: number): EventSubscription;
+export declare function subscribeContractEvents(contract: Contract, instance: ContractInstance, options: SubscribeOptions<ContractEvent<any>>, fromCount?: number): EventSubscription;
 export declare function callMethod<I, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, instance: ContractInstance, methodName: string, params: Optional<CallContractParams<A>, 'args'>): Promise<CallContractResult<R>>;
+export declare function getContractEventsCurrentCount(contractAddress: Address): Promise<number>;
 export {};

package/dist/src/contract/contract.js

@@ -43,7 +43,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.callMethod = exports.subscribeAllEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.testMethod = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.ContractFactory = exports.randomTxId = exports.toApiVals = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = void 0;
+exports.getContractEventsCurrentCount = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.testMethod = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.DestroyContractEventAddress = exports.CreateContractEventAddress = exports.ContractFactory = exports.randomTxId = exports.toApiVals = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = void 0;
 const buffer_1 = require("buffer/");
 const crypto_1 = require("crypto");
 const fs_1 = __importDefault(require("fs"));
@@ -886,6 +886,13 @@ class ContractFactory {
     }
 }
 exports.ContractFactory = ContractFactory;
+function specialContractAddress(n) {
+    const bytes = new Uint8Array(32).fill(0);
+    bytes[31] = n;
+    return (0, utils_1.addressFromContractId)((0, utils_1.binToHex)(bytes));
+}
+exports.CreateContractEventAddress = specialContractAddress(-1);
+exports.DestroyContractEventAddress = specialContractAddress(-2);
 function decodeSystemEvent(event, systemEventSig, eventIndex) {
     if (event.eventIndex !== eventIndex) {
         throw new Error(`Invalid event index: ${event.eventIndex}, expected: ${eventIndex}`);
@@ -968,20 +975,20 @@ async function fetchContractState(contract, instance) {
     };
 }
 exports.fetchContractState = fetchContractState;
-function subscribeContractCreatedEvent(instance, options, fromCount) {
-    return subscribeEventsFromContract(options, instance.address, Contract.ContractCreatedEventIndex, (event) => {
+function subscribeContractCreatedEvent(options, fromCount) {
+    return subscribeEventsFromContract(options, exports.CreateContractEventAddress, Contract.ContractCreatedEventIndex, (event) => {
         return {
             ...decodeContractCreatedEvent(event),
-            contractAddress: instance.address
+            contractAddress: exports.CreateContractEventAddress
         };
     }, fromCount);
 }
 exports.subscribeContractCreatedEvent = subscribeContractCreatedEvent;
-function subscribeContractDestroyedEvent(instance, options, fromCount) {
-    return subscribeEventsFromContract(options, instance.address, Contract.ContractDestroyedEventIndex, (event) => {
+function subscribeContractDestroyedEvent(options, fromCount) {
+    return subscribeEventsFromContract(options, exports.DestroyContractEventAddress, Contract.ContractDestroyedEventIndex, (event) => {
         return {
             ...decodeContractDestroyedEvent(event),
-            contractAddress: instance.address
+            contractAddress: exports.DestroyContractEventAddress
         };
     }, fromCount);
 }
@@ -1010,27 +1017,12 @@ function subscribeContractEvent(contract, instance, options, eventName, fromCoun
     return subscribeEventsFromContract(options, instance.address, eventIndex, (event) => decodeEvent(contract, instance, event, eventIndex), fromCount);
 }
 exports.subscribeContractEvent = subscribeContractEvent;
-function subscribeAllEvents(contract, instance, options, fromCount) {
+function subscribeContractEvents(contract, instance, options, fromCount) {
     const messageCallback = (event) => {
-        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, subscription) => {
         return options.errorCallback(err, subscription);
@@ -1042,7 +1034,7 @@ function subscribeAllEvents(contract, instance, options, fromCount) {
     };
     return (0, events_1.subscribeToEvents)(opt, instance.address, fromCount);
 }
-exports.subscribeAllEvents = subscribeAllEvents;
+exports.subscribeContractEvents = subscribeContractEvents;
 async function callMethod(contract, instance, methodName, params) {
     const methodIndex = contract.contract.getMethodIndex(methodName);
     const txId = params?.txId ?? randomTxId();
@@ -1052,3 +1044,14 @@ async function callMethod(contract, instance, methodName, params) {
     return callResult;
 }
 exports.callMethod = callMethod;
+async function getContractEventsCurrentCount(contractAddress) {
+    return (0, global_1.getCurrentNodeProvider)()
+        .events.getEventsContractContractaddressCurrentCount(contractAddress)
+        .catch((error) => {
+        if (error instanceof Error && error.message.includes(`${contractAddress} not found`)) {
+            return 0;
+        }
+        throw error;
+    });
+}
+exports.getContractEventsCurrentCount = getContractEventsCurrentCount;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.5.0-rc.13",
+  "version": "0.5.0-rc.14",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",

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'
@@ -1360,6 +1361,15 @@ export interface CallContractResult<R> {
   events: ContractEvent[]
 }
 
+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)
+
 export interface SystemEventSig extends EventSig {
   optionalFieldNames?: string[]
   optionalFieldTypes?: string[]
@@ -1472,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
@@ -1491,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
@@ -1552,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>>)
@@ -1610,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
+    })
+}