@alephium/web3 1.1.2 → 1.2.1-rc.0

package/src/contract/contract.ts

@@ -77,7 +77,6 @@ import {
   StoreMutFieldByIndex,
   DestroySelf,
   Pop,
-  byteStringCodec,
   StoreLocal,
   instrCodec,
   U256Const,
@@ -603,20 +602,30 @@ export class Contract extends Artifact {
   ): CallContractResult<unknown> {
     const returnTypes = this.functions[`${methodIndex}`].returnTypes
     const callResult = tryGetCallResult(result)
-    const rawReturn = fromApiArray(callResult.returns, returnTypes, this.structs)
-    const returns = rawReturn.length === 0 ? null : rawReturn.length === 1 ? rawReturn[0] : rawReturn
+    return fromCallResult(callResult, txId, returnTypes, this.structs, getContractByCodeHash)
+  }
+}
 
-    const addressToCodeHash = new Map<string, string>()
-    callResult.contracts.forEach((contract) => addressToCodeHash.set(contract.address, contract.codeHash))
-    return {
-      returns: returns,
-      gasUsed: callResult.gasUsed,
-      contracts: callResult.contracts.map((state) => Contract.fromApiContractState(state, getContractByCodeHash)),
-      txInputs: callResult.txInputs,
-      txOutputs: callResult.txOutputs.map((output) => fromApiOutput(output)),
-      events: Contract.fromApiEvents(callResult.events, addressToCodeHash, txId, getContractByCodeHash),
-      debugMessages: callResult.debugMessages
-    }
+function fromCallResult(
+  callResult: node.CallContractSucceeded | node.CallTxScriptResult,
+  txId: string,
+  returnTypes: string[],
+  structs: Struct[],
+  getContractByCodeHash: (codeHash: string) => Contract
+): CallContractResult<unknown> {
+  const rawReturn = fromApiArray(callResult.returns, returnTypes, structs)
+  const returns = rawReturn.length === 0 ? null : rawReturn.length === 1 ? rawReturn[0] : rawReturn
+
+  const addressToCodeHash = new Map<string, string>()
+  callResult.contracts.forEach((contract) => addressToCodeHash.set(contract.address, contract.codeHash))
+  return {
+    returns: returns,
+    gasUsed: callResult.gasUsed,
+    contracts: callResult.contracts.map((state) => Contract.fromApiContractState(state, getContractByCodeHash)),
+    txInputs: callResult.txInputs,
+    txOutputs: callResult.txOutputs.map((output) => fromApiOutput(output)),
+    events: Contract.fromApiEvents(callResult.events, addressToCodeHash, txId, getContractByCodeHash),
+    debugMessages: callResult.debugMessages
   }
 }
 
@@ -1011,17 +1020,38 @@ export abstract class ContractFactory<I extends ContractInstance, F extends Fiel
   }
 }
 
-export class ExecutableScript<P extends Fields = Fields> {
+export class ExecutableScript<P extends Fields = Fields, R extends Val | null = null> {
   readonly script: Script
+  readonly getContractByCodeHash: (codeHash: string) => Contract
 
-  constructor(script: Script) {
+  constructor(script: Script, getContractByCodeHash: (codeHash: string) => Contract) {
     this.script = script
+    this.getContractByCodeHash = getContractByCodeHash
   }
 
   async execute(signer: SignerProvider, params: ExecuteScriptParams<P>): Promise<ExecuteScriptResult> {
     const signerParams = await this.script.txParamsForExecution(signer, params)
     return await signer.signAndSubmitExecuteScriptTx(signerParams)
   }
+
+  async call(params: CallScriptParams<P>): Promise<CallScriptResult<R>> {
+    const mainFunc = this.script.functions.find((f) => f.name === 'main')
+    if (mainFunc === undefined) {
+      throw new Error(`There is no main function in script ${this.script.name}`)
+    }
+    const bytecode = this.script.buildByteCodeToDeploy(params.initialFields)
+    const txId = params.txId ?? randomTxId()
+    const provider = getCurrentNodeProvider()
+    const callResult = await provider.contracts.postContractsCallTxScript({
+      ...params,
+      group: params.groupIndex ?? 0,
+      bytecode: bytecode,
+      inputAssets: toApiInputAssets(params.inputAssets)
+    })
+    const returnTypes = mainFunc.returnTypes
+    const result = fromCallResult(callResult, txId, returnTypes, this.script.structs, this.getContractByCodeHash)
+    return result as CallScriptResult<R>
+  }
 }
 
 export interface ExecuteScriptParams<P extends Fields = Fields> {
@@ -1041,11 +1071,23 @@ export interface ExecuteScriptResult {
   gasPrice: Number256
 }
 
+export interface CallScriptParams<P extends Fields = Fields> {
+  initialFields: P
+  groupIndex?: number
+  callerAddress?: string
+  worldStateBlockHash?: string
+  txId?: string
+  interestedContracts?: string[]
+  inputAssets?: InputAsset[]
+}
+
+export type CallScriptResult<R> = CallContractResult<R>
+
 export interface CallContractParams<T extends Arguments = Arguments> {
   args: T
   worldStateBlockHash?: string
   txId?: string
-  existingContracts?: string[]
+  interestedContracts?: string[]
   inputAssets?: InputAsset[]
 }
 

package/std/nft_interface.ral

@@ -14,11 +14,30 @@ Interface INFT {
    //         },
    //         "description": {
    //             "type": "string",
-   //             "description": "General description of the NFT"
+   //             "description": "General description of the NFT",
+   //             "nullable": true
    //         },
    //         "image": {
    //             "type": "string",
    //             "description": "A URI to the image that represents the NFT"
+   //         },
+   //         "attributes": {
+   //           "type": "array",
+   //           "description": "An array of attributes for the NFT",
+   //           "items": {
+   //             "type": "object",
+   //             "properties": {
+   //               "trait_type": {
+   //                 "type": "string",
+   //                 "description": "The type of trait"
+   //               },
+   //               "value": {
+   //                 "type": ["string", "number", "boolean"],
+   //                 "description": "The value of the trait"
+   //               }
+   //             }
+   //           },
+   //           "nullable": true
    //         }
    //     }
    // }