560 xp add sc manager

packages/massa-web3/src/experimental/basicElements/index.ts

@@ -3,3 +3,4 @@ export * from './signature'
 export * from './keys'
 export * from './operationManager'
 export * from './operation'
+export * from './storage'

packages/massa-web3/src/experimental/basicElements/operation.ts

@@ -1,4 +1,4 @@
-import { SCOutputEvent } from '../client'
+import { EventFilter, SCOutputEvent } from '../client'
 import { BlockchainClient } from '../client'
 
 /**
@@ -10,24 +10,109 @@
     public id: string
   ) {}
 
+  /**
+   * Gets the status of the operation.
+   *
+   * @returns The status of the operation.
+   */
   async getStatus(): Promise<OperationStatus> {
     return await this.client.getOperationStatus(this.id)
   }
 
-  async waitSpeculativeExecution(): Promise<OperationStatus> {
-    throw new Error('Not implemented')
+  /**
+   * Waits for the operation to reach a specific status.
+   *
+   * @param exitThreshold - The minimal status to wait for.
+   * @param timeout - The maximum time to wait.
+   * @param period - The time interval to check the status.
+   *
+   * @returns The status of the operation or NotFound if the timeout is reached.
+   */
+  private wait(
+    exitThreshold: OperationStatus,
+    timeout: number = 60000,
+    period: number = 500
+  ): Promise<OperationStatus> {
+    return new Promise<OperationStatus>((resolve) => {
+      let elapsedTime = 0
+      const checkStatusInterval = setInterval(async () => {
+        const currentStatus = await this.getStatus()
+        if (currentStatus >= exitThreshold) {
+          clearInterval(checkStatusInterval)
+          resolve(currentStatus)
+        } else if (elapsedTime >= timeout) {
+          clearInterval(checkStatusInterval)
+          resolve(OperationStatus.NotFound)
+        }
+        elapsedTime += period
+      }, period)
+    })
   }
 
-  async waitFinalExecution(): Promise<OperationStatus> {
-    throw new Error('Not implemented')
+  /**
+   * Waits for the operation to be included in a block.
+   *
+   * @param timeout - The maximum time to wait.
+   * @param period - The time interval to check the status.
+   *
+   * @returns The status of the operation or NotFound if the timeout is reached.
+   */
+  async waitSpeculativeExecution(
+    timeout?: number,
+    period?: number
+  ): Promise<OperationStatus> {
+    return this.wait(OperationStatus.SpeculativeSuccess, timeout, period)
   }
 
+  /**
+   * Waits for the block containing the operation to be final.
+   *
+   * @param timeout - The maximum time to wait.
+   * @param period - The time interval to check the status.
+   *
+   * @returns The status of the operation or NotFound if the timeout is reached.
+   */
+  async waitFinalExecution(
+    timeout?: number,
+    period?: number
+  ): Promise<OperationStatus> {
+    return this.wait(OperationStatus.Success, timeout, period)
+  }
+
+  /**
+   * Gets the events of the operation once the block reaches the final state.
+   *
+   * @returns The events of the operation.
+   */
   async getFinalEvents(): Promise<SCOutputEvent[]> {
-    throw new Error('Not implemented')
+    if ((await this.waitFinalExecution()) === OperationStatus.NotFound) {
+      return Promise.reject(new Error('Operation not found'))
+    }
+
+    const filter = {
+      operationId: this.id,
+      isFinal: true,
+    } as EventFilter
+
+    return this.client.getEvents(filter)
   }
 
+  /**
+   * Gets the events of the speculative execution of the operation.
+   *
+   * @returns The speculative events of the operation.
+   */
   async getSpeculativeEvents(): Promise<SCOutputEvent[]> {
-    throw new Error('Not implemented')
+    if ((await this.waitSpeculativeExecution()) === OperationStatus.NotFound) {
+      return Promise.reject(new Error('Operation not found'))
+    }
+
+    const filter = {
+      operationId: this.id,
+      isFinal: false,
+    } as EventFilter
+
+    return this.client.getEvents(filter)
   }
 }
 
@@ -36,8 +121,16 @@
  *
  * @remarks
  * This enumeration captures the lifecycle stages of a blockchain operation, from initiation to finalization.
+ *
+ * @privateRemarks
+ * Keeps the order of the stages in the lifecycle as it is used by the wait method.
  */
 export enum OperationStatus {
+  /**
+   * The operation has not been found within the blockchain, either because it is not yet processed or does not exist.
+   */
+  NotFound,
+
   /**
    * The operation has been recognized and is awaiting inclusion in the blockchain ledger.
    */
@@ -62,9 +155,4 @@
    * The operation has failed and the block containing the failure has been confirmed as final.
    */
   Error,
-
-  /**
-   * The operation has not been found within the blockchain, either because it is not yet processed or does not exist.
-   */
-  NotFound,
 }

packages/massa-web3/src/experimental/basicElements/storage.ts

@@ -0,0 +1,49 @@
+import { fromMAS } from '@massalabs/web3-utils'
+
+/**
+ * Calculates the cost of deploying a smart contract.
+ */
+export class StorageCost {
+  /**
+   * Calculates the cost of a given number of bytes.
+   *
+   * @param numberOfBytes - The number of bytes.
+   *
+   * @returns The cost in the smallest unit of the Massa currency.
+   */
+  static bytes(numberOfBytes: number): bigint {
+    return BigInt(numberOfBytes) * fromMAS(0.0001)
+  }
+
+  /**
+   * Calculates the cost of creating a new account.
+   *
+   * @returns The cost in the smallest unit of the Massa currency.
+   */
+  static account(): bigint {
+    return fromMAS(0.001)
+  }
+
+  /**
+   * Calculates the cost of deploying a smart contract.
+   *
+   * @remarks
+   * The cost of deploying a smart contract includes the cost of creating a new account.
+   *
+   * @param numberOfBytes - The number of bytes of the smart contract.
+   *
+   * @returns The cost in the smallest unit of the Massa currency.
+   */
+  static smartContract(numberOfBytes: number): bigint {
+    return StorageCost.bytes(numberOfBytes) + StorageCost.account()
+  }
+
+  /**
+   * Calculates the cost of creating a new entry in the datastore.
+   *
+   * @returns The cost in the smallest unit of the Massa currency.
+   */
+  static newEntry(): bigint {
+    return StorageCost.bytes(4)
+  }
+}

packages/massa-web3/src/experimental/client/client.ts

@@ -1,4 +1,5 @@
 import { OperationStatus } from '../basicElements'
+import { Slot } from '../generated/client'
 
 export interface SendOperationInput {
   data: Uint8Array
@@ -10,6 +11,16 @@ export interface SCOutputEvent {
   data: string
 }
 
+export interface EventFilter {
+  start?: Slot
+  end?: Slot
+  smartContractAddress?: string
+  callerAddress?: string
+  operationId?: string
+  isFinal?: boolean
+  isError?: boolean
+}
+
 /*
  * Blockchain client functions needed by the Operation class to send operations to the blockchain.
  */
@@ -19,4 +30,5 @@ export interface BlockchainClient {
   fetchPeriod(): Promise<number>
   getOperationStatus(operationId: string): Promise<OperationStatus>
   getBalance(address: string, speculative?: boolean): Promise<bigint>
+  getEvents(filter: EventFilter): Promise<SCOutputEvent[]>
 }

packages/massa-web3/src/experimental/publicAPI.ts

@@ -1,5 +1,5 @@
 import { OperationStatus } from './basicElements'
-import { SendOperationInput } from './client'
+import { SendOperationInput, EventFilter as EvtFilter } from './client'
 import {
   OperationInput,
   Pagination,
@@ -95,7 +95,7 @@
     speculative: boolean = false
   ): Promise<bigint> {
     return this.getAddressInfo(address).then((r) => {
       console.log('getAddressInfo', r)
       return BigInt(speculative ? r.candidate_balance : r.final_balance)
     })
   }
@@ -176,10 +176,20 @@
     return this.connector.get_endorsements(endorsementIds)
   }
 
-  async getFilteredScOutputEvent(
-    filter: EventFilter
-  ): Promise<SCOutputEvent[]> {
-    return this.connector.get_filtered_sc_output_event(filter)
+  async getEvents(filter: EvtFilter): Promise<SCOutputEvent[]> {
+    filter = {
+      start: filter.start,
+      end: filter.end,
+      emitter_address: filter.smartContractAddress,
+      original_caller_address: filter.callerAddress,
+      original_operation_id: filter.operationId,
+      is_final: filter.isFinal,
+      is_error: filter.isError,
+    } as EventFilter
+
+    const events = await this.connector.get_filtered_sc_output_event(filter)
+
+    return events
   }
 
   async getGraphInterval(