fix(sdk): stop reporting live Tron EOAs as inactive owners (hyperlane-xyz#9312)

Co-authored-by: Claude Opus 5 <noreply@anthropic.com>

Author: xeno097

.changeset/tron-eoa-owner-status.md

@@ -0,0 +1,6 @@
+---
+'@hyperlane-xyz/tron-sdk': minor
+'@hyperlane-xyz/sdk': patch
+---
+
+Tron externally-owned accounts are no longer reported as inactive owners. `TronJsonRpcProvider` gained `isAccountActive`, which reads on-chain activation from the native `wallet/getaccount` endpoint instead of leaving liveness to be inferred from `getTransactionCount` (Tron has no nonces, so that method is hardcoded to 0 and made every Tron EOA look dead). `isAddressActive` now consults that method when the provider offers it and otherwise keeps its existing code-or-nonce behaviour, so `warp check` stops emitting a permanent `ownerStatus` violation for live Tron EOA owners. A failure reaching the Tron node is thrown rather than reported as inactive.

typescript/sdk/src/contracts/contracts.test.ts

@@ -0,0 +1,128 @@
+import { expect } from 'chai';
+
+import { Address } from '@hyperlane-xyz/utils';
+
+import type { EthersLikeProvider } from '../deploy/proxy.js';
+
+import { isAddressActive } from './contracts.js';
+
+const ADDRESS: Address = '0xa7eccdb9be08178f896c26b7bbd8c3d4e844d9ba';
+const CONTRACT_CODE = '0x60806040';
+
+interface NonceProviderCalls {
+  getTransactionCount: number;
+}
+
+interface ActivationProviderCalls {
+  isAccountActive: number;
+}
+
+/** Provider double for chains whose liveness is inferred from the nonce. */
+function nonceProvider(
+  code: string,
+  txnCount: number,
+): { provider: EthersLikeProvider; calls: NonceProviderCalls } {
+  const calls: NonceProviderCalls = { getTransactionCount: 0 };
+  const double = {
+    getCode: async () => code,
+    getTransactionCount: async () => {
+      calls.getTransactionCount += 1;
+      return txnCount;
+    },
+  };
+  // CAST: explicit test double exercising only the two methods isAddressActive calls.
+  return { provider: double as unknown as EthersLikeProvider, calls };
+}
+
+/** Provider double for chains that answer activation directly (Tron). */
+function activationProvider(
+  code: string,
+  activation: boolean | (() => Promise<boolean>),
+): { provider: EthersLikeProvider; calls: ActivationProviderCalls } {
+  const calls: ActivationProviderCalls = { isAccountActive: 0 };
+  const double = {
+    getCode: async () => code,
+    getTransactionCount: async () => {
+      throw new Error('getTransactionCount must not be consulted');
+    },
+    isAccountActive: async () => {
+      calls.isAccountActive += 1;
+      return typeof activation === 'boolean' ? activation : activation();
+    },
+  };
+  // CAST: explicit test double exercising only the methods isAddressActive calls.
+  return { provider: double as unknown as EthersLikeProvider, calls };
+}
+
+describe('isAddressActive', () => {
+  describe('providers without an activation check', () => {
+    it('returns false for an EOA with no code and a zero nonce', async () => {
+      const { provider } = nonceProvider('0x', 0);
+
+      expect(await isAddressActive(provider, ADDRESS)).to.be.false;
+    });
+
+    it('returns true for an EOA with a non-zero nonce', async () => {
+      const { provider } = nonceProvider('0x', 1);
+
+      expect(await isAddressActive(provider, ADDRESS)).to.be.true;
+    });
+
+    it('returns true for a contract regardless of nonce', async () => {
+      const { provider } = nonceProvider(CONTRACT_CODE, 0);
+
+      expect(await isAddressActive(provider, ADDRESS)).to.be.true;
+    });
+  });
+
+  describe('providers with an activation check', () => {
+    it('returns true for an activated EOA with no code and no nonce', async () => {
+      const { provider, calls } = activationProvider('0x', true);
+
+      expect(await isAddressActive(provider, ADDRESS)).to.be.true;
+      expect(calls.isAccountActive).to.equal(1);
+    });
+
+    it('returns false for an unactivated EOA', async () => {
+      const { provider, calls } = activationProvider('0x', false);
+
+      expect(await isAddressActive(provider, ADDRESS)).to.be.false;
+      expect(calls.isAccountActive).to.equal(1);
+    });
+
+    it('returns true for a contract without consulting the activation check', async () => {
+      const { provider, calls } = activationProvider(CONTRACT_CODE, false);
+
+      expect(await isAddressActive(provider, ADDRESS)).to.be.true;
+      expect(calls.isAccountActive).to.equal(0);
+    });
+
+    it('returns true for a contract even when the activation check would fail', async () => {
+      const { provider, calls } = activationProvider(
+        CONTRACT_CODE,
+        async () => {
+          throw new Error('the method wallet/getaccount is not available');
+        },
+      );
+
+      expect(await isAddressActive(provider, ADDRESS)).to.be.true;
+      expect(calls.isAccountActive).to.equal(0);
+    });
+
+    it('propagates an activation-check failure instead of reporting inactive', async () => {
+      const failure = new Error('bad response (status=503)');
+      const { provider } = activationProvider('0x', async () => {
+        throw failure;
+      });
+
+      let thrown: unknown;
+      try {
+        await isAddressActive(provider, ADDRESS);
+      } catch (error: unknown) {
+        thrown = error;
+      }
+
+      expect(thrown).to.equal(failure);
+    });
+  });
+});

typescript/sdk/src/contracts/contracts.ts

@@ -1,6 +1,7 @@
 import { constants } from 'ethers';
 
 import { Ownable, Ownable__factory } from '@hyperlane-xyz/core';
+import type { TronJsonRpcProvider } from '@hyperlane-xyz/tron-sdk/runtime';
 import {
   Address,
   EvmChainId,
@@ -346,10 +347,43 @@ export function transferOwnershipTransactions(
   ];
 }
 
+/**
+ * Providers for chains whose account model has no nonce (Tron) answer liveness
+ * directly instead of leaving it to be inferred from `getTransactionCount`.
+ *
+ * The shape is derived from the Tron provider rather than declared
+ * independently so that renaming or removing `isAccountActive` in
+ * @hyperlane-xyz/tron-sdk breaks this build, instead of silently reverting the
+ * structural check below to the always-zero nonce path.
+ */
+type AccountActivationProvider = Pick<TronJsonRpcProvider, 'isAccountActive'>;
+
+function canCheckActivation(
+  provider: EthersLikeProvider,
+): provider is EthersLikeProvider & AccountActivationProvider {
+  return (
+    'isAccountActive' in provider &&
+    typeof provider.isAccountActive === 'function'
+  );
+}
+
 export async function isAddressActive(
   provider: EthersLikeProvider,
   address: Address,
 ): Promise<boolean> {
+  if (canCheckActivation(provider)) {
+    // Deliberately sequential: non-empty code is by itself conclusive, so a
+    // contract must not be put at the mercy of an activation endpoint it never
+    // needed. Issuing both in parallel would propagate an activation failure
+    // for an address we had already proven active.
+    const code = await provider.getCode(address);
+    if (code !== '0x') {
+      return true;
+    }
+
+    return provider.isAccountActive(address);
+  }
+
   const [code, txnCount] = await Promise.all([
     provider.getCode(address),
     provider.getTransactionCount(address),

typescript/tron-sdk/src/ethers/TronJsonRpcProvider.integration.test.ts

@@ -0,0 +1,62 @@
+import { expect } from 'chai';
+import { TronWeb } from 'tronweb';
+
+import { assert, ensure0x, strip0x } from '@hyperlane-xyz/utils';
+
+import {
+  TronNodeInfo,
+  TronTestChainMetadata,
+  runTronNode,
+  stopTronNode,
+} from '../testing/node.js';
+
+import { TronJsonRpcProvider } from './TronJsonRpcProvider.js';
+
+const TEST_CHAIN: TronTestChainMetadata = {
+  name: 'tron-test-account',
+  chainId: 3360022319,
+  domainId: 3360022319,
+  port: 19091,
+};
+
+// Never funded by TRE, so the node has no account record for it.
+const UNACTIVATED_ADDRESS = '0xa7eccdb9be08178f896c26b7bbd8c3d4e844d9ba';
+
+describe('TronJsonRpcProvider Integration Tests', function () {
+  this.timeout(120_000);
+
+  let node: TronNodeInfo;
+  let provider: TronJsonRpcProvider;
+  let fundedAddress: string;
+
+  before(async () => {
+    node = await runTronNode(TEST_CHAIN);
+
+    const host = `http://127.0.0.1:${TEST_CHAIN.port}`;
+    provider = new TronJsonRpcProvider(`${host}/jsonrpc`, TEST_CHAIN.chainId);
+
+    const tronWeb = new TronWeb({ fullHost: host });
+    const base58 = tronWeb.address.fromPrivateKey(node.privateKeys[0]);
+    assert(base58, 'TRE did not expose a funded account');
+    // TronWeb hex is 41-prefixed; the provider is fed the 0x form production uses.
+    fundedAddress = ensure0x(strip0x(tronWeb.address.toHex(base58)).slice(2));
+  });
+
+  after(async () => {
+    await stopTronNode(node);
+  });
+
+  describe('isAccountActive', () => {
+    it('returns true for an activated (funded) account', async () => {
+      expect(await provider.isAccountActive(fundedAddress)).to.be.true;
+    });
+
+    it('returns false for an address that was never activated', async () => {
+      expect(await provider.isAccountActive(UNACTIVATED_ADDRESS)).to.be.false;
+    });
+
+    it('still reports a zero nonce for the activated account', async () => {
+      expect(await provider.getTransactionCount(fundedAddress)).to.equal(0);
+    });
+  });
+});