feat(express): add typed routes for TRX delegation APIs

Add dedicated Express routes for accountresources and
activedelegations endpoints with io-ts validation.

TICKET: CHALO-346

Author: bhavidhingra

modules/express/src/clientRoutes.ts

@@ -1012,6 +1012,40 @@ async function handleV2SendMany(req: ExpressApiRouteRequest<'express.v2.wallet.s
   return result;
 }
 
+/**
+ * handle get account resources
+ * @param req
+ */
+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 });
+  return wallet.getAccountResources({
+    addresses: req.decoded.addresses,
+    destinationAddress: req.decoded.destinationAddress,
+  });
+}
+
+/**
+ * handle get resource delegations
+ * @param req
+ */
+async function handleV2ResourceDelegations(
+  req: ExpressApiRouteRequest<'express.v2.wallet.resourcedelegations', 'get'>
+) {
+  const bitgo = req.bitgo;
+  const coin = req.decoded.coin;
+  const walletId = req.decoded.id;
+  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;
+  return bitgo
+    .get(bitgo.url(`/${coin}/wallet/${walletId}/resourcedelegations`, 2))
+    .query(query)
+    .result();
+}
+
 /**
  *  payload meant for prebuildAndSignTransaction() in sdk-core which
  * validates the payload and makes the appropriate request to WP to
@@ -1770,6 +1804,16 @@ export function setupAPIRoutes(app: express.Application, config: Config): void {
     typedPromiseWrapper(handleV2ConsolidateAccount),
   ]);
 
+  // TRX resource delegation
+  router.post('express.v2.wallet.getaccountresources', [
+    prepareBitGo(config),
+    typedPromiseWrapper(handleV2AccountResources),
+  ]);
+  router.get('express.v2.wallet.resourcedelegations', [
+    prepareBitGo(config),
+    typedPromiseWrapper(handleV2ResourceDelegations),
+  ]);
+
   // Miscellaneous
   router.post('express.canonicaladdress', [prepareBitGo(config), typedPromiseWrapper(handleCanonicalAddress)]);
   router.post('express.verifycoinaddress', [prepareBitGo(config), typedPromiseWrapper(handleV2VerifyAddress)]);

modules/express/src/typedRoutes/api/index.ts

@@ -51,6 +51,8 @@ import { PostWalletEnableTokens } from './v2/walletEnableTokens';
 import { PostWalletSweep } from './v2/walletSweep';
 import { PostWalletAccelerateTx } from './v2/walletAccelerateTx';
 import { PostIsWalletAddress } from './v2/isWalletAddress';
+import { GetAccountResources } from './v2/accountResources';
+import { GetResourceDelegations } from './v2/resourceDelegations';
 
 // Too large types can cause the following error
 //
@@ -322,6 +324,18 @@ export const ExpressV2WalletAccelerateTxApiSpec = apiSpec({
   },
 });
 
+export const ExpressV2WalletAccountResourcesApiSpec = apiSpec({
+  'express.v2.wallet.getaccountresources': {
+    post: GetAccountResources,
+  },
+});
+
+export const ExpressV2WalletResourceDelegationsApiSpec = apiSpec({
+  'express.v2.wallet.resourcedelegations': {
+    get: GetResourceDelegations,
+  },
+});
+
 export type ExpressApi = typeof ExpressPingApiSpec &
   typeof ExpressPingExpressApiSpec &
   typeof ExpressLoginApiSpec &
@@ -360,6 +374,8 @@ export type ExpressApi = typeof ExpressPingApiSpec &
   typeof ExpressV2CanonicalAddressApiSpec &
   typeof ExpressV2WalletSweepApiSpec &
   typeof ExpressV2WalletAccelerateTxApiSpec &
+  typeof ExpressV2WalletAccountResourcesApiSpec &
+  typeof ExpressV2WalletResourceDelegationsApiSpec &
   typeof ExpressWalletManagementApiSpec;
 
 export const ExpressApi: ExpressApi = {
@@ -401,6 +417,8 @@ export const ExpressApi: ExpressApi = {
   ...ExpressV2CanonicalAddressApiSpec,
   ...ExpressV2WalletSweepApiSpec,
   ...ExpressV2WalletAccelerateTxApiSpec,
+  ...ExpressV2WalletAccountResourcesApiSpec,
+  ...ExpressV2WalletResourceDelegationsApiSpec,
   ...ExpressWalletManagementApiSpec,
 };
 

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

@@ -0,0 +1,95 @@
+import * as t from 'io-ts';
+import { httpRoute, httpRequest, optional } from '@api-ts/io-ts-http';
+import { BitgoExpressError } from '../../schemas/error';
+
+/**
+ * Path parameters for account resources endpoint
+ */
+export const AccountResourcesParams = {
+  /** Coin identifier (e.g., 'trx', 'ttrx') */
+  coin: t.string,
+  /** Wallet ID */
+  id: t.string,
+} as const;
+
+/**
+ * Body parameters for account resources endpoint
+ */
+export const AccountResourcesBody = {
+  /** On-chain addresses to query resources for */
+  addresses: t.array(t.string),
+  /** Optional destination address to calculate energy deficit for token transfers */
+  destinationAddress: optional(t.string),
+} as const;
+
+/**
+ * Account resource information for a single address
+ */
+export const AccountResourceInfo = t.intersection([
+  t.type({
+    address: t.string,
+    free_bandwidth_available: t.number,
+    free_bandwidth_used: t.number,
+    staked_bandwidth_available: t.number,
+    staked_bandwidth_used: t.number,
+    energy_available: t.number,
+    energy_used: t.number,
+    resourceDeficitForAssetTransfer: t.intersection([
+      t.type({
+        bandwidthDeficit: t.number,
+        bandwidthSunRequired: t.string,
+      }),
+      t.partial({
+        energyDeficit: t.number,
+        energySunRequired: t.string,
+      }),
+    ]),
+  }),
+  t.partial({
+    maxResourcesDelegatable: t.type({
+      bandwidthSun: t.string,
+      energySun: t.string,
+    }),
+  }),
+]);
+
+/**
+ * Failed address information
+ */
+export const FailedAddressInfo = t.type({
+  address: t.string,
+  error: t.string,
+});
+
+/**
+ * Response for account resources
+ */
+export const AccountResourcesResponse = {
+  /** Account resources for the queried addresses */
+  200: t.type({
+    resources: t.array(AccountResourceInfo),
+    failedAddresses: t.array(FailedAddressInfo),
+  }),
+  /** Invalid request */
+  400: BitgoExpressError,
+} as const;
+
+/**
+ * Get Account Resources
+ *
+ * Query BANDWIDTH and ENERGY resource information for TRX wallet addresses.
+ * Returns resource availability, usage, and optional deficit calculations
+ * for token transfers.
+ *
+ * @operationId express.v2.wallet.getaccountresources
+ * @tag express
+ */
+export const GetAccountResources = httpRoute({
+  path: '/api/v2/{coin}/wallet/{id}/getaccountresources',
+  method: 'POST',
+  request: httpRequest({
+    params: AccountResourcesParams,
+    body: AccountResourcesBody,
+  }),
+  response: AccountResourcesResponse,
+});

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

@@ -0,0 +1,82 @@
+import * as t from 'io-ts';
+import { NumberFromString } from 'io-ts-types';
+import { httpRoute, httpRequest, optional } from '@api-ts/io-ts-http';
+import { BitgoExpressError } from '../../schemas/error';
+
+/**
+ * Path parameters for resource delegations endpoint
+ */
+export const ResourceDelegationsParams = {
+  /** Coin identifier (e.g., 'trx', 'ttrx') */
+  coin: t.string,
+  /** Wallet ID */
+  id: t.string,
+} as const;
+
+/**
+ * Query parameters for resource delegations endpoint
+ */
+export const ResourceDelegationsQuery = {
+  /** Filter by delegation direction: 'outgoing' for delegations from this address, 'incoming' for delegations to this address; omit to fetch both */
+  type: optional(t.union([t.literal('outgoing'), t.literal('incoming')])),
+  /** Filter by resource type (case-insensitive: ENERGY, energy, BANDWIDTH, bandwidth) */
+  resource: optional(t.string),
+  /** Maximum number of results to return */
+  limit: optional(NumberFromString),
+  /** Pagination cursor from previous response */
+  nextBatchPrevId: optional(t.string),
+} as const;
+
+/**
+ * A single delegation record
+ */
+export const DelegationRecord = t.type({
+  id: t.string,
+  coin: t.string,
+  ownerAddress: t.string,
+  receiverAddress: t.string,
+  resource: t.union([t.literal('ENERGY'), t.literal('BANDWIDTH')]),
+  balance: t.string,
+  updatedAt: t.string,
+});
+
+/**
+ * Response for resource delegations
+ */
+export const ResourceDelegationsResponse = {
+  /** Resource delegations for the wallet */
+  200: t.type({
+    address: t.string,
+    coin: t.string,
+    delegations: t.intersection([
+      t.type({
+        outgoing: t.array(DelegationRecord),
+        incoming: t.array(DelegationRecord),
+      }),
+      t.partial({
+        nextBatchPrevId: t.string,
+      }),
+    ]),
+  }),
+  /** Invalid request */
+  400: BitgoExpressError,
+} as const;
+
+/**
+ * Get Resource Delegations
+ *
+ * Query active outgoing and incoming ENERGY/BANDWIDTH resource delegations
+ * for a TRX wallet.
+ *
+ * @operationId express.v2.wallet.resourcedelegations
+ * @tag express
+ */
+export const GetResourceDelegations = httpRoute({
+  path: '/api/v2/{coin}/wallet/{id}/resourcedelegations',
+  method: 'GET',
+  request: httpRequest({
+    params: ResourceDelegationsParams,
+    query: ResourceDelegationsQuery,
+  }),
+  response: ResourceDelegationsResponse,
+});

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

@@ -1483,12 +1483,12 @@ export class Wallet implements IWallet {
       throw new Error('addresses array cannot be empty');
     }
 
-    const query: GetAccountResourcesOptions = { addresses };
+    const body: GetAccountResourcesOptions = { addresses };
     if (destinationAddress) {
-      query.destinationAddress = destinationAddress;
+      body.destinationAddress = destinationAddress;
     }
 
-    return this.bitgo.get(this.url('/getAccountResources')).query(query).result();
+    return this.bitgo.post(this.url('/getAccountResources')).send(body).result();
   }
 
   async updateWalletBuildDefaults(params: UpdateBuildDefaultOptions): Promise<unknown> {

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

@@ -11,7 +11,7 @@ describe('Wallet - getAccountResources', function () {
 
   beforeEach(function () {
     mockBitGo = {
-      get: sinon.stub(),
+      post: sinon.stub(),
     };
 
     mockBaseCoin = {
@@ -40,8 +40,8 @@ describe('Wallet - getAccountResources', function () {
         ],
       };
 
-      mockBitGo.get.returns({
-        query: sinon.stub().returns({
+      mockBitGo.post.returns({
+        send: sinon.stub().returns({
           result: sinon.stub().resolves(mockResponse),
         }),
       });
@@ -50,18 +50,18 @@ describe('Wallet - getAccountResources', function () {
       const result = await wallet.getAccountResources({ addresses });
 
       result.should.deepEqual(mockResponse);
-      sinon.assert.calledOnce(mockBitGo.get);
-      const queryStub = mockBitGo.get.returnValues[0].query;
-      sinon.assert.calledWith(queryStub, { addresses });
+      sinon.assert.calledOnce(mockBitGo.post);
+      const sendStub = mockBitGo.post.returnValues[0].send;
+      sinon.assert.calledWith(sendStub, { addresses });
     });
 
     it('should call WP API with addresses and destinationAddress parameters', async function () {
       const mockResponse = {
         resources: [{ address: 'address1', balance: 100 }],
       };
 
-      mockBitGo.get.returns({
-        query: sinon.stub().returns({
+      mockBitGo.post.returns({
+        send: sinon.stub().returns({
           result: sinon.stub().resolves(mockResponse),
         }),
       });
@@ -71,9 +71,9 @@ describe('Wallet - getAccountResources', function () {
       const result = await wallet.getAccountResources({ addresses, destinationAddress });
 
       result.should.deepEqual(mockResponse);
-      sinon.assert.calledOnce(mockBitGo.get);
-      const queryStub = mockBitGo.get.returnValues[0].query;
-      sinon.assert.calledWith(queryStub, { addresses, destinationAddress });
+      sinon.assert.calledOnce(mockBitGo.post);
+      const sendStub = mockBitGo.post.returnValues[0].send;
+      sinon.assert.calledWith(sendStub, { addresses, destinationAddress });
     });
 
     it('should throw error if addresses is not an array', async function () {
@@ -94,22 +94,22 @@ describe('Wallet - getAccountResources', function () {
       }
     });
 
-    it('should not include destinationAddress in query if not provided', async function () {
+    it('should not include destinationAddress in body if not provided', async function () {
       const mockResponse = { resources: [] };
 
-      mockBitGo.get.returns({
-        query: sinon.stub().returns({
+      mockBitGo.post.returns({
+        send: 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('destinationAddress');
+      const sendStub = mockBitGo.post.returnValues[0].send;
+      const bodyArg = sendStub.firstCall.args[0];
+      bodyArg.should.deepEqual({ addresses });
+      bodyArg.should.not.have.property('destinationAddress');
     });
   });
 });