@alephium/web3 1.6.0 → 1.7.1

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

@@ -2,7 +2,7 @@ import { NamedVals, node, NodeProvider, Number256, Token, Val } from '../api';
 import { SignDeployContractTxParams, SignDeployContractTxResult, SignExecuteScriptTxParams, SignerProvider, Address, SignExecuteScriptTxResult } from '../signer';
 import { Optional, HexString } from '../utils';
 import { EventSubscribeOptions, EventSubscription } from './events';
-import { Method } from '../codec';
+import { contract, Method } from '../codec';
 export type FieldsSig = node.FieldsSig;
 export type MapsSig = node.MapsSig;
 export type EventSig = node.EventSig;
@@ -32,7 +32,7 @@ export declare abstract class Artifact {
     readonly name: string;
     readonly functions: FunctionSig[];
     constructor(version: string, name: string, functions: FunctionSig[]);
-    abstract buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean): string;
+    abstract buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean, exposePrivateFunctions: boolean): string;
     isDevnet(signer: SignerProvider): Promise<boolean>;
 }
 export declare class Contract extends Artifact {
@@ -48,11 +48,17 @@ export declare class Contract extends Artifact {
     readonly stdInterfaceId?: HexString;
     readonly bytecodeDebug: string;
     readonly codeHashDebug: string;
-    readonly decodedMethods: Method[];
+    readonly decodedContract: contract.Contract;
+    private bytecodeForTesting;
+    private codeHashForTesting;
     constructor(version: string, name: string, bytecode: string, bytecodeDebugPatch: string, codeHash: string, codeHashDebug: string, fieldsSig: FieldsSig, eventsSig: EventSig[], functions: FunctionSig[], constants: Constant[], enums: Enum[], structs: Struct[], mapsSig?: MapsSig, stdInterfaceId?: HexString);
+    getByteCodeForTesting(): string;
+    hasCodeHash(hash: string): boolean;
+    getDecodedMethod(methodIndex: number): Method;
     publicFunctions(): FunctionSig[];
     usingPreapprovedAssetsFunctions(): FunctionSig[];
     usingAssetsInContractFunctions(): FunctionSig[];
+    isMethodUsePreapprovedAssets(methodIndex: number): boolean;
     static fromJson(artifact: any, bytecodeDebugPatch?: string, codeHashDebug?: string, structs?: Struct[]): Contract;
     static fromCompileResult(result: node.CompileContractResult, structs?: Struct[]): Contract;
     static fromArtifactFile(path: string, bytecodeDebugPatch: string, codeHashDebug: string, structs?: Struct[]): Promise<Contract>;
@@ -75,7 +81,7 @@ export declare class Contract extends Artifact {
     static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined, txId: string, getContractByCodeHash: (codeHash: string) => Contract): ContractEvent;
     fromApiTestContractResult(methodName: string, result: node.TestContractResult, txId: string, getContractByCodeHash: (codeHash: string) => Contract): TestContractResult<unknown>;
     txParamsForDeployment<P extends Fields>(signer: SignerProvider, params: DeployContractParams<P>): Promise<SignDeployContractTxParams>;
-    buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean): string;
+    buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean, exposePrivateFunctions?: boolean): string;
     static fromApiEvents(events: node.ContractEventByTxId[], addressToCodeHash: Map<string, string>, txId: string, getContractByCodeHash: (codeHash: string) => Contract): ContractEvent[];
     toApiCallContract<T extends Arguments>(params: CallContractParams<T>, groupIndex: number, contractAddress: string, methodIndex: number): node.CallContract;
     fromApiCallContractResult(result: node.CallContractResult, txId: string, methodIndex: number, getContractByCodeHash: (codeHash: string) => Contract): CallContractResult<unknown>;
@@ -173,6 +179,7 @@ export interface DeployContractParams<P extends Fields = Fields> {
     issueTokenTo?: string;
     gasAmount?: number;
     gasPrice?: Number256;
+    exposePrivateFunctions?: boolean;
 }
 export type DeployContractResult<T extends ContractInstance> = Omit<SignDeployContractTxResult, 'contractId' | 'contractAddress' | 'groupIndex'> & {
     contractInstance: T;

package/dist/src/contract/contract.js

@@ -129,16 +129,46 @@ class Contract extends Artifact {
         this.stdInterfaceId = stdInterfaceId;
         this.bytecodeDebug = ralph.buildDebugBytecode(this.bytecode, this.bytecodeDebugPatch);
         this.codeHashDebug = codeHashDebug;
-        this.decodedMethods = codec_1.contract.contractCodec.decodeContract((0, utils_1.hexToBinUnsafe)(bytecode)).methods;
+        this.decodedContract = codec_1.contract.contractCodec.decodeContract((0, utils_1.hexToBinUnsafe)(this.bytecode));
+        this.bytecodeForTesting = undefined;
+        this.codeHashForTesting = undefined;
+    }
+    getByteCodeForTesting() {
+        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 = codec_1.contract.contractCodec.decodeContract((0, utils_1.hexToBinUnsafe)(this.bytecodeDebug));
+        const methods = decodedDebugContract.methods.map((method) => ({ ...method, isPublic: true }));
+        const bytecodeForTesting = codec_1.contract.contractCodec.encodeContract({
+            fieldLength: decodedDebugContract.fieldLength,
+            methods: methods
+        });
+        const codeHashForTesting = blake.blake2b(bytecodeForTesting, undefined, 32);
+        this.bytecodeForTesting = (0, utils_1.binToHex)(bytecodeForTesting);
+        this.codeHashForTesting = (0, utils_1.binToHex)(codeHashForTesting);
+        return this.bytecodeForTesting;
+    }
+    hasCodeHash(hash) {
+        return this.codeHash === hash || this.codeHashDebug === hash || this.codeHashForTesting === hash;
+    }
+    getDecodedMethod(methodIndex) {
+        return this.decodedContract.methods[`${methodIndex}`];
     }
     publicFunctions() {
-        return this.functions.filter((_, index) => this.decodedMethods[`${index}`].isPublic);
+        return this.functions.filter((_, index) => this.getDecodedMethod(index).isPublic);
     }
     usingPreapprovedAssetsFunctions() {
-        return this.functions.filter((_, index) => this.decodedMethods[`${index}`].usePreapprovedAssets);
+        return this.functions.filter((_, index) => this.getDecodedMethod(index).usePreapprovedAssets);
     }
     usingAssetsInContractFunctions() {
-        return this.functions.filter((_, index) => this.decodedMethods[`${index}`].useContractAssets);
+        return this.functions.filter((_, index) => this.getDecodedMethod(index).useContractAssets);
+    }
+    isMethodUsePreapprovedAssets(methodIndex) {
+        return this.getDecodedMethod(methodIndex).usePreapprovedAssets;
     }
     // TODO: safely parse json
     static fromJson(artifact, bytecodeDebugPatch = '', codeHashDebug = '', structs = []) {
@@ -333,7 +363,7 @@ class Contract extends Artifact {
     async txParamsForDeployment(signer, params) {
         const isDevnet = await this.isDevnet(signer);
         const initialFields = 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 = {
             signerAddress: selectedAccount.address,
@@ -348,9 +378,17 @@ class Contract extends Artifact {
         };
         return signerParams;
     }
-    buildByteCodeToDeploy(initialFields, isDevnet) {
+    buildByteCodeToDeploy(initialFields, isDevnet, exposePrivateFunctions = false) {
+        if (exposePrivateFunctions && !isDevnet) {
+            throw new Error('Cannot expose private functions in non-devnet environment');
+        }
         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}`);
@@ -1074,7 +1112,7 @@ exports.callMethod = callMethod;
 async function signExecuteMethod(contract, instance, methodName, params) {
     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, functionSig, contract.contract.structs, params.attoAlphAmount, params.tokens);
     const fieldsSig = toFieldsSig(contract.contract.name, functionSig);
     const bytecode = ralph.buildScriptByteCode(bytecodeTemplate, { __contract__: instance.contractId, ...params.args }, fieldsSig, contract.contract.structs);

package/package.json

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

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,19 @@ export class Contract extends Artifact {
     return signerParams
   }
 
-  buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean): string {
+  buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean, exposePrivateFunctions = false): string {
+    if (exposePrivateFunctions && !isDevnet) {
+      throw new Error('Cannot expose private functions in non-devnet environment')
+    }
+
     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 +1022,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 +1735,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,