@alephium/web3 0.10.0-rc.1 → 0.10.0-rc.3

package/dist/src/api/node-provider.js

@@ -39,8 +39,8 @@ class NodeProvider {
         };
         // Only use this when the token is following the standard token interface
         this.fetchStdTokenMetaData = async (tokenId) => {
-            const group = 0;
             const address = (0, utils_2.addressFromTokenId)(tokenId);
+            const group = (0, utils_2.groupOfAddress)(address);
             const calls = Array.from([0, 1, 2, 3], (index) => ({ methodIndex: index, group: group, address: address }));
             const result = await this.contracts.postContractsMulticallContract({
                 calls: calls

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

@@ -220,10 +220,10 @@ export interface DeployContractParams<P extends Fields = Fields> {
     gasAmount?: number;
     gasPrice?: Number256;
 }
-export type DeployContractResult<T> = SignDeployContractTxResult & {
-    instance: T;
+export type DeployContractResult<T extends ContractInstance> = Omit<SignDeployContractTxResult, 'contractId' | 'contractAddress' | 'groupIndex'> & {
+    contractInstance: T;
 };
-export declare abstract class ContractFactory<I, F extends Fields = Fields> {
+export declare abstract class ContractFactory<I extends ContractInstance, F extends Fields = Fields> {
     readonly contract: Contract;
     constructor(contract: Contract);
     abstract at(address: string): I;
@@ -278,7 +278,7 @@ export declare function subscribeEventsFromContract<T extends Fields, M extends
 export declare function addStdIdToFields<F extends Fields>(contract: Contract, fields: F): F | (F & {
     __stdInterfaceId: HexString;
 });
-export declare function testMethod<I, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, methodName: string, params: Optional<TestContractParams<F, A>, 'testArgs' | 'initialFields'>): Promise<TestContractResult<R>>;
+export declare function testMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(contract: ContractFactory<I, F>, methodName: string, params: Optional<TestContractParams<F, A>, 'testArgs' | 'initialFields'>): Promise<TestContractResult<R>>;
 export declare abstract class ContractInstance {
     readonly address: Address;
     readonly contractId: string;
@@ -291,7 +291,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, 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, 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'>): 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 getContractEventsCurrentCount(contractAddress: Address): Promise<number>;
 export {};

package/dist/src/contract/contract.js

@@ -880,7 +880,7 @@ class ContractFactory {
         const result = await signer.signAndSubmitDeployContractTx(signerParams);
         return {
             ...result,
-            instance: this.at(result.contractAddress)
+            contractInstance: this.at(result.contractAddress)
         };
     }
     // This is used for testing contract functions

package/package.json

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

package/src/api/node-provider.ts

@@ -102,8 +102,8 @@ export class NodeProvider implements NodeProviderApis {
 
   // Only use this when the token is following the standard token interface
   fetchStdTokenMetaData = async (tokenId: HexString): Promise<TokenMetaData> => {
-    const group = 0
     const address = addressFromTokenId(tokenId)
+    const group = groupOfAddress(address)
     const calls = Array.from([0, 1, 2, 3], (index) => ({ methodIndex: index, group: group, address: address }))
     const result = await this.contracts.postContractsMulticallContract({
       calls: calls

package/src/contract/contract.ts

@@ -1300,9 +1300,14 @@ assertType<
     Omit<SignDeployContractTxParams, 'signerAddress' | 'signerKeyType' | 'bytecode'>
   >
 >
-export type DeployContractResult<T> = SignDeployContractTxResult & { instance: T }
+export type DeployContractResult<T extends ContractInstance> = Omit<
+  SignDeployContractTxResult,
+  'contractId' | 'contractAddress' | 'groupIndex'
+> & {
+  contractInstance: T
+}
 
-export abstract class ContractFactory<I, F extends Fields = Fields> {
+export abstract class ContractFactory<I extends ContractInstance, F extends Fields = Fields> {
   readonly contract: Contract
 
   constructor(contract: Contract) {
@@ -1319,7 +1324,7 @@ export abstract class ContractFactory<I, F extends Fields = Fields> {
     const result = await signer.signAndSubmitDeployContractTx(signerParams)
     return {
       ...result,
-      instance: this.at(result.contractAddress)
+      contractInstance: this.at(result.contractAddress)
     }
   }
 
@@ -1463,7 +1468,7 @@ export function addStdIdToFields<F extends Fields>(
     : { ...fields, __stdInterfaceId: stdInterfaceIdPrefix + contract.stdInterfaceId }
 }
 
-export async function testMethod<I, F extends Fields, A extends Arguments, R>(
+export async function testMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(
   contract: ContractFactory<I, F>,
   methodName: string,
   params: Optional<TestContractParams<F, A>, 'testArgs' | 'initialFields'>
@@ -1610,7 +1615,7 @@ export function subscribeContractEvents(
   return subscribeToEvents(opt, instance.address, fromCount)
 }
 
-export async function callMethod<I, F extends Fields, A extends Arguments, R>(
+export async function callMethod<I extends ContractInstance, F extends Fields, A extends Arguments, R>(
   contract: ContractFactory<I, F>,
   instance: ContractInstance,
   methodName: string,
@@ -1629,7 +1634,7 @@ export async function callMethod<I, F extends Fields, A extends Arguments, R>(
   return callResult as CallContractResult<R>
 }
 
-export async function multicallMethods<I, F extends Fields>(
+export async function multicallMethods<I extends ContractInstance, F extends Fields>(
   contract: ContractFactory<I, F>,
   instance: ContractInstance,
   calls: Record<string, Optional<CallContractParams<any>, 'args'>>