@alephium/web3 1.5.2 → 1.7.0

package/src/contract/contract.ts

@@ -162,7 +162,7 @@ export abstract class Artifact {
     this.functions = functions
   }
 
-  abstract buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean): string
+  abstract buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean, exposePrivateFunctions: boolean): string
 
   async isDevnet(signer: SignerProvider): Promise<boolean> {
     if (!signer.nodeProvider) {
@@ -197,7 +197,10 @@ export class Contract extends Artifact {
 
   readonly bytecodeDebug: string
   readonly codeHashDebug: string
-  readonly decodedMethods: Method[]
+  readonly decodedContract: contract.Contract
+
+  private bytecodeForTesting: string | undefined
+  private codeHashForTesting: string | undefined
 
   constructor(
     version: string,
@@ -230,19 +233,54 @@ export class Contract extends Artifact {
     this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch)
     this.codeHashDebug = codeHashDebug
 
-    this.decodedMethods = contract.contractCodec.decodeContract(hexToBinUnsafe(bytecode)).methods
+    this.decodedContract = contract.contractCodec.decodeContract(hexToBinUnsafe(this.bytecode))
+    this.bytecodeForTesting = undefined
+    this.codeHashForTesting = undefined
+  }
+
+  getByteCodeForTesting(): string {
+    if (this.bytecodeForTesting !== undefined) return this.bytecodeForTesting
+
+    if (this.publicFunctions().length == this.functions.length) {
+      this.bytecodeForTesting = this.bytecodeDebug
+      this.codeHashForTesting = this.codeHashDebug
+      return this.bytecodeForTesting
+    }
+
+    const decodedDebugContract = contract.contractCodec.decodeContract(hexToBinUnsafe(this.bytecodeDebug))
+    const methods = decodedDebugContract.methods.map((method) => ({ ...method, isPublic: true }))
+    const bytecodeForTesting = contract.contractCodec.encodeContract({
+      fieldLength: decodedDebugContract.fieldLength,
+      methods: methods
+    })
+    const codeHashForTesting = blake.blake2b(bytecodeForTesting, undefined, 32)
+    this.bytecodeForTesting = binToHex(bytecodeForTesting)
+    this.codeHashForTesting = binToHex(codeHashForTesting)
+    return this.bytecodeForTesting
+  }
+
+  hasCodeHash(hash: string): boolean {
+    return this.codeHash === hash || this.codeHashDebug === hash || this.codeHashForTesting === hash
+  }
+
+  getDecodedMethod(methodIndex: number): Method {
+    return this.decodedContract.methods[`${methodIndex}`]
   }
 
   publicFunctions(): FunctionSig[] {
-    return this.functions.filter((_, index) => this.decodedMethods[`${index}`].isPublic)
+    return this.functions.filter((_, index) => this.getDecodedMethod(index).isPublic)
   }
 
   usingPreapprovedAssetsFunctions(): FunctionSig[] {
-    return this.functions.filter((_, index) => this.decodedMethods[`${index}`].usePreapprovedAssets)
+    return this.functions.filter((_, index) => this.getDecodedMethod(index).usePreapprovedAssets)
   }
 
   usingAssetsInContractFunctions(): FunctionSig[] {
-    return this.functions.filter((_, index) => this.decodedMethods[`${index}`].useContractAssets)
+    return this.functions.filter((_, index) => this.getDecodedMethod(index).useContractAssets)
+  }
+
+  isMethodUsePreapprovedAssets(methodIndex: number): boolean {
+    return this.getDecodedMethod(methodIndex).usePreapprovedAssets
   }
 
   // TODO: safely parse json
@@ -530,7 +568,11 @@ export class Contract extends Artifact {
   ): Promise<SignDeployContractTxParams> {
     const isDevnet = await this.isDevnet(signer)
     const initialFields: Fields = params.initialFields ?? {}
-    const bytecode = this.buildByteCodeToDeploy(addStdIdToFields(this, initialFields), isDevnet)
+    const bytecode = this.buildByteCodeToDeploy(
+      addStdIdToFields(this, initialFields),
+      isDevnet,
+      params.exposePrivateFunctions ?? false
+    )
     const selectedAccount = await signer.getSelectedAccount()
     const signerParams: SignDeployContractTxParams = {
       signerAddress: selectedAccount.address,
@@ -546,14 +588,15 @@ export class Contract extends Artifact {
     return signerParams
   }
 
-  buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean): string {
+  buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean, exposePrivateFunctions = false): string {
     try {
-      return ralph.buildContractByteCode(
-        isDevnet ? this.bytecodeDebug : this.bytecode,
-        initialFields,
-        this.fieldsSig,
-        this.structs
-      )
+      const bytecode =
+        exposePrivateFunctions && isDevnet
+          ? this.getByteCodeForTesting()
+          : isDevnet
+          ? this.bytecodeDebug
+          : this.bytecode
+      return ralph.buildContractByteCode(bytecode, initialFields, this.fieldsSig, this.structs)
     } catch (error) {
       throw new Error(`Failed to build bytecode for contract ${this.name}, error: ${error}`)
     }
@@ -975,10 +1018,11 @@ export interface DeployContractParams<P extends Fields = Fields> {
   issueTokenTo?: string
   gasAmount?: number
   gasPrice?: Number256
+  exposePrivateFunctions?: boolean
 }
 assertType<
   Eq<
-    Omit<DeployContractParams<undefined>, 'initialFields'>,
+    Omit<DeployContractParams<undefined>, 'initialFields' | 'exposePrivateFunctions'>,
     Omit<SignDeployContractTxParams, 'signerAddress' | 'signerKeyType' | 'bytecode'>
   >
 >
@@ -1687,7 +1731,7 @@ export async function signExecuteMethod<I extends ContractInstance, F extends Fi
 ): Promise<SignExecuteScriptTxResult> {
   const methodIndex = contract.contract.getMethodIndex(methodName)
   const functionSig = contract.contract.functions[methodIndex]
-  const methodUsePreapprovedAssets = contract.contract.decodedMethods[methodIndex].usePreapprovedAssets
+  const methodUsePreapprovedAssets = contract.contract.isMethodUsePreapprovedAssets(methodIndex)
   const bytecodeTemplate = getBytecodeTemplate(
     methodIndex,
     methodUsePreapprovedAssets,
@@ -1944,7 +1988,7 @@ export async function multicallMethods<I extends ContractInstance, F extends Fie
   })
   const result = await getCurrentNodeProvider().contracts.postContractsMulticallContract({ calls: callsParams.flat() })
   let callResultIndex = 0
-  const results = callsParams.map((calls, index0) => {
+  return callsParams.map((calls, index0) => {
     const callsResult: Record<string, CallContractResult<any>> = {}
     const entries = callEntries[`${index0}`]
     calls.forEach((call, index1) => {
@@ -1961,7 +2005,6 @@ export async function multicallMethods<I extends ContractInstance, F extends Fie
     })
     return callsResult
   })
-  return results.length === 1 ? results[0] : results
 }
 
 export async function getContractEventsCurrentCount(contractAddress: Address): Promise<number> {