@alephium/web3 2.0.7 → 2.0.10

package/dist/src/contract/contract.js

@@ -823,7 +823,8 @@ function subscribeEventsFromContract(options, address, eventIndex, decodeFunc, f
         pollingInterval: options.pollingInterval,
         messageCallback: messageCallback,
         errorCallback: errorCallback,
-        onEventCountChanged: options.onEventCountChanged
+        onEventCountChanged: options.onEventCountChanged,
+        parallel: options.parallel
     };
     return (0, events_1.subscribeToEvents)(opt, address, fromCount);
 }
@@ -1242,7 +1243,8 @@ function subscribeContractEvents(contract, instance, options, fromCount) {
         pollingInterval: options.pollingInterval,
         messageCallback: messageCallback,
         errorCallback: errorCallback,
-        onEventCountChanged: options.onEventCountChanged
+        onEventCountChanged: options.onEventCountChanged,
+        parallel: options.parallel
     };
     return (0, events_1.subscribeToEvents)(opt, instance.address, fromCount);
 }
@@ -1250,13 +1252,39 @@ exports.subscribeContractEvents = subscribeContractEvents;
 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 callArgs = getCallMethodArgs(params.args ?? {}, instance.groupIndex);
+    const callParams = contract.contract.toApiCallContract({ ...params, txId: txId, args: callArgs }, instance.groupIndex, instance.address, methodIndex);
     const result = await (0, global_1.getCurrentNodeProvider)().contracts.postContractsCallContract(callParams);
     const callResult = contract.contract.fromApiCallContractResult(result, txId, methodIndex, getContractByCodeHash);
     contract.contract.printDebugMessages(methodName, callResult.debugMessages);
     return callResult;
 }
 exports.callMethod = callMethod;
+function tryGetCallMethodAddressArg(maybeAddress, groupIndex) {
+    if (!(0, address_1.isValidAddress)(maybeAddress))
+        return maybeAddress;
+    if ((0, address_1.isGrouplessAddress)(maybeAddress)) {
+        const rawAddress = (0, address_1.addressWithoutExplicitGroupIndex)(maybeAddress);
+        return `${rawAddress}:${groupIndex}`;
+    }
+    return maybeAddress;
+}
+function getCallMethodArgsFromVal(val, groupIndex) {
+    if (typeof val === 'string') {
+        return tryGetCallMethodAddressArg(val, groupIndex);
+    }
+    if (Array.isArray(val)) {
+        return val.map((v) => getCallMethodArgsFromVal(v, groupIndex));
+    }
+    return val;
+}
+function getCallMethodArgs(args, groupIndex) {
+    const newArgs = {};
+    for (const [key, value] of Object.entries(args)) {
+        newArgs[`${key}`] = getCallMethodArgsFromVal(value, groupIndex);
+    }
+    return newArgs;
+}
 async function signExecuteMethod(contract, instance, methodName, params) {
     const methodIndex = contract.contract.getMethodIndex(methodName);
     const functionSig = contract.contract.functions[methodIndex];
@@ -1449,7 +1477,8 @@ async function multicallMethods(contract, instance, _callss, getContractByCodeHa
             const [methodName, params] = entry;
             const methodIndex = contract.contract.getMethodIndex(methodName);
             const txId = params?.txId ?? randomTxId();
-            return contract.contract.toApiCallContract({ ...params, txId: txId, args: params.args === undefined ? {} : params.args }, instance.groupIndex, instance.address, methodIndex);
+            const callArgs = getCallMethodArgs(params.args ?? {}, instance.groupIndex);
+            return contract.contract.toApiCallContract({ ...params, txId: txId, args: callArgs }, instance.groupIndex, instance.address, methodIndex);
         });
     });
     const result = await (0, global_1.getCurrentNodeProvider)().contracts.postContractsMulticallContract({ calls: callsParams.flat() });

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

@@ -2,11 +2,13 @@ import { node } from '../api';
 import { Subscription, SubscribeOptions } from '../utils';
 export interface EventSubscribeOptions<Message> extends SubscribeOptions<Message> {
     onEventCountChanged?: (eventCount: number) => Promise<void> | void;
+    parallel?: boolean;
 }
 export declare class EventSubscription extends Subscription<node.ContractEvent> {
     readonly contractAddress: string;
     private fromCount;
     private onEventCountChanged?;
+    private parallel;
     constructor(options: EventSubscribeOptions<node.ContractEvent>, contractAddress: string, fromCount?: number);
     currentEventCount(): number;
     private getEvents;

package/dist/src/contract/events.js

@@ -46,9 +46,11 @@ const utils_1 = require("../utils");
 class EventSubscription extends utils_1.Subscription {
     constructor(options, contractAddress, fromCount) {
         super(options);
+        this.parallel = false;
         this.contractAddress = contractAddress;
         this.fromCount = typeof fromCount === 'undefined' ? 0 : fromCount;
         this.onEventCountChanged = options.onEventCountChanged;
+        this.parallel = options.parallel ?? false;
     }
     currentEventCount() {
         return this.fromCount;
@@ -72,8 +74,15 @@ class EventSubscription extends utils_1.Subscription {
             if (this.fromCount === events.nextStart) {
                 return;
             }
-            const promises = events.events.map((event) => this.messageCallback(event));
-            await Promise.all(promises);
+            if (this.parallel) {
+                const promises = events.events.map((event) => this.messageCallback(event));
+                await Promise.all(promises);
+            }
+            else {
+                for (const event of events.events) {
+                    await this.messageCallback(event);
+                }
+            }
             this.fromCount = events.nextStart;
             if (this.onEventCountChanged !== undefined) {
                 await this.onEventCountChanged(this.fromCount);

package/dist/src/utils/webcrypto.js

@@ -29,7 +29,8 @@ class WebCrypto {
             throw new TypeError("Failed to execute 'getRandomValues' on 'Crypto': parameter 1 is not of type 'ArrayBufferView'");
         }
         const bytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
-        if (isBrowser) {
+        // Prefer global Web Crypto (e.g. react-native-get-random-values) for mobile compatibility
+        if (globalThis.crypto && typeof globalThis.crypto.getRandomValues === 'function') {
             globalThis.crypto.getRandomValues(bytes);
         }
         else {

package/package.json

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

package/src/contract/contract.ts

@@ -59,7 +59,15 @@ import {
   isHexString,
   hexToString
 } from '../utils'
-import { contractIdFromAddress, groupOfAddress, addressFromContractId, subContractId } from '../address'
+import {
+  contractIdFromAddress,
+  groupOfAddress,
+  addressFromContractId,
+  subContractId,
+  isGrouplessAddress,
+  isValidAddress,
+  addressWithoutExplicitGroupIndex
+} from '../address'
 import { getCurrentNodeProvider } from '../global'
 import { EventSubscribeOptions, EventSubscription, subscribeToEvents } from './events'
 import { MINIMAL_CONTRACT_DEPOSIT, ONE_ALPH, TOTAL_NUMBER_OF_GROUPS } from '../constants'
@@ -1334,7 +1342,8 @@ export function subscribeEventsFromContract<T extends Fields, M extends Contract
     pollingInterval: options.pollingInterval,
     messageCallback: messageCallback,
     errorCallback: errorCallback,
-    onEventCountChanged: options.onEventCountChanged
+    onEventCountChanged: options.onEventCountChanged,
+    parallel: options.parallel
   }
   return subscribeToEvents(opt, address, fromCount)
 }
@@ -1907,7 +1916,8 @@ export function subscribeContractEvents(
     pollingInterval: options.pollingInterval,
     messageCallback: messageCallback,
     errorCallback: errorCallback,
-    onEventCountChanged: options.onEventCountChanged
+    onEventCountChanged: options.onEventCountChanged,
+    parallel: options.parallel
   }
   return subscribeToEvents(opt, instance.address, fromCount)
 }
@@ -1921,8 +1931,9 @@ export async function callMethod<I extends ContractInstance, F extends Fields, A
 ): Promise<CallContractResult<R>> {
   const methodIndex = contract.contract.getMethodIndex(methodName)
   const txId = params?.txId ?? randomTxId()
+  const callArgs = getCallMethodArgs(params.args ?? {}, instance.groupIndex)
   const callParams = contract.contract.toApiCallContract(
-    { ...params, txId: txId, args: params.args === undefined ? {} : params.args },
+    { ...params, txId: txId, args: callArgs },
     instance.groupIndex,
     instance.address,
     methodIndex
@@ -1933,6 +1944,33 @@ export async function callMethod<I extends ContractInstance, F extends Fields, A
   return callResult as CallContractResult<R>
 }
 
+function tryGetCallMethodAddressArg(maybeAddress: string, groupIndex: number): Val {
+  if (!isValidAddress(maybeAddress)) return maybeAddress
+  if (isGrouplessAddress(maybeAddress)) {
+    const rawAddress = addressWithoutExplicitGroupIndex(maybeAddress)
+    return `${rawAddress}:${groupIndex}`
+  }
+  return maybeAddress
+}
+
+function getCallMethodArgsFromVal(val: Val, groupIndex: number): Val {
+  if (typeof val === 'string') {
+    return tryGetCallMethodAddressArg(val, groupIndex)
+  }
+  if (Array.isArray(val)) {
+    return val.map((v) => getCallMethodArgsFromVal(v, groupIndex))
+  }
+  return val
+}
+
+function getCallMethodArgs<A extends Arguments>(args: A, groupIndex: number): A {
+  const newArgs: Arguments = {}
+  for (const [key, value] of Object.entries(args)) {
+    newArgs[`${key}`] = getCallMethodArgsFromVal(value, groupIndex)
+  }
+  return newArgs as A
+}
+
 export async function signExecuteMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(
   contract: ContractFactory<I, F>,
   instance: ContractInstance,
@@ -2197,8 +2235,9 @@ export async function multicallMethods<I extends ContractInstance, F extends Fie
       const [methodName, params] = entry
       const methodIndex = contract.contract.getMethodIndex(methodName)
       const txId = params?.txId ?? randomTxId()
+      const callArgs = getCallMethodArgs(params.args ?? {}, instance.groupIndex)
       return contract.contract.toApiCallContract(
-        { ...params, txId: txId, args: params.args === undefined ? {} : params.args },
+        { ...params, txId: txId, args: callArgs },
         instance.groupIndex,
         instance.address,
         methodIndex

package/src/contract/events.ts

@@ -23,18 +23,21 @@ import { ContractEvents } from '../api/api-alephium'
 
 export interface EventSubscribeOptions<Message> extends SubscribeOptions<Message> {
   onEventCountChanged?: (eventCount: number) => Promise<void> | void
+  parallel?: boolean
 }
 
 export class EventSubscription extends Subscription<node.ContractEvent> {
   readonly contractAddress: string
   private fromCount: number
   private onEventCountChanged?: (eventCount: number) => Promise<void> | void
+  private parallel = false
 
   constructor(options: EventSubscribeOptions<node.ContractEvent>, contractAddress: string, fromCount?: number) {
     super(options)
     this.contractAddress = contractAddress
     this.fromCount = typeof fromCount === 'undefined' ? 0 : fromCount
     this.onEventCountChanged = options.onEventCountChanged
+    this.parallel = options.parallel ?? false
   }
 
   currentEventCount(): number {
@@ -61,8 +64,15 @@ export class EventSubscription extends Subscription<node.ContractEvent> {
         return
       }
 
-      const promises = events.events.map((event) => this.messageCallback(event))
-      await Promise.all(promises)
+      if (this.parallel) {
+        const promises = events.events.map((event) => this.messageCallback(event))
+        await Promise.all(promises)
+      } else {
+        for (const event of events.events) {
+          await this.messageCallback(event)
+        }
+      }
+
       this.fromCount = events.nextStart
 
       if (this.onEventCountChanged !== undefined) {

package/src/utils/webcrypto.ts

@@ -31,7 +31,8 @@ export class WebCrypto {
     }
     const bytes = new Uint8Array(array.buffer, array.byteOffset, array.byteLength)
 
-    if (isBrowser) {
+    // Prefer global Web Crypto (e.g. react-native-get-random-values) for mobile compatibility
+    if (globalThis.crypto && typeof globalThis.crypto.getRandomValues === 'function') {
       globalThis.crypto.getRandomValues(bytes)
     } else {
       randomFillSync(bytes)