@alephium/web3 0.12.3 → 0.12.5-rc.0

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

@@ -128,18 +128,18 @@ export declare class Contract extends Artifact {
     toApiContractStates(states?: ContractState[]): node.ContractState[] | undefined;
     toApiTestContractParams(funcName: string, params: TestContractParams): node.TestContract;
     fromApiContractState(state: node.ContractState): ContractState<Fields>;
-    static fromApiContractState(state: node.ContractState): ContractState;
+    static fromApiContractState(state: node.ContractState, getContractByCodeHash?: (codeHash: string) => Contract): ContractState;
     static ContractCreatedEventIndex: number;
     static ContractCreatedEvent: EventSig;
     static ContractDestroyedEventIndex: number;
     static ContractDestroyedEvent: EventSig;
-    static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined, txId: string): ContractEvent;
+    static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined, txId: string, getContractByCodeHash?: (codeHash: string) => Contract): ContractEvent;
     fromApiTestContractResult(methodName: string, result: node.TestContractResult, txId: string): TestContractResult<unknown>;
     txParamsForDeployment<P extends Fields>(signer: SignerProvider, params: DeployContractParams<P>): Promise<SignDeployContractTxParams>;
     buildByteCodeToDeploy(initialFields: Fields): string;
-    static fromApiEvents(events: node.ContractEventByTxId[], addressToCodeHash: Map<string, string>, txId: string): ContractEvent[];
+    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): CallContractResult<unknown>;
+    fromApiCallContractResult(result: node.CallContractResult, txId: string, methodIndex: number, getContractByCodeHash?: (codeHash: string) => Contract): CallContractResult<unknown>;
 }
 export declare class Script extends Artifact {
     readonly bytecodeTemplate: string;
@@ -235,6 +235,11 @@ export declare abstract class ContractFactory<I extends ContractInstance, F exte
     deploy(signer: SignerProvider, deployParams: DeployContractParams<F>): Promise<DeployContractResult<I>>;
     stateForTest(initFields: F, asset?: Asset, address?: string): ContractState<F>;
 }
+export declare class ExecutableScript<P extends Fields = Fields> {
+    readonly script: Script;
+    constructor(script: Script);
+    execute(signer: SignerProvider, params: ExecuteScriptParams<P>): Promise<ExecuteScriptResult>;
+}
 export interface ExecuteScriptParams<P extends Fields = Fields> {
     initialFields: P;
     attoAlphAmount?: Number256;
@@ -296,7 +301,7 @@ export declare function subscribeContractDestroyedEvent(options: SubscribeOption
 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 subscribeContractEvents(contract: Contract, instance: ContractInstance, options: SubscribeOptions<ContractEvent<any>>, fromCount?: number): EventSubscription;
-export declare function callMethod<I extends ContractInstance, 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 multicallMethods<I extends ContractInstance, F extends Fields>(contract: ContractFactory<I, F>, instance: ContractInstance, calls: Record<string, Optional<CallContractParams<any>, 'args'>>): Promise<Record<string, CallContractResult<any>>>;
+export declare function callMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, instance: ContractInstance, methodName: string, params: Optional<CallContractParams<A>, 'args'>, getContractByCodeHash?: (codeHash: string) => Contract): Promise<CallContractResult<R>>;
+export declare function multicallMethods<I extends ContractInstance, F extends Fields>(contract: ContractFactory<I, F>, instance: ContractInstance, calls: Record<string, Optional<CallContractParams<any>, 'args'>>, getContractByCodeHash?: (codeHash: string) => Contract): Promise<Record<string, CallContractResult<any>>>;
 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.getContractEventsCurrentCount = exports.multicallMethods = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.testMethod = exports.addStdIdToFields = 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 = exports.StdIdFieldName = void 0;
+exports.getContractEventsCurrentCount = exports.multicallMethods = exports.callMethod = exports.subscribeContractEvents = exports.subscribeContractEvent = exports.decodeEvent = exports.subscribeContractDestroyedEvent = exports.subscribeContractCreatedEvent = exports.fetchContractState = exports.ContractInstance = exports.testMethod = exports.addStdIdToFields = exports.subscribeEventsFromContract = exports.decodeContractDestroyedEvent = exports.decodeContractCreatedEvent = exports.DestroyContractEventAddress = exports.CreateContractEventAddress = exports.ExecutableScript = exports.ContractFactory = exports.randomTxId = exports.toApiVals = exports.Script = exports.Contract = exports.Artifact = exports.Project = exports.DEFAULT_COMPILER_OPTIONS = exports.DEFAULT_NODE_COMPILER_OPTIONS = exports.StdIdFieldName = void 0;
 const buffer_1 = require("buffer/");
 const fs_1 = __importDefault(require("fs"));
 const fs_2 = require("fs");
@@ -620,11 +620,13 @@ class Contract extends Artifact {
             asset: fromApiAsset(state.asset)
         };
     }
-    static fromApiContractState(state) {
-        const contract = Project.currentProject.contractByCodeHash(state.codeHash);
+    static fromApiContractState(state, getContractByCodeHash) {
+        const contract = getContractByCodeHash
+            ? getContractByCodeHash(state.codeHash)
+            : Project.currentProject.contractByCodeHash(state.codeHash);
         return contract.fromApiContractState(state);
     }
-    static fromApiEvent(event, codeHash, txId) {
+    static fromApiEvent(event, codeHash, txId, getContractByCodeHash) {
         let fields;
         let name;
         if (event.eventIndex == Contract.ContractCreatedEventIndex) {
@@ -636,7 +638,9 @@ class Contract extends Artifact {
             name = Contract.ContractDestroyedEvent.name;
         }
         else {
-            const contract = Project.currentProject.contractByCodeHash(codeHash);
+            const contract = getContractByCodeHash
+                ? getContractByCodeHash(codeHash)
+                : Project.currentProject.contractByCodeHash(codeHash);
             const eventSig = contract.eventsSig[event.eventIndex];
             fields = fromApiEventFields(event.fields, eventSig);
             name = eventSig.name;
@@ -688,12 +692,12 @@ class Contract extends Artifact {
     buildByteCodeToDeploy(initialFields) {
         return ralph.buildContractByteCode(this.bytecode, initialFields, this.fieldsSig);
     }
-    static fromApiEvents(events, addressToCodeHash, txId) {
+    static fromApiEvents(events, addressToCodeHash, txId, getContractByCodeHash) {
         return events.map((event) => {
             const contractAddress = event.contractAddress;
             const codeHash = addressToCodeHash.get(contractAddress);
             if (typeof codeHash !== 'undefined' || event.eventIndex < 0) {
-                return Contract.fromApiEvent(event, codeHash, txId);
+                return Contract.fromApiEvent(event, codeHash, txId, getContractByCodeHash);
             }
             else {
                 throw Error(`Cannot find codeHash for the contract address: ${contractAddress}`);
@@ -711,7 +715,7 @@ class Contract extends Artifact {
             args: args
         };
     }
-    fromApiCallContractResult(result, txId, methodIndex) {
+    fromApiCallContractResult(result, txId, methodIndex, getContractByCodeHash) {
         const returnTypes = this.functions[`${methodIndex}`].returnTypes;
         const rawReturn = (0, api_1.fromApiArray)(result.returns, returnTypes);
         const returns = rawReturn.length === 0 ? null : rawReturn.length === 1 ? rawReturn[0] : rawReturn;
@@ -720,10 +724,10 @@ class Contract extends Artifact {
         return {
             returns: returns,
             gasUsed: result.gasUsed,
-            contracts: result.contracts.map((state) => Contract.fromApiContractState(state)),
+            contracts: result.contracts.map((state) => Contract.fromApiContractState(state, getContractByCodeHash)),
             txInputs: result.txInputs,
             txOutputs: result.txOutputs.map((output) => fromApiOutput(output)),
-            events: Contract.fromApiEvents(result.events, addressToCodeHash, txId)
+            events: Contract.fromApiEvents(result.events, addressToCodeHash, txId, getContractByCodeHash)
         };
     }
 }
@@ -931,6 +935,16 @@ class ContractFactory {
     }
 }
 exports.ContractFactory = ContractFactory;
+class ExecutableScript {
+    constructor(script) {
+        this.script = script;
+    }
+    async execute(signer, params) {
+        const signerParams = await this.script.txParamsForExecution(signer, params);
+        return await signer.signAndSubmitExecuteScriptTx(signerParams);
+    }
+}
+exports.ExecutableScript = ExecutableScript;
 function specialContractAddress(n) {
     const bytes = new Uint8Array(32).fill(0);
     bytes[31] = n;
@@ -1094,16 +1108,16 @@ function subscribeContractEvents(contract, instance, options, fromCount) {
     return (0, events_1.subscribeToEvents)(opt, instance.address, fromCount);
 }
 exports.subscribeContractEvents = subscribeContractEvents;
-async function callMethod(contract, instance, methodName, params) {
+async function callMethod(contract, instance, methodName, params, getContractByCodeHash) {
     const methodIndex = contract.contract.getMethodIndex(methodName);
     const txId = params?.txId ?? randomTxId();
     const callParams = contract.contract.toApiCallContract({ ...params, txId: txId, args: params.args === undefined ? {} : params.args }, instance.groupIndex, instance.address, methodIndex);
     const result = await (0, global_1.getCurrentNodeProvider)().contracts.postContractsCallContract(callParams);
-    const callResult = contract.contract.fromApiCallContractResult(result, txId, methodIndex);
+    const callResult = contract.contract.fromApiCallContractResult(result, txId, methodIndex, getContractByCodeHash);
     return callResult;
 }
 exports.callMethod = callMethod;
-async function multicallMethods(contract, instance, calls) {
+async function multicallMethods(contract, instance, calls, getContractByCodeHash) {
     const callEntries = Object.entries(calls);
     const callsParams = callEntries.map((entry) => {
         const [methodName, params] = entry;
@@ -1117,7 +1131,7 @@ async function multicallMethods(contract, instance, calls) {
         const methodIndex = call.methodIndex;
         const callResult = result.results[`${methodIndex}`];
         const methodName = callEntries[`${index}`][`0`];
-        callsResult[`${methodName}`] = contract.contract.fromApiCallContractResult(callResult, call.txId, methodIndex);
+        callsResult[`${methodName}`] = contract.contract.fromApiCallContractResult(callResult, call.txId, methodIndex, getContractByCodeHash);
     });
     return callsResult;
 }

package/dist/src/utils/webcrypto.d.ts

@@ -1,4 +1,5 @@
 export declare class WebCrypto {
     subtle: SubtleCrypto;
+    constructor();
     getRandomValues<T extends ArrayBufferView | null>(array: T): T;
 }

package/package.json

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

package/src/contract/contract.ts

@@ -922,8 +922,13 @@ export class Contract extends Artifact {
     }
   }
 
-  static fromApiContractState(state: node.ContractState): ContractState {
-    const contract = Project.currentProject.contractByCodeHash(state.codeHash)
+  static fromApiContractState(
+    state: node.ContractState,
+    getContractByCodeHash?: (codeHash: string) => Contract
+  ): ContractState {
+    const contract = getContractByCodeHash
+      ? getContractByCodeHash(state.codeHash)
+      : Project.currentProject.contractByCodeHash(state.codeHash)
     return contract.fromApiContractState(state)
   }
 
@@ -941,7 +946,12 @@ export class Contract extends Artifact {
     fieldTypes: ['Address']
   }
 
-  static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined, txId: string): ContractEvent {
+  static fromApiEvent(
+    event: node.ContractEventByTxId,
+    codeHash: string | undefined,
+    txId: string,
+    getContractByCodeHash?: (codeHash: string) => Contract
+  ): ContractEvent {
     let fields: Fields
     let name: string
 
@@ -952,7 +962,9 @@ export class Contract extends Artifact {
       fields = fromApiEventFields(event.fields, Contract.ContractDestroyedEvent, true)
       name = Contract.ContractDestroyedEvent.name
     } else {
-      const contract = Project.currentProject.contractByCodeHash(codeHash!)
+      const contract = getContractByCodeHash
+        ? getContractByCodeHash(codeHash!)
+        : Project.currentProject.contractByCodeHash(codeHash!)
       const eventSig = contract.eventsSig[event.eventIndex]
       fields = fromApiEventFields(event.fields, eventSig)
       name = eventSig.name
@@ -1020,13 +1032,14 @@ export class Contract extends Artifact {
   static fromApiEvents(
     events: node.ContractEventByTxId[],
     addressToCodeHash: Map<string, string>,
-    txId: string
+    txId: string,
+    getContractByCodeHash?: (codeHash: string) => Contract
   ): ContractEvent[] {
     return events.map((event) => {
       const contractAddress = event.contractAddress
       const codeHash = addressToCodeHash.get(contractAddress)
       if (typeof codeHash !== 'undefined' || event.eventIndex < 0) {
-        return Contract.fromApiEvent(event, codeHash, txId)
+        return Contract.fromApiEvent(event, codeHash, txId, getContractByCodeHash)
       } else {
         throw Error(`Cannot find codeHash for the contract address: ${contractAddress}`)
       }
@@ -1053,7 +1066,8 @@ export class Contract extends Artifact {
   fromApiCallContractResult(
     result: node.CallContractResult,
     txId: string,
-    methodIndex: number
+    methodIndex: number,
+    getContractByCodeHash?: (codeHash: string) => Contract
   ): CallContractResult<unknown> {
     const returnTypes = this.functions[`${methodIndex}`].returnTypes
     const rawReturn = fromApiArray(result.returns, returnTypes)
@@ -1064,10 +1078,10 @@ export class Contract extends Artifact {
     return {
       returns: returns,
       gasUsed: result.gasUsed,
-      contracts: result.contracts.map((state) => Contract.fromApiContractState(state)),
+      contracts: result.contracts.map((state) => Contract.fromApiContractState(state, getContractByCodeHash)),
       txInputs: result.txInputs,
       txOutputs: result.txOutputs.map((output) => fromApiOutput(output)),
-      events: Contract.fromApiEvents(result.events, addressToCodeHash, txId)
+      events: Contract.fromApiEvents(result.events, addressToCodeHash, txId, getContractByCodeHash)
     }
   }
 }
@@ -1404,6 +1418,19 @@ export abstract class ContractFactory<I extends ContractInstance, F extends Fiel
   }
 }
 
+export class ExecutableScript<P extends Fields = Fields> {
+  readonly script: Script
+
+  constructor(script: Script) {
+    this.script = script
+  }
+
+  async execute(signer: SignerProvider, params: ExecuteScriptParams<P>): Promise<ExecuteScriptResult> {
+    const signerParams = await this.script.txParamsForExecution(signer, params)
+    return await signer.signAndSubmitExecuteScriptTx(signerParams)
+  }
+}
+
 export interface ExecuteScriptParams<P extends Fields = Fields> {
   initialFields: P
   attoAlphAmount?: Number256
@@ -1685,7 +1712,8 @@ export async function callMethod<I extends ContractInstance, F extends Fields, A
   contract: ContractFactory<I, F>,
   instance: ContractInstance,
   methodName: string,
-  params: Optional<CallContractParams<A>, 'args'>
+  params: Optional<CallContractParams<A>, 'args'>,
+  getContractByCodeHash?: (codeHash: string) => Contract
 ): Promise<CallContractResult<R>> {
   const methodIndex = contract.contract.getMethodIndex(methodName)
   const txId = params?.txId ?? randomTxId()
@@ -1696,14 +1724,15 @@ export async function callMethod<I extends ContractInstance, F extends Fields, A
     methodIndex
   )
   const result = await getCurrentNodeProvider().contracts.postContractsCallContract(callParams)
-  const callResult = contract.contract.fromApiCallContractResult(result, txId, methodIndex)
+  const callResult = contract.contract.fromApiCallContractResult(result, txId, methodIndex, getContractByCodeHash)
   return callResult as CallContractResult<R>
 }
 
 export async function multicallMethods<I extends ContractInstance, F extends Fields>(
   contract: ContractFactory<I, F>,
   instance: ContractInstance,
-  calls: Record<string, Optional<CallContractParams<any>, 'args'>>
+  calls: Record<string, Optional<CallContractParams<any>, 'args'>>,
+  getContractByCodeHash?: (codeHash: string) => Contract
 ): Promise<Record<string, CallContractResult<any>>> {
   const callEntries = Object.entries(calls)
   const callsParams = callEntries.map((entry) => {
@@ -1726,7 +1755,8 @@ export async function multicallMethods<I extends ContractInstance, F extends Fie
     callsResult[`${methodName}`] = contract.contract.fromApiCallContractResult(
       callResult,
       call.txId!,
-      methodIndex
+      methodIndex,
+      getContractByCodeHash
     ) as CallContractResult<any>
   })
   return callsResult

package/src/utils/webcrypto.ts

@@ -22,7 +22,11 @@ import { webcrypto, randomFillSync } from 'crypto'
 const isBrowser = typeof window !== 'undefined' && typeof window.document !== 'undefined'
 
 export class WebCrypto {
-  subtle = isBrowser ? globalThis.crypto.subtle : webcrypto.subtle
+  subtle: SubtleCrypto
+
+  constructor() {
+    this.subtle = isBrowser ? globalThis.crypto.subtle : webcrypto.subtle
+  }
 
   public getRandomValues<T extends ArrayBufferView | null>(array: T): T {
     if (!ArrayBuffer.isView(array)) {