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

modules/express/src/clientRoutes.ts

@@ -1012,6 +1012,43 @@ async function handleV2SendMany(req: ExpressApiRouteRequest<'express.v2.wallet.s
   return result;
 }
 
+/**
+ * handle get account resources
+ * @param req
+ */
+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 });
+  return wallet.getAccountResources({
+    addresses: req.decoded.addresses,
+    destinationAddress: req.decoded.destinationAddress,
+  });
+}
+
+/**
+ * handle get resource delegations
+ * @param req
+ */
+export 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 !== 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)
+    .result();
+}
+
 /**
  *  payload meant for prebuildAndSignTransaction() in sdk-core which
  * validates the payload and makes the appropriate request to WP to
@@ -1770,6 +1807,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,
+  }),
+  t.partial({
+    resourceDeficitForAssetTransfer: t.intersection([
+      t.type({
+        bandwidthDeficit: t.number,
+        bandwidthSunRequired: t.string,
+      }),
+      t.partial({
+        energyDeficit: t.number,
+        energySunRequired: t.string,
+      }),
+    ]),
+    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,
+});