@alephium/web3 0.30.0 → 0.30.2

package/dist/src/api/node-provider.d.ts

@@ -34,9 +34,11 @@ export declare class NodeProvider implements NodeProviderApis {
     static Remote(handler: ApiRequestHandler): NodeProvider;
     fetchFungibleTokenMetaData: (tokenId: HexString) => Promise<FungibleTokenMetaData>;
     fetchNFTMetaData: (tokenId: HexString) => Promise<NFTMetaData>;
-    fetchNFTCollectionMetaData: (contractId: HexString) => Promise<NFTCollectionMetaData>;
+    fetchNFTCollectionMetaData: (collectionId: HexString) => Promise<NFTCollectionMetaData>;
+    fetchNFTRoyaltyAmount: (collectionId: HexString, tokenId: HexString, salePrice: bigint) => Promise<bigint>;
     guessStdInterfaceId: (tokenId: HexString) => Promise<HexString | undefined>;
     guessFollowsNFTCollectionStd: (contractId: HexString) => Promise<boolean>;
+    guessFollowsNFTCollectionWithRoyaltyStd: (contractId: HexString) => Promise<boolean>;
     guessStdTokenType: (tokenId: HexString) => Promise<'fungible' | 'non-fungible' | undefined>;
 }
 export {};

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

@@ -99,8 +99,8 @@ class NodeProvider {
             }
         };
         // Only use this when the contract follows the NFT collection interface, check `guessFollowsNFTCollectionStd` first
-        this.fetchNFTCollectionMetaData = async (contractId) => {
-            const address = (0, utils_1.addressFromContractId)(contractId);
+        this.fetchNFTCollectionMetaData = async (collectionId) => {
+            const address = (0, utils_1.addressFromContractId)(collectionId);
             const group = (0, utils_1.groupOfAddress)(address);
             const calls = Array.from([0, 1], (index) => ({ methodIndex: index, group: group, address: address }));
             const result = await this.contracts.postContractsMulticallContract({ calls });
@@ -110,6 +110,28 @@ class NodeProvider {
                 totalSupply: BigInt(callResults[1].returns[0].value)
             };
         };
+        // Only use this when the contract follows the NFT collection with royalty interface, check `guessFollowsNFTCollectionWithRoyaltyStd` first
+        this.fetchNFTRoyaltyAmount = async (collectionId, tokenId, salePrice) => {
+            const address = (0, utils_1.addressFromContractId)(collectionId);
+            const group = (0, utils_1.groupOfAddress)(address);
+            const apiResult = await this.contracts.postContractsCallContract({
+                address: address,
+                group: group,
+                methodIndex: 4,
+                args: [
+                    {
+                        type: 'ByteVec',
+                        value: tokenId
+                    },
+                    {
+                        type: 'U256',
+                        value: salePrice.toString()
+                    }
+                ]
+            });
+            const result = (0, contract_1.tryGetCallResult)(apiResult);
+            return BigInt(result.returns[0].value);
+        };
         this.guessStdInterfaceId = async (tokenId) => {
             const address = (0, utils_1.addressFromTokenId)(tokenId);
             const group = (0, utils_1.groupOfAddress)(address);
@@ -127,6 +149,10 @@ class NodeProvider {
             const interfaceId = await this.guessStdInterfaceId(contractId);
             return !!interfaceId && interfaceId.startsWith(types_1.StdInterfaceIds.NFTCollection);
         };
+        this.guessFollowsNFTCollectionWithRoyaltyStd = async (contractId) => {
+            const interfaceId = await this.guessStdInterfaceId(contractId);
+            return interfaceId === types_1.StdInterfaceIds.NFTCollectionWithRoyalty;
+        };
         this.guessStdTokenType = async (tokenId) => {
             const interfaceId = await this.guessStdInterfaceId(tokenId);
             switch (interfaceId) {

package/dist/src/api/types.d.ts

@@ -57,12 +57,10 @@ export interface NFTTokenUriMetaData {
     name: string;
     description?: string;
     image: string;
-    attributes?: [
-        {
-            trait_type: string;
-            value: string | number | boolean;
-        }
-    ];
+    attributes?: {
+        trait_type: string;
+        value: string | number | boolean;
+    }[];
 }
 export interface NFTCollectionUriMetaData {
     name: string;

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

@@ -178,6 +178,7 @@ export declare function toApiVals(fields: Fields, names: string[], types: string
 export interface TestContractParams<F extends Fields = Fields, A extends Arguments = Arguments> {
     group?: number;
     address?: string;
+    callerAddress?: string;
     blockHash?: string;
     blockTimeStamp?: number;
     txId?: string;

package/dist/src/contract/contract.js

@@ -632,6 +632,7 @@ class Contract extends Artifact {
             blockTimeStamp: params.blockTimeStamp,
             txId: params.txId,
             address: params.address,
+            callerAddress: params.callerAddress,
             bytecode: this.bytecodeDebug,
             initialImmFields: immFields,
             initialMutFields: mutFields,

package/package.json

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

package/src/api/node-provider.ts

@@ -182,8 +182,8 @@ export class NodeProvider implements NodeProviderApis {
   }
 
   // Only use this when the contract follows the NFT collection interface, check `guessFollowsNFTCollectionStd` first
-  fetchNFTCollectionMetaData = async (contractId: HexString): Promise<NFTCollectionMetaData> => {
-    const address = addressFromContractId(contractId)
+  fetchNFTCollectionMetaData = async (collectionId: HexString): Promise<NFTCollectionMetaData> => {
+    const address = addressFromContractId(collectionId)
     const group = groupOfAddress(address)
     const calls = Array.from([0, 1], (index) => ({ methodIndex: index, group: group, address: address }))
     const result = await this.contracts.postContractsMulticallContract({ calls })
@@ -194,6 +194,30 @@ export class NodeProvider implements NodeProviderApis {
     }
   }
 
+  // Only use this when the contract follows the NFT collection with royalty interface, check `guessFollowsNFTCollectionWithRoyaltyStd` first
+  fetchNFTRoyaltyAmount = async (collectionId: HexString, tokenId: HexString, salePrice: bigint): Promise<bigint> => {
+    const address = addressFromContractId(collectionId)
+    const group = groupOfAddress(address)
+    const apiResult = await this.contracts.postContractsCallContract({
+      address: address,
+      group: group,
+      methodIndex: 4,
+      args: [
+        {
+          type: 'ByteVec',
+          value: tokenId
+        },
+        {
+          type: 'U256',
+          value: salePrice.toString()
+        }
+      ]
+    })
+
+    const result = tryGetCallResult(apiResult)
+    return BigInt(result.returns[0].value as any as string)
+  }
+
   guessStdInterfaceId = async (tokenId: HexString): Promise<HexString | undefined> => {
     const address = addressFromTokenId(tokenId)
     const group = groupOfAddress(address)
@@ -212,6 +236,11 @@ export class NodeProvider implements NodeProviderApis {
     return !!interfaceId && interfaceId.startsWith(StdInterfaceIds.NFTCollection)
   }
 
+  guessFollowsNFTCollectionWithRoyaltyStd = async (contractId: HexString): Promise<boolean> => {
+    const interfaceId = await this.guessStdInterfaceId(contractId)
+    return interfaceId === StdInterfaceIds.NFTCollectionWithRoyalty
+  }
+
   guessStdTokenType = async (tokenId: HexString): Promise<'fungible' | 'non-fungible' | undefined> => {
     const interfaceId = await this.guessStdInterfaceId(tokenId)
     switch (interfaceId) {

package/src/api/types.ts

@@ -343,12 +343,10 @@ export interface NFTTokenUriMetaData {
   name: string
   description?: string
   image: string
-  attributes?: [
-    {
-      trait_type: string
-      value: string | number | boolean
-    }
-  ]
+  attributes?: {
+    trait_type: string
+    value: string | number | boolean
+  }[]
 }
 
 export interface NFTCollectionUriMetaData {

package/src/contract/contract.ts

@@ -937,6 +937,7 @@ export class Contract extends Artifact {
       blockTimeStamp: params.blockTimeStamp,
       txId: params.txId,
       address: params.address,
+      callerAddress: params.callerAddress,
       bytecode: this.bytecodeDebug,
       initialImmFields: immFields,
       initialMutFields: mutFields,
@@ -1341,6 +1342,7 @@ function toApiInputAssets(inputAssets?: InputAsset[]): node.TestInputAsset[] | u
 export interface TestContractParams<F extends Fields = Fields, A extends Arguments = Arguments> {
   group?: number // default 0
   address?: string
+  callerAddress?: string
   blockHash?: string
   blockTimeStamp?: number
   txId?: string