Add getAccountResources method to wallet class with tests

Co-authored-by: bhavidhingra <17147510+bhavidhingra@users.noreply.github.com>

Author: Copilot

modules/sdk-core/src/bitgo/wallet/iWallet.ts

@@ -539,6 +539,11 @@ export interface ForwarderBalanceOptions {
   maximumBalance?: number;
 }
 
+export interface GetAccountResourcesOptions {
+  addresses: string[];
+  tokenName?: string;
+}
+
 export type CreateAddressFormat = 'base58' | 'cashaddr';
 
 export interface CreateAddressOptions {
@@ -988,6 +993,7 @@ export interface IWallet {
   getAddress(params?: GetAddressOptions): Promise<any>;
   createAddress(params?: CreateAddressOptions): Promise<any>;
   updateAddress(params?: UpdateAddressOptions): Promise<any>;
+  getAccountResources(addresses: string[], tokenName?: string): Promise<any>;
   listWebhooks(params?: PaginationOptions): Promise<any>;
   simulateWebhook(params?: SimulateWebhookOptions): Promise<any>;
   addWebhook(params?: ModifyWebhookOptions): Promise<any>;

modules/sdk-core/src/bitgo/wallet/wallet.ts

@@ -1465,6 +1465,29 @@ export class Wallet implements IWallet {
     return this.bitgo.put(url).send(putParams).result();
   }
 
+  /**
+   * Get account resources for the given addresses
+   * @param addresses - array of address strings
+   * @param tokenName - optional token name
+   * @returns {Promise<any>} - response from WP API
+   */
+  async getAccountResources(addresses: string[], tokenName?: string): Promise<any> {
+    if (!Array.isArray(addresses)) {
+      throw new Error('addresses must be an array');
+    }
+
+    if (addresses.length === 0) {
+      throw new Error('addresses array cannot be empty');
+    }
+
+    const query: any = { addresses };
+    if (tokenName) {
+      query.tokenName = tokenName;
+    }
+
+    return this.bitgo.get(this.url('/accountResources')).query(query).result();
+  }
+
   async updateWalletBuildDefaults(params: UpdateBuildDefaultOptions): Promise<unknown> {
     common.validateParams(params, [], ['minFeeRate', 'changeAddressType', 'txFormat']);
     return this.updateWallet({

modules/sdk-core/test/unit/bitgo/wallet/getAccountResources.ts

@@ -0,0 +1,116 @@
+import * as assert from 'assert';
+import * as sinon from 'sinon';
+import 'should';
+import { Wallet } from '../../../../src/bitgo/wallet/wallet';
+
+describe('Wallet - getAccountResources', function () {
+  let wallet: Wallet;
+  let mockBitGo: any;
+  let mockBaseCoin: any;
+  let mockWalletData: any;
+
+  beforeEach(function () {
+    mockBitGo = {
+      get: sinon.stub(),
+    };
+
+    mockBaseCoin = {
+      url: sinon.stub().returns('/test/coin'),
+    };
+
+    mockWalletData = {
+      id: 'test-wallet-id',
+      keys: ['user-key', 'backup-key', 'bitgo-key'],
+    };
+
+    wallet = new Wallet(mockBitGo, mockBaseCoin, mockWalletData);
+  });
+
+  afterEach(function () {
+    sinon.restore();
+  });
+
+  describe('getAccountResources', function () {
+    it('should call WP API with addresses parameter', async function () {
+      const mockResponse = {
+        resources: [
+          { address: 'address1', balance: 100 },
+          { address: 'address2', balance: 200 },
+        ],
+      };
+
+      mockBitGo.get.returns({
+        query: sinon.stub().returns({
+          result: sinon.stub().resolves(mockResponse),
+        }),
+      });
+
+      const addresses = ['address1', 'address2'];
+      const result = await wallet.getAccountResources(addresses);
+
+      result.should.deepEqual(mockResponse);
+      mockBitGo.get.should.have.been.calledOnce;
+      const queryStub = mockBitGo.get.returnValues[0].query;
+      queryStub.should.have.been.calledWith({ addresses });
+    });
+
+    it('should call WP API with addresses and tokenName parameters', async function () {
+      const mockResponse = {
+        resources: [
+          { address: 'address1', balance: 100, token: 'USDT' },
+        ],
+      };
+
+      mockBitGo.get.returns({
+        query: sinon.stub().returns({
+          result: sinon.stub().resolves(mockResponse),
+        }),
+      });
+
+      const addresses = ['address1'];
+      const tokenName = 'USDT';
+      const result = await wallet.getAccountResources(addresses, tokenName);
+
+      result.should.deepEqual(mockResponse);
+      mockBitGo.get.should.have.been.calledOnce;
+      const queryStub = mockBitGo.get.returnValues[0].query;
+      queryStub.should.have.been.calledWith({ addresses, tokenName });
+    });
+
+    it('should throw error if addresses is not an array', async function () {
+      try {
+        await wallet.getAccountResources('not-an-array' as any);
+        assert.fail('Should have thrown error');
+      } catch (error) {
+        error.message.should.equal('addresses must be an array');
+      }
+    });
+
+    it('should throw error if addresses array is empty', async function () {
+      try {
+        await wallet.getAccountResources([]);
+        assert.fail('Should have thrown error');
+      } catch (error) {
+        error.message.should.equal('addresses array cannot be empty');
+      }
+    });
+
+    it('should not include tokenName in query if not provided', async function () {
+      const mockResponse = { resources: [] };
+
+      mockBitGo.get.returns({
+        query: sinon.stub().returns({
+          result: sinon.stub().resolves(mockResponse),
+        }),
+      });
+
+      const addresses = ['address1'];
+      await wallet.getAccountResources(addresses);
+
+      const queryStub = mockBitGo.get.returnValues[0].query;
+      const queryArg = queryStub.firstCall.args[0];
+      queryArg.should.deepEqual({ addresses });
+      queryArg.should.not.have.property('tokenName');
+    });
+  });
+});