@mapprotocol/common-contracts 0.2.0 → 0.3.0

package/artifacts/contracts/factory/Create2Factory.sol/Create2Factory.json

@@ -0,0 +1,107 @@
+{
+  "_format": "hh-sol-artifact-1",
+  "contractName": "Create2Factory",
+  "sourceName": "contracts/factory/Create2Factory.sol",
+  "abi": [
+    {
+      "anonymous": false,
+      "inputs": [
+        {
+          "indexed": true,
+          "internalType": "address",
+          "name": "addr",
+          "type": "address"
+        },
+        {
+          "indexed": true,
+          "internalType": "bytes32",
+          "name": "salt",
+          "type": "bytes32"
+        }
+      ],
+      "name": "Deployed",
+      "type": "event"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes32",
+          "name": "salt",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes",
+          "name": "creationCode",
+          "type": "bytes"
+        },
+        {
+          "internalType": "uint256",
+          "name": "value",
+          "type": "uint256"
+        }
+      ],
+      "name": "deploy",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "addr",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "nonpayable",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes32",
+          "name": "salt",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "codeHash",
+          "type": "bytes32"
+        }
+      ],
+      "name": "getAddress",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    },
+    {
+      "inputs": [
+        {
+          "internalType": "bytes32",
+          "name": "salt",
+          "type": "bytes32"
+        },
+        {
+          "internalType": "bytes32",
+          "name": "codeHash",
+          "type": "bytes32"
+        }
+      ],
+      "name": "getAddressTron",
+      "outputs": [
+        {
+          "internalType": "address",
+          "name": "",
+          "type": "address"
+        }
+      ],
+      "stateMutability": "view",
+      "type": "function"
+    }
+  ],
+  "bytecode": "0x6080604052348015600f57600080fd5b506102f98061001f6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063933559b014610046578063c7aeef0f14610075578063d3a3968614610088575b600080fd5b61005961005436600461018e565b61009b565b6040516001600160a01b03909116815260200160405180910390f35b6100596100833660046101c6565b6100d8565b61005961009636600461018e565b61016c565b6040516000906100b990604160f81b9030908690869060200161028a565b60408051601f1981840301815291905280516020909101209392505050565b60008383516020850184f590506001600160a01b03811661012f5760405162461bcd60e51b815260206004820152600d60248201526c1111541313d657d19052531151609a1b604482015260640160405180910390fd5b60405184906001600160a01b038316907f94bfd9af14ef450884c8a7ddb5734e2e1e14e70a1c84f0801cc5a29e34d2642890600090a39392505050565b6040516000906100b9906001600160f81b03199030908690869060200161028a565b600080604083850312156101a157600080fd5b50508035926020909101359150565b634e487b7160e01b600052604160045260246000fd5b6000806000606084860312156101db57600080fd5b83359250602084013567ffffffffffffffff808211156101fa57600080fd5b818601915086601f83011261020e57600080fd5b813581811115610220576102206101b0565b604051601f8201601f19908116603f01168101908382118183101715610248576102486101b0565b8160405282815289602084870101111561026157600080fd5b826020860160208301376000602084830101528096505050505050604084013590509250925092565b6001600160f81b031994909416845260609290921b6bffffffffffffffffffffffff19166001840152601583015260358201526055019056fea26469706673582212205fb7d781d8404b93aed56d95e5543997fe78a250c5faf35b40c771504b4c853b64736f6c63430008190033",
+  "deployedBytecode": "0x608060405234801561001057600080fd5b50600436106100415760003560e01c8063933559b014610046578063c7aeef0f14610075578063d3a3968614610088575b600080fd5b61005961005436600461018e565b61009b565b6040516001600160a01b03909116815260200160405180910390f35b6100596100833660046101c6565b6100d8565b61005961009636600461018e565b61016c565b6040516000906100b990604160f81b9030908690869060200161028a565b60408051601f1981840301815291905280516020909101209392505050565b60008383516020850184f590506001600160a01b03811661012f5760405162461bcd60e51b815260206004820152600d60248201526c1111541313d657d19052531151609a1b604482015260640160405180910390fd5b60405184906001600160a01b038316907f94bfd9af14ef450884c8a7ddb5734e2e1e14e70a1c84f0801cc5a29e34d2642890600090a39392505050565b6040516000906100b9906001600160f81b03199030908690869060200161028a565b600080604083850312156101a157600080fd5b50508035926020909101359150565b634e487b7160e01b600052604160045260246000fd5b6000806000606084860312156101db57600080fd5b83359250602084013567ffffffffffffffff808211156101fa57600080fd5b818601915086601f83011261020e57600080fd5b813581811115610220576102206101b0565b604051601f8201601f19908116603f01168101908382118183101715610248576102486101b0565b8160405282815289602084870101111561026157600080fd5b826020860160208301376000602084830101528096505050505050604084013590509250925092565b6001600160f81b031994909416845260609290921b6bffffffffffffffffffffffff19166001840152601583015260358201526055019056fea26469706673582212205fb7d781d8404b93aed56d95e5543997fe78a250c5faf35b40c771504b4c853b64736f6c63430008190033",
+  "linkReferences": {},
+  "deployedLinkReferences": {}
+}

package/contracts/factory/Create2Factory.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+/**
+ * @title Create2Factory
+ * @notice Universal CREATE2 factory — works on both EVM and Tron.
+ * @dev Address prediction differs between EVM (0xff prefix) and Tron (0x41 prefix).
+ *      Use getAddress() on EVM chains, getAddressTron() on Tron.
+ *
+ * Usage:
+ *   // Deploy
+ *   bytes32 salt = keccak256("my_salt");
+ *   bytes memory code = abi.encodePacked(type(MyContract).creationCode, abi.encode(arg1));
+ *   address addr = factory.deploy(salt, code, 0);
+ *
+ *   // Predict address (off-chain or on-chain)
+ *   bytes32 codeHash = keccak256(code);
+ *   address predicted = factory.getAddress(salt, codeHash);       // EVM
+ *   address predicted = factory.getAddressTron(salt, codeHash);   // Tron
+ */
+contract Create2Factory {
+    event Deployed(address indexed addr, bytes32 indexed salt);
+
+    /// @notice Deploy contract via CREATE2
+    /// @param salt Deterministic salt
+    /// @param creationCode Contract bytecode + constructor args
+    /// @param value Native token value to send to the new contract
+    /// @return addr The deployed contract address
+    function deploy(bytes32 salt, bytes memory creationCode, uint256 value)
+        external returns (address addr)
+    {
+        assembly {
+            addr := create2(value, add(creationCode, 0x20), mload(creationCode), salt)
+        }
+        require(addr != address(0), "DEPLOY_FAILED");
+        emit Deployed(addr, salt);
+    }
+
+    /// @notice Predict CREATE2 address on EVM chains
+    /// @param salt The same salt used in deploy()
+    /// @param codeHash keccak256(creationCode) — includes constructor args
+    function getAddress(bytes32 salt, bytes32 codeHash) external view returns (address) {
+        return address(uint160(uint256(keccak256(
+            abi.encodePacked(bytes1(0xff), address(this), salt, codeHash)
+        ))));
+    }
+
+    /// @notice Predict CREATE2 address on Tron
+    /// @dev Tron uses 0x41 prefix instead of 0xff, and 21-byte sender (41 + 20-byte address)
+    /// @param salt The same salt used in deploy()
+    /// @param codeHash keccak256(creationCode) — includes constructor args
+    function getAddressTron(bytes32 salt, bytes32 codeHash) external view returns (address) {
+        return address(uint160(uint256(keccak256(
+            abi.encodePacked(bytes1(0x41), address(this), salt, codeHash)
+        ))));
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mapprotocol/common-contracts",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Common contracts for MAP Protocol",
   "main": "typechain-types/index.js",
   "types": "typechain-types/index.d.ts",

package/typechain-types/contracts/factory/Create2Factory.ts

@@ -0,0 +1,174 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumberish,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "../../common";
+
+export interface Create2FactoryInterface extends Interface {
+  getFunction(
+    nameOrSignature: "deploy" | "getAddress" | "getAddressTron"
+  ): FunctionFragment;
+
+  getEvent(nameOrSignatureOrTopic: "Deployed"): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "deploy",
+    values: [BytesLike, BytesLike, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getAddress",
+    values: [BytesLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "getAddressTron",
+    values: [BytesLike, BytesLike]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "deploy", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "getAddress", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "getAddressTron",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace DeployedEvent {
+  export type InputTuple = [addr: AddressLike, salt: BytesLike];
+  export type OutputTuple = [addr: string, salt: string];
+  export interface OutputObject {
+    addr: string;
+    salt: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface Create2Factory extends BaseContract {
+  connect(runner?: ContractRunner | null): Create2Factory;
+  waitForDeployment(): Promise<this>;
+
+  interface: Create2FactoryInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  deploy: TypedContractMethod<
+    [salt: BytesLike, creationCode: BytesLike, value: BigNumberish],
+    [string],
+    "nonpayable"
+  >;
+
+  getAddress: TypedContractMethod<
+    [salt: BytesLike, codeHash: BytesLike],
+    [string],
+    "view"
+  >;
+
+  getAddressTron: TypedContractMethod<
+    [salt: BytesLike, codeHash: BytesLike],
+    [string],
+    "view"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "deploy"
+  ): TypedContractMethod<
+    [salt: BytesLike, creationCode: BytesLike, value: BigNumberish],
+    [string],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "getAddress"
+  ): TypedContractMethod<
+    [salt: BytesLike, codeHash: BytesLike],
+    [string],
+    "view"
+  >;
+  getFunction(
+    nameOrSignature: "getAddressTron"
+  ): TypedContractMethod<
+    [salt: BytesLike, codeHash: BytesLike],
+    [string],
+    "view"
+  >;
+
+  getEvent(
+    key: "Deployed"
+  ): TypedContractEvent<
+    DeployedEvent.InputTuple,
+    DeployedEvent.OutputTuple,
+    DeployedEvent.OutputObject
+  >;
+
+  filters: {
+    "Deployed(address,bytes32)": TypedContractEvent<
+      DeployedEvent.InputTuple,
+      DeployedEvent.OutputTuple,
+      DeployedEvent.OutputObject
+    >;
+    Deployed: TypedContractEvent<
+      DeployedEvent.InputTuple,
+      DeployedEvent.OutputTuple,
+      DeployedEvent.OutputObject
+    >;
+  };
+}

package/typechain-types/contracts/factory/index.ts

@@ -0,0 +1,4 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export type { Create2Factory } from "./Create2Factory";

package/typechain-types/contracts/index.ts

@@ -3,4 +3,6 @@
 /* eslint-disable */
 import type * as base from "./base";
 export type { base };
+import type * as factory from "./factory";
+export type { factory };
 export type { AuthorityManager } from "./AuthorityManager";

package/typechain-types/factories/contracts/factory/Create2Factory__factory.ts

@@ -0,0 +1,163 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import {
+  Contract,
+  ContractFactory,
+  ContractTransactionResponse,
+  Interface,
+} from "ethers";
+import type { Signer, ContractDeployTransaction, ContractRunner } from "ethers";
+import type { NonPayableOverrides } from "../../../common";
+import type {
+  Create2Factory,
+  Create2FactoryInterface,
+} from "../../../contracts/factory/Create2Factory";
+
+const _abi = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "addr",
+        type: "address",
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "salt",
+        type: "bytes32",
+      },
+    ],
+    name: "Deployed",
+    type: "event",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "salt",
+        type: "bytes32",
+      },
+      {
+        internalType: "bytes",
+        name: "creationCode",
+        type: "bytes",
+      },
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256",
+      },
+    ],
+    name: "deploy",
+    outputs: [
+      {
+        internalType: "address",
+        name: "addr",
+        type: "address",
+      },
+    ],
+    stateMutability: "nonpayable",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "salt",
+        type: "bytes32",
+      },
+      {
+        internalType: "bytes32",
+        name: "codeHash",
+        type: "bytes32",
+      },
+    ],
+    name: "getAddress",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "salt",
+        type: "bytes32",
+      },
+      {
+        internalType: "bytes32",
+        name: "codeHash",
+        type: "bytes32",
+      },
+    ],
+    name: "getAddressTron",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address",
+      },
+    ],
+    stateMutability: "view",
+    type: "function",
+  },
+] as const;
+
+const _bytecode =
+  "0x6080604052348015600f57600080fd5b506102f98061001f6000396000f3fe608060405234801561001057600080fd5b50600436106100415760003560e01c8063933559b014610046578063c7aeef0f14610075578063d3a3968614610088575b600080fd5b61005961005436600461018e565b61009b565b6040516001600160a01b03909116815260200160405180910390f35b6100596100833660046101c6565b6100d8565b61005961009636600461018e565b61016c565b6040516000906100b990604160f81b9030908690869060200161028a565b60408051601f1981840301815291905280516020909101209392505050565b60008383516020850184f590506001600160a01b03811661012f5760405162461bcd60e51b815260206004820152600d60248201526c1111541313d657d19052531151609a1b604482015260640160405180910390fd5b60405184906001600160a01b038316907f94bfd9af14ef450884c8a7ddb5734e2e1e14e70a1c84f0801cc5a29e34d2642890600090a39392505050565b6040516000906100b9906001600160f81b03199030908690869060200161028a565b600080604083850312156101a157600080fd5b50508035926020909101359150565b634e487b7160e01b600052604160045260246000fd5b6000806000606084860312156101db57600080fd5b83359250602084013567ffffffffffffffff808211156101fa57600080fd5b818601915086601f83011261020e57600080fd5b813581811115610220576102206101b0565b604051601f8201601f19908116603f01168101908382118183101715610248576102486101b0565b8160405282815289602084870101111561026157600080fd5b826020860160208301376000602084830101528096505050505050604084013590509250925092565b6001600160f81b031994909416845260609290921b6bffffffffffffffffffffffff19166001840152601583015260358201526055019056fea26469706673582212205fb7d781d8404b93aed56d95e5543997fe78a250c5faf35b40c771504b4c853b64736f6c63430008190033";
+
+type Create2FactoryConstructorParams =
+  | [signer?: Signer]
+  | ConstructorParameters<typeof ContractFactory>;
+
+const isSuperArgs = (
+  xs: Create2FactoryConstructorParams
+): xs is ConstructorParameters<typeof ContractFactory> => xs.length > 1;
+
+export class Create2Factory__factory extends ContractFactory {
+  constructor(...args: Create2FactoryConstructorParams) {
+    if (isSuperArgs(args)) {
+      super(...args);
+    } else {
+      super(_abi, _bytecode, args[0]);
+    }
+  }
+
+  override getDeployTransaction(
+    overrides?: NonPayableOverrides & { from?: string }
+  ): Promise<ContractDeployTransaction> {
+    return super.getDeployTransaction(overrides || {});
+  }
+  override deploy(overrides?: NonPayableOverrides & { from?: string }) {
+    return super.deploy(overrides || {}) as Promise<
+      Create2Factory & {
+        deploymentTransaction(): ContractTransactionResponse;
+      }
+    >;
+  }
+  override connect(runner: ContractRunner | null): Create2Factory__factory {
+    return super.connect(runner) as Create2Factory__factory;
+  }
+
+  static readonly bytecode = _bytecode;
+  static readonly abi = _abi;
+  static createInterface(): Create2FactoryInterface {
+    return new Interface(_abi) as Create2FactoryInterface;
+  }
+  static connect(
+    address: string,
+    runner?: ContractRunner | null
+  ): Create2Factory {
+    return new Contract(address, _abi, runner) as unknown as Create2Factory;
+  }
+}

package/typechain-types/factories/contracts/factory/index.ts

@@ -0,0 +1,4 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export { Create2Factory__factory } from "./Create2Factory__factory";

package/typechain-types/factories/contracts/index.ts

@@ -2,4 +2,5 @@
 /* tslint:disable */
 /* eslint-disable */
 export * as base from "./base";
+export * as factory from "./factory";
 export { AuthorityManager__factory } from "./AuthorityManager__factory";

package/typechain-types/hardhat.d.ts

@@ -89,6 +89,10 @@ declare module "hardhat/types/runtime" {
       name: "BaseImplementation",
       signerOrOptions?: ethers.Signer | FactoryOptions
     ): Promise<Contracts.BaseImplementation__factory>;
+    getContractFactory(
+      name: "Create2Factory",
+      signerOrOptions?: ethers.Signer | FactoryOptions
+    ): Promise<Contracts.Create2Factory__factory>;
 
     getContractAt(
       name: "AccessManagedUpgradeable",
@@ -185,6 +189,11 @@ declare module "hardhat/types/runtime" {
       address: string | ethers.Addressable,
       signer?: ethers.Signer
     ): Promise<Contracts.BaseImplementation>;
+    getContractAt(
+      name: "Create2Factory",
+      address: string | ethers.Addressable,
+      signer?: ethers.Signer
+    ): Promise<Contracts.Create2Factory>;
 
     deployContract(
       name: "AccessManagedUpgradeable",
@@ -262,6 +271,10 @@ declare module "hardhat/types/runtime" {
       name: "BaseImplementation",
       signerOrOptions?: ethers.Signer | DeployContractOptions
     ): Promise<Contracts.BaseImplementation>;
+    deployContract(
+      name: "Create2Factory",
+      signerOrOptions?: ethers.Signer | DeployContractOptions
+    ): Promise<Contracts.Create2Factory>;
 
     deployContract(
       name: "AccessManagedUpgradeable",
@@ -358,6 +371,11 @@ declare module "hardhat/types/runtime" {
       args: any[],
       signerOrOptions?: ethers.Signer | DeployContractOptions
     ): Promise<Contracts.BaseImplementation>;
+    deployContract(
+      name: "Create2Factory",
+      args: any[],
+      signerOrOptions?: ethers.Signer | DeployContractOptions
+    ): Promise<Contracts.Create2Factory>;
 
     // default types
     getContractFactory(

package/typechain-types/index.ts

@@ -44,3 +44,5 @@ export type { AuthorityManager } from "./contracts/AuthorityManager";
 export { AuthorityManager__factory } from "./factories/contracts/AuthorityManager__factory";
 export type { BaseImplementation } from "./contracts/base/BaseImplementation";
 export { BaseImplementation__factory } from "./factories/contracts/base/BaseImplementation__factory";
+export type { Create2Factory } from "./contracts/factory/Create2Factory";
+export { Create2Factory__factory } from "./factories/contracts/factory/Create2Factory__factory";

package/utils/addressCodec.ts

@@ -1,10 +1,15 @@
+/**
+ * Multi-chain address encoding — converts EVM, Tron, and Solana addresses to hex bytes.
+ */
 import bs58 from "bs58";
+import { tronToHex } from "./tronHelper";
 
 /**
- * Convert address to hex bytes based on address format
- * - EVM address (0x prefix): return as-is (20 bytes)
- * - Tron address (T prefix, 34 chars): base58 decode, extract 20 bytes
+ * Convert any address format to hex bytes.
+ * - EVM address (0x prefix): return as-is lowercase
+ * - Tron address (T prefix, 34 chars, 0x41 byte): convert via tronToHex
  * - Solana/other base58 address: base58 decode to full bytes
+ * @param addr - address in any supported format
  */
 export function addressToHex(addr: string): string {
     if (addr.startsWith("0x")) {
@@ -12,10 +17,7 @@ export function addressToHex(addr: string): string {
     }
 
     if (isTronAddress(addr)) {
-        const decoded = bs58.decode(addr);
-        // Tron format: 0x41 (1 byte) + address (20 bytes) + checksum (4 bytes)
-        const addressBytes = decoded.slice(1, 21);
-        return "0x" + Buffer.from(addressBytes).toString("hex");
+        return tronToHex(addr);
     }
 
     if (isBase58(addr)) {
@@ -26,6 +28,7 @@ export function addressToHex(addr: string): string {
     throw new Error(`Unknown address format: ${addr}`);
 }
 
+/** Check if a string is valid base58 encoding. */
 export function isBase58(addr: string): boolean {
     const base58Chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
     for (const char of addr) {
@@ -36,6 +39,7 @@ export function isBase58(addr: string): boolean {
     return true;
 }
 
+/** Check if address is Tron format (T prefix, 34 chars, 0x41 first byte after decode). */
 export function isTronAddress(addr: string): boolean {
     if (!addr.startsWith("T") || addr.length !== 34 || !isBase58(addr)) return false;
     try {
@@ -47,6 +51,7 @@ export function isTronAddress(addr: string): boolean {
     }
 }
 
+/** Check if chain name is Solana. */
 export function isSolanaChain(chainName: string): boolean {
     return chainName === "Sol" || chainName === "sol_test";
 }