@alephium/web3 0.12.5 → 0.13.0

package/dist/src/api/api-alephium.d.ts

@@ -938,7 +938,7 @@ export declare class HttpClient<SecurityDataType = unknown> {
 }
 /**
  * @title Alephium API
- * @version 2.3.3
+ * @version 2.3.5
  * @baseUrl ../
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
@@ -1373,7 +1373,9 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Get the balance of an address
          * @request GET:/addresses/{address}/balance
          */
-        getAddressesAddressBalance: (address: string, params?: RequestParams) => Promise<Balance>;
+        getAddressesAddressBalance: (address: string, query?: {
+            mempool?: boolean;
+        }, params?: RequestParams) => Promise<Balance>;
         /**
          * No description
          *

package/dist/src/api/api-alephium.js

@@ -151,7 +151,7 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 2.3.3
+ * @version 2.3.5
  * @baseUrl ../
  */
 class Api extends HttpClient {
@@ -758,9 +758,10 @@ class Api extends HttpClient {
              * @summary Get the balance of an address
              * @request GET:/addresses/{address}/balance
              */
-            getAddressesAddressBalance: (address, params = {}) => this.request({
+            getAddressesAddressBalance: (address, query, params = {}) => this.request({
                 path: `/addresses/${address}/balance`,
                 method: 'GET',
+                query: query,
                 format: 'json',
                 ...params
             }).then(utils_1.convertHttpResponse),

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

@@ -1,4 +1,4 @@
-import { ApiRequestArguments, ApiRequestHandler, TokenMetaData } from './types';
+import { ApiRequestArguments, ApiRequestHandler, FungibleTokenMetaData, NFTMetaData } from './types';
 import { Api as NodeApi } from './api-alephium';
 import { HexString } from '../contract';
 interface NodeProviderApis {
@@ -32,7 +32,9 @@ export declare class NodeProvider implements NodeProviderApis {
     request: (args: ApiRequestArguments) => Promise<any>;
     static Proxy(nodeProvider: NodeProvider): NodeProvider;
     static Remote(handler: ApiRequestHandler): NodeProvider;
-    fetchStdTokenMetaData: (tokenId: HexString) => Promise<TokenMetaData>;
+    fetchFungibleTokenMetaData: (tokenId: HexString) => Promise<FungibleTokenMetaData>;
+    fetchNFTMetaData: (tokenId: HexString) => Promise<NFTMetaData>;
     guessStdInterfaceId: (tokenId: HexString) => Promise<HexString | undefined>;
+    guessStdTokenType: (tokenId: HexString) => Promise<'fungible' | 'non-fungible' | undefined>;
 }
 export {};

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

@@ -37,8 +37,8 @@ class NodeProvider {
         this.request = (args) => {
             return (0, types_1.request)(this, args);
         };
-        // Only use this when the token is following the standard token interface
-        this.fetchStdTokenMetaData = async (tokenId) => {
+        // Only use this when the token follows the fungible token interface, check `guessTokenType` first
+        this.fetchFungibleTokenMetaData = async (tokenId) => {
             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 }));
@@ -52,6 +52,19 @@ class NodeProvider {
                 totalSupply: BigInt(result.results[3].returns[0].value)
             };
         };
+        // Only use this when the token follows the non-fungile token interface, check `guessTokenType` first
+        this.fetchNFTMetaData = async (tokenId) => {
+            const address = (0, utils_2.addressFromTokenId)(tokenId);
+            const group = (0, utils_2.groupOfAddress)(address);
+            const calls = Array.from([0, 1], (index) => ({ methodIndex: index, group: group, address: address }));
+            const result = await this.contracts.postContractsMulticallContract({
+                calls: calls
+            });
+            return {
+                tokenUri: (0, utils_2.hexToString)(result.results[0].returns[0].value),
+                collectionAddress: (0, utils_2.addressFromContractId)(result.results[1].returns[0].value)
+            };
+        };
         this.guessStdInterfaceId = async (tokenId) => {
             const address = (0, utils_2.addressFromTokenId)(tokenId);
             const group = (0, utils_2.groupOfAddress)(address);
@@ -65,6 +78,17 @@ class NodeProvider {
                 return undefined;
             }
         };
+        this.guessStdTokenType = async (tokenId) => {
+            const interfaceId = await this.guessStdInterfaceId(tokenId);
+            switch (interfaceId) {
+                case '0001':
+                    return 'fungible';
+                case '0003':
+                    return 'non-fungible';
+                default:
+                    return undefined;
+            }
+        };
         let nodeApi;
         if (typeof param0 === 'string') {
             nodeApi = initializeNodeApi(param0, apiKey, customFetch);

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

@@ -30,9 +30,13 @@ export interface ApiRequestArguments {
 export type ApiRequestHandler = (args: ApiRequestArguments) => Promise<any>;
 export declare function forwardRequests(api: Record<string, any>, handler: ApiRequestHandler): void;
 export declare function request(provider: Record<string, any>, args: ApiRequestArguments): Promise<any>;
-export interface TokenMetaData {
+export interface FungibleTokenMetaData {
     name: string;
     symbol: string;
     decimals: number;
     totalSupply: Number256;
 }
+export interface NFTMetaData {
+    collectionAddress: string;
+    tokenUri: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.12.5",
+  "version": "0.13.0",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",
@@ -27,7 +27,7 @@
   },
   "author": "Alephium dev <dev@alephium.org>",
   "config": {
-    "alephium_version": "2.3.3",
+    "alephium_version": "2.3.5",
     "explorer_backend_version": "1.13.5"
   },
   "type": "commonjs",

package/src/api/api-alephium.ts

@@ -1228,7 +1228,7 @@ export class HttpClient<SecurityDataType = unknown> {
 
 /**
  * @title Alephium API
- * @version 2.3.3
+ * @version 2.3.5
  * @baseUrl ../
  */
 export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
@@ -2016,10 +2016,17 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      * @summary Get the balance of an address
      * @request GET:/addresses/{address}/balance
      */
-    getAddressesAddressBalance: (address: string, params: RequestParams = {}) =>
+    getAddressesAddressBalance: (
+      address: string,
+      query?: {
+        mempool?: boolean
+      },
+      params: RequestParams = {}
+    ) =>
       this.request<Balance, BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable>({
         path: `/addresses/${address}/balance`,
         method: 'GET',
+        query: query,
         format: 'json',
         ...params
       }).then(convertHttpResponse),

package/src/api/node-provider.ts

@@ -16,11 +16,18 @@ You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
-import { ApiRequestArguments, ApiRequestHandler, forwardRequests, request, TokenMetaData } from './types'
+import {
+  ApiRequestArguments,
+  ApiRequestHandler,
+  forwardRequests,
+  request,
+  FungibleTokenMetaData,
+  NFTMetaData
+} from './types'
 import { Api as NodeApi } from './api-alephium'
 import { DEFAULT_THROTTLE_FETCH } from './utils'
 import { HexString } from '../contract'
-import { addressFromTokenId, groupOfAddress } from '../utils'
+import { addressFromContractId, addressFromTokenId, groupOfAddress, hexToString } from '../utils'
 
 function initializeNodeApi(baseUrl: string, apiKey?: string, customFetch?: typeof fetch): NodeApi<string> {
   const nodeApi = new NodeApi<string>({
@@ -100,8 +107,8 @@ export class NodeProvider implements NodeProviderApis {
     return new NodeProvider(handler)
   }
 
-  // Only use this when the token is following the standard token interface
-  fetchStdTokenMetaData = async (tokenId: HexString): Promise<TokenMetaData> => {
+  // Only use this when the token follows the fungible token interface, check `guessTokenType` first
+  fetchFungibleTokenMetaData = async (tokenId: HexString): Promise<FungibleTokenMetaData> => {
     const address = addressFromTokenId(tokenId)
     const group = groupOfAddress(address)
     const calls = Array.from([0, 1, 2, 3], (index) => ({ methodIndex: index, group: group, address: address }))
@@ -116,6 +123,20 @@ export class NodeProvider implements NodeProviderApis {
     }
   }
 
+  // Only use this when the token follows the non-fungile token interface, check `guessTokenType` first
+  fetchNFTMetaData = async (tokenId: HexString): Promise<NFTMetaData> => {
+    const address = addressFromTokenId(tokenId)
+    const group = groupOfAddress(address)
+    const calls = Array.from([0, 1], (index) => ({ methodIndex: index, group: group, address: address }))
+    const result = await this.contracts.postContractsMulticallContract({
+      calls: calls
+    })
+    return {
+      tokenUri: hexToString(result.results[0].returns[0].value as any as string),
+      collectionAddress: addressFromContractId(result.results[1].returns[0].value as any as string)
+    }
+  }
+
   guessStdInterfaceId = async (tokenId: HexString): Promise<HexString | undefined> => {
     const address = addressFromTokenId(tokenId)
     const group = groupOfAddress(address)
@@ -128,4 +149,16 @@ export class NodeProvider implements NodeProviderApis {
       return undefined
     }
   }
+
+  guessStdTokenType = async (tokenId: HexString): Promise<'fungible' | 'non-fungible' | undefined> => {
+    const interfaceId = await this.guessStdInterfaceId(tokenId)
+    switch (interfaceId) {
+      case '0001':
+        return 'fungible'
+      case '0003':
+        return 'non-fungible'
+      default:
+        return undefined
+    }
+  }
 }

package/src/api/types.ts

@@ -264,9 +264,14 @@ export async function request(provider: Record<string, any>, args: ApiRequestArg
   return call(...args.params)
 }
 
-export interface TokenMetaData {
+export interface FungibleTokenMetaData {
   name: string
   symbol: string
   decimals: number
   totalSupply: Number256
 }
+
+export interface NFTMetaData {
+  collectionAddress: string
+  tokenUri: string
+}