fix(express): convert limit to string and forward nextBatchPrevId in resource delegations handler

Agent-Logs-Url: https://github.com/BitGo/BitGoJS/sessions/c1f514f3-1017-413f-90a9-4de5a30f1f0e

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

TICKET: CHALO-346

Author: Copilot

modules/express/src/clientRoutes.ts

@@ -1016,7 +1016,9 @@ async function handleV2SendMany(req: ExpressApiRouteRequest<'express.v2.wallet.s
  * handle get account resources
  * @param req
  */
-async function handleV2AccountResources(req: ExpressApiRouteRequest<'express.v2.wallet.getaccountresources', 'post'>) {
+export async function handleV2AccountResources(
+  req: ExpressApiRouteRequest<'express.v2.wallet.getaccountresources', 'post'>
+) {
   const bitgo = req.bitgo;
   const coin = bitgo.coin(req.decoded.coin);
   const wallet = await coin.wallets().get({ id: req.decoded.id });
@@ -1030,7 +1032,7 @@ async function handleV2AccountResources(req: ExpressApiRouteRequest<'express.v2.
  * handle get resource delegations
  * @param req
  */
-async function handleV2ResourceDelegations(
+export async function handleV2ResourceDelegations(
   req: ExpressApiRouteRequest<'express.v2.wallet.resourcedelegations', 'get'>
 ) {
   const bitgo = req.bitgo;
@@ -1039,7 +1041,8 @@ async function handleV2ResourceDelegations(
   const query: Record<string, string> = {};
   if (req.decoded.type) query.type = req.decoded.type;
   if (req.decoded.resource) query.resource = req.decoded.resource;
-  if (req.decoded.limit) query.limit = req.decoded.limit;
+  if (req.decoded.limit !== undefined) query.limit = String(req.decoded.limit);
+  if (req.decoded.nextBatchPrevId) query.nextBatchPrevId = req.decoded.nextBatchPrevId;
   return bitgo
     .get(bitgo.url(`/${coin}/wallet/${walletId}/resourcedelegations`, 2))
     .query(query)

modules/express/src/typedRoutes/api/v2/accountResources.ts

@@ -34,6 +34,8 @@ export const AccountResourceInfo = t.intersection([
     staked_bandwidth_used: t.number,
     energy_available: t.number,
     energy_used: t.number,
+  }),
+  t.partial({
     resourceDeficitForAssetTransfer: t.intersection([
       t.type({
         bandwidthDeficit: t.number,
@@ -44,8 +46,6 @@ export const AccountResourceInfo = t.intersection([
         energySunRequired: t.string,
       }),
     ]),
-  }),
-  t.partial({
     maxResourcesDelegatable: t.type({
       bandwidthSun: t.string,
       energySun: t.string,

modules/express/test/unit/clientRoutes/trxResourceDelegation.ts

@@ -0,0 +1,180 @@
+import * as sinon from 'sinon';
+import { decodeOrElse } from '@bitgo/sdk-core';
+
+import 'should';
+import 'should-sinon';
+import '../../lib/asserts';
+
+import * as express from 'express';
+
+import { handleV2AccountResources, handleV2ResourceDelegations } from '../../../src/clientRoutes';
+import { AccountResourcesResponse } from '../../../src/typedRoutes/api/v2/accountResources';
+import { ResourceDelegationsResponse } from '../../../src/typedRoutes/api/v2/resourceDelegations';
+
+import { BitGo } from 'bitgo';
+
+describe('TRX Resource Delegation handlers', () => {
+  const sandbox = sinon.createSandbox();
+
+  afterEach(() => {
+    sandbox.verifyAndRestore();
+  });
+
+  describe('handleV2AccountResources', () => {
+    const mockResources = {
+      resources: [
+        {
+          address: 'TAddr123',
+          free_bandwidth_available: 1500,
+          free_bandwidth_used: 0,
+          staked_bandwidth_available: 0,
+          staked_bandwidth_used: 0,
+          energy_available: 0,
+          energy_used: 0,
+        },
+      ],
+      failedAddresses: [],
+    };
+
+    function createMocks(result: unknown) {
+      const getAccountResourcesStub = sandbox.stub().resolves(result);
+      const walletStub = { getAccountResources: getAccountResourcesStub };
+      const coinStub = {
+        wallets: () => ({ get: () => Promise.resolve(walletStub) }),
+      };
+      const bitgoStub = sinon.createStubInstance(BitGo as any, { coin: coinStub });
+      return { bitgoStub, getAccountResourcesStub };
+    }
+
+    it('should call getAccountResources with addresses and return codec-valid result', async () => {
+      const { bitgoStub, getAccountResourcesStub } = createMocks(mockResources);
+
+      const mockRequest = {
+        bitgo: bitgoStub,
+        decoded: {
+          coin: 'ttrx',
+          id: 'walletId123',
+          addresses: ['TAddr123'],
+        },
+      };
+
+      const result = await handleV2AccountResources(mockRequest as express.Request & typeof mockRequest);
+      decodeOrElse('AccountResourcesResponse', AccountResourcesResponse[200], result, (_) => {
+        throw new Error('Response did not match expected codec');
+      });
+      getAccountResourcesStub.should.be.calledOnceWith({
+        addresses: ['TAddr123'],
+        destinationAddress: undefined,
+      });
+    });
+
+    it('should forward destinationAddress when provided', async () => {
+      const { bitgoStub, getAccountResourcesStub } = createMocks(mockResources);
+
+      const mockRequest = {
+        bitgo: bitgoStub,
+        decoded: {
+          coin: 'ttrx',
+          id: 'walletId123',
+          addresses: ['TAddr123'],
+          destinationAddress: 'TDest456',
+        },
+      };
+
+      await handleV2AccountResources(mockRequest as express.Request & typeof mockRequest);
+      getAccountResourcesStub.should.be.calledOnceWith({
+        addresses: ['TAddr123'],
+        destinationAddress: 'TDest456',
+      });
+    });
+  });
+
+  describe('handleV2ResourceDelegations', () => {
+    const mockDelegations = {
+      address: 'TAddr123',
+      coin: 'ttrx',
+      delegations: {
+        outgoing: [],
+        incoming: [],
+      },
+    };
+
+    function createBitgoStub(result: unknown) {
+      const resultStub = sandbox.stub().resolves(result);
+      const queryStub = sandbox.stub().returns({ result: resultStub });
+      const getStub = sandbox.stub().returns({ query: queryStub });
+      const urlStub = sandbox
+        .stub()
+        .returns('https://test.bitgo.com/api/v2/ttrx/wallet/walletId123/resourcedelegations');
+      const bitgoStub = sinon.createStubInstance(BitGo as any, { get: getStub, url: urlStub });
+      return { bitgoStub, getStub, queryStub, resultStub };
+    }
+
+    it('should forward type and resource query params', async () => {
+      const { bitgoStub, queryStub } = createBitgoStub(mockDelegations);
+
+      const mockRequest = {
+        bitgo: bitgoStub,
+        decoded: {
+          coin: 'ttrx',
+          id: 'walletId123',
+          type: 'outgoing' as const,
+          resource: 'ENERGY',
+        },
+      };
+
+      await handleV2ResourceDelegations(mockRequest as express.Request & typeof mockRequest);
+      queryStub.should.be.calledOnceWith({ type: 'outgoing', resource: 'ENERGY' });
+    });
+
+    it('should convert limit to string when forwarding', async () => {
+      const { bitgoStub, queryStub } = createBitgoStub(mockDelegations);
+
+      const mockRequest = {
+        bitgo: bitgoStub,
+        decoded: {
+          coin: 'ttrx',
+          id: 'walletId123',
+          limit: 10,
+        },
+      };
+
+      await handleV2ResourceDelegations(mockRequest as express.Request & typeof mockRequest);
+      queryStub.should.be.calledOnceWith({ limit: '10' });
+    });
+
+    it('should forward nextBatchPrevId for pagination', async () => {
+      const { bitgoStub, queryStub } = createBitgoStub(mockDelegations);
+
+      const mockRequest = {
+        bitgo: bitgoStub,
+        decoded: {
+          coin: 'ttrx',
+          id: 'walletId123',
+          type: 'incoming' as const,
+          nextBatchPrevId: 'cursor-abc123',
+        },
+      };
+
+      await handleV2ResourceDelegations(mockRequest as express.Request & typeof mockRequest);
+      queryStub.should.be.calledOnceWith({ type: 'incoming', nextBatchPrevId: 'cursor-abc123' });
+    });
+
+    it('should return codec-valid delegations result', async () => {
+      const { bitgoStub } = createBitgoStub(mockDelegations);
+
+      const mockRequest = {
+        bitgo: bitgoStub,
+        decoded: {
+          coin: 'ttrx',
+          id: 'walletId123',
+        },
+      };
+
+      const result = await handleV2ResourceDelegations(mockRequest as express.Request & typeof mockRequest);
+      decodeOrElse('ResourceDelegationsResponse', ResourceDelegationsResponse[200], result, (_) => {
+        throw new Error('Response did not match expected codec');
+      });
+    });
+  });
+});