feat: consider assetId in check account utility

.changeset/fifty-seals-fetch.md

@@ -0,0 +1,5 @@
+---
+"@fuel-ts/account": patch
+---
+
+feat: consider `assetId` in check account utility

.eslintrc.js

@@ -60,6 +60,7 @@ module.exports = {
     'import/prefer-default-export': 'off',
     'tsdoc/syntax': 'warn',
     'require-await': 'off',
+    'no-empty': ['error', { allowEmptyCatch: true }],
     '@typescript-eslint/require-await': 'error',
     '@typescript-eslint/no-floating-promises': 'error',
     '@typescript-eslint/no-unused-vars': [

packages/account/src/providers/provider.ts

@@ -150,6 +150,8 @@ export type GetBlocksResponse = {
   pageInfo: PageInfo;
 };
 
+export type GetAddressTypeResponse = 'Account' | 'Contract' | 'Transaction' | 'Blob' | 'Asset';
+
 /**
  * Deployed Contract bytecode and contract id
  */
@@ -2193,19 +2195,17 @@ export default class Provider {
    * @returns A promise that resolves to the result of the check.
    */
   async isUserAccount(id: string): Promise<boolean> {
-    const { contract, blob, transaction } = await this.operations.isUserAccount({
-      blobId: id,
-      contractId: id,
-      transactionId: id,
-    });
-
-    if (contract || blob || transaction) {
-      return false;
-    }
-    return true;
+    const type = await this.getAddressType(id);
+    return type === 'Account';
   }
 
-  async getAddressType(id: string): Promise<'Account' | 'Contract' | 'Transaction' | 'Blob'> {
+  /**
+   * Determines the type of address based on the provided ID.
+   *
+   * @param id - The ID to be checked.
+   * @returns A promise that resolves to a string indicating the type of address.
+   */
+  async getAddressType(id: string): Promise<GetAddressTypeResponse> {
     const { contract, blob, transaction } = await this.operations.isUserAccount({
       blobId: id,
       contractId: id,
@@ -2222,6 +2222,14 @@ export default class Provider {
       return 'Transaction';
     }
 
+    try {
+      // Unlike the previous queries this one will throw if the ID is not an assetId
+      const asset = await this.getAssetDetails(id);
+      if (asset) {
+        return 'Asset';
+      }
+    } catch (e) {}
+
     return 'Account';
   }
 

packages/fuel-gauge/src/check-user-account.test.ts

@@ -1,5 +1,6 @@
 import { launchTestNode } from 'fuels/test-utils';
 
+import { TokenContractFactory } from '../test/typegen';
 import { AdvancedLoggingFactory } from '../test/typegen/contracts/AdvancedLoggingFactory';
 import { ScriptMainArgBool } from '../test/typegen/scripts';
 
@@ -66,14 +67,60 @@ describe('User account tests', () => {
     expect(await provider.isUserAccount(tx.id)).toBe(false);
   });
 
+  it('should return false for a Asset ID', async () => {
+    using launch = await launchTestNode({
+      contractsConfigs: [{ factory: TokenContractFactory }],
+    });
+
+    const {
+      provider,
+      contracts: [tokenContract],
+    } = launch;
+
+    const call = await tokenContract.functions.mint_coins(1).call();
+    const {
+      transactionResult: { mintedAssets },
+    } = await call.waitForResult();
+
+    const [{ assetId }] = mintedAssets;
+
+    expect(await provider.isUserAccount(assetId)).toBe(false);
+  });
+
   it('should return the correct address type', async () => {
-    using launch = await launchTestNode();
+    using launch = await launchTestNode({
+      contractsConfigs: [{ factory: TokenContractFactory }],
+    });
 
     const {
       provider,
       wallets: [wallet],
+      contracts: [tokenContract],
     } = launch;
 
-    expect(await provider.getAddressType(wallet.address.toB256())).toBe('Account');
+    const script = new ScriptMainArgBool(wallet);
+    const { blobId, waitForResult } = await script.deploy(wallet);
+    await waitForResult();
+
+    const call = await tokenContract.functions.mint_coins(1000000).call();
+    const {
+      transactionResult: { mintedAssets, id },
+    } = await call.waitForResult();
+    const [{ assetId }] = mintedAssets;
+
+    let type = await provider.getAddressType(assetId);
+    expect(type).toBe('Asset');
+
+    type = await provider.getAddressType(id);
+    expect(type).toBe('Transaction');
+
+    type = await provider.getAddressType(blobId);
+    expect(type).toBe('Blob');
+
+    type = await provider.getAddressType(tokenContract.id.toB256());
+    expect(type).toBe('Contract');
+
+    type = await provider.getAddressType(wallet.address.toB256());
+    expect(type).toBe('Account');
   });
 });