@bankofai/x402 0.3.0

package/README.md

@@ -0,0 +1,368 @@
+# @bankofai/x402
+
+TypeScript client SDK for the x402 payment protocol on TRON blockchain. Enable pay-per-request APIs with automatic HTTP 402 payment handling.
+
+## Features
+
+- 🔐 **Automatic Payment Handling** - Transparently handles HTTP 402 Payment Required responses
+- ⛓️ **TRON Native** - Built for TRON Mainnet, Shasta, and Nile testnets
+- 🔑 **TIP-712 Signing** - Secure cryptographic signatures using TRON's EIP-712 implementation
+- 💰 **Token Approval Management** - Automatic ERC20 token allowance handling
+- 🚀 **Simple Integration** - Just 3 lines of code to get started
+- 📦 **Zero Dependencies** - Only requires `tronweb` as peer dependency
+
+## Installation
+
+```bash
+npm i @bankofai/x402 tronweb
+```
+
+## Quick Start
+
+```typescript
+import TronWeb from 'tronweb';
+import {
+  X402Client,
+  X402FetchClient,
+  ExactTronClientMechanism,
+  TronClientSigner,
+} from '@bankofai/x402';
+
+// 1. Initialize TronWeb
+const tronWeb = new TronWeb({
+  fullHost: 'https://nile.trongrid.io',
+  privateKey: 'your_private_key_here',
+});
+
+// 2. Create signer and register payment mechanism
+const signer = TronClientSigner.withPrivateKey(tronWeb, 'your_private_key_here', 'nile');
+const x402Client = new X402Client().register('tron:*', new ExactTronClientMechanism(signer));
+
+// 3. Create HTTP client with automatic 402 handling
+const client = new X402FetchClient(x402Client);
+
+// 4. Make requests - payments are handled automatically!
+const response = await client.get('https://api.example.com/premium-data');
+const data = await response.json();
+console.log(data);
+```
+
+## Core Concepts
+
+### Payment Flow
+
+When you make a request to a protected resource:
+
+1. **First Request** - Server responds with `402 Payment Required` and payment requirements
+2. **Payment Creation** - SDK automatically creates and signs a payment permit
+3. **Token Approval** - SDK ensures sufficient token allowance (if needed)
+4. **Retry with Payment** - Request is retried with payment signature
+5. **Success** - Server validates payment and returns the protected resource
+
+### Components
+
+- **`X402Client`** - Core payment client that manages payment mechanisms
+- **`X402FetchClient`** - HTTP client wrapper with automatic 402 handling
+- **`TronClientSigner`** - Signs payment permits using TIP-712
+- **`ExactTronClientMechanism`** - Implements the "exact" payment scheme for TRON
+
+## API Reference
+
+### X402Client
+
+Core client for managing payment mechanisms.
+
+```typescript
+const x402Client = new X402Client();
+```
+
+#### Methods
+
+##### `register(networkPattern: string, mechanism: ClientMechanism): X402Client`
+
+Register a payment mechanism for a network pattern.
+
+```typescript
+x402Client.register('tron:*', new ExactTronClientMechanism(signer));
+x402Client.register('tron:nile', new ExactTronClientMechanism(nileSigner));
+```
+
+##### `selectPaymentRequirements(accepts: PaymentRequirements[], filters?: PaymentRequirementsFilter): PaymentRequirements`
+
+Select payment requirements from available options.
+
+```typescript
+const selected = x402Client.selectPaymentRequirements(accepts, {
+  network: 'tron:nile',
+  maxAmount: '1000000',
+});
+```
+
+##### `createPaymentPayload(requirements: PaymentRequirements, resource: string, extensions?: object): Promise<PaymentPayload>`
+
+Create a payment payload for the given requirements.
+
+```typescript
+const payload = await x402Client.createPaymentPayload(requirements, '/api/data', extensions);
+```
+
+### X402FetchClient
+
+HTTP client with automatic 402 payment handling.
+
+```typescript
+const client = new X402FetchClient(x402Client, selector?);
+```
+
+#### Methods
+
+##### `get(url: string, init?: RequestInit): Promise<Response>`
+
+Make a GET request with automatic payment handling.
+
+```typescript
+const response = await client.get('https://api.example.com/data');
+```
+
+##### `post(url: string, body?: RequestInit['body'], init?: RequestInit): Promise<Response>`
+
+Make a POST request with automatic payment handling.
+
+```typescript
+const response = await client.post('https://api.example.com/data', JSON.stringify({ key: 'value' }));
+```
+
+##### `request(url: string, init?: RequestInit): Promise<Response>`
+
+Make any HTTP request with automatic payment handling.
+
+```typescript
+const response = await client.request('https://api.example.com/data', {
+  method: 'PUT',
+  body: JSON.stringify({ key: 'value' }),
+});
+```
+
+### TronClientSigner
+
+Signer for creating payment permits using TIP-712.
+
+#### Static Methods
+
+##### `withPrivateKey(tronWeb: TronWeb, privateKey: string, network?: TronNetwork): TronClientSigner`
+
+Create a signer with an explicit private key.
+
+```typescript
+const signer = TronClientSigner.withPrivateKey(tronWeb, '0x...', 'nile');
+```
+
+##### `fromTronWeb(tronWeb: TronWeb, network?: TronNetwork): TronClientSigner`
+
+Create a signer from a TronWeb instance (uses default private key).
+
+```typescript
+const signer = TronClientSigner.fromTronWeb(tronWeb, 'mainnet');
+```
+
+#### Instance Methods
+
+##### `getAddress(): string`
+
+Get the signer's TRON address (Base58 format).
+
+```typescript
+const address = signer.getAddress(); // "TXYZopYRdj2D9XRtbG411XZZ3kM5VkAeBf"
+```
+
+##### `checkAllowance(token: string, amount: bigint, network: string): Promise<bigint>`
+
+Check current token allowance for the payment permit contract.
+
+```typescript
+const allowance = await signer.checkAllowance(tokenAddress, BigInt(1000000), 'tron:nile');
+```
+
+##### `ensureAllowance(token: string, amount: bigint, network: string, mode?: 'auto' | 'interactive' | 'skip'): Promise<boolean>`
+
+Ensure sufficient token allowance, approving if necessary.
+
+```typescript
+await signer.ensureAllowance(tokenAddress, BigInt(1000000), 'tron:nile', 'auto');
+```
+
+### ExactTronClientMechanism
+
+Payment mechanism implementing the "exact" scheme for TRON.
+
+```typescript
+const mechanism = new ExactTronClientMechanism(signer);
+```
+
+## Usage Examples
+
+### Basic Usage with Automatic Payment
+
+```typescript
+import TronWeb from 'tronweb';
+import { X402Client, X402FetchClient, ExactTronClientMechanism, TronClientSigner } from '@bankofai/x402';
+
+const tronWeb = new TronWeb({
+  fullHost: 'https://nile.trongrid.io',
+  privateKey: process.env.TRON_PRIVATE_KEY,
+});
+
+const signer = TronClientSigner.withPrivateKey(tronWeb, process.env.TRON_PRIVATE_KEY, 'nile');
+const x402Client = new X402Client().register('tron:*', new ExactTronClientMechanism(signer));
+const client = new X402FetchClient(x402Client);
+
+// Automatic payment handling
+const response = await client.get('https://api.example.com/weather');
+const weather = await response.json();
+console.log(weather);
+```
+
+### Manual Payment Handling
+
+```typescript
+import TronWeb from 'tronweb';
+import { X402Client, ExactTronClientMechanism, TronClientSigner, encodePaymentPayload } from '@bankofai/x402';
+
+const tronWeb = new TronWeb({ fullHost: 'https://nile.trongrid.io', privateKey: process.env.TRON_PRIVATE_KEY });
+const signer = TronClientSigner.withPrivateKey(tronWeb, process.env.TRON_PRIVATE_KEY, 'nile');
+const x402Client = new X402Client().register('tron:*', new ExactTronClientMechanism(signer));
+
+// First request
+const response = await fetch('https://api.example.com/data');
+
+if (response.status === 402) {
+  // Parse payment requirements
+  const paymentRequired = await response.json();
+  
+  // Create payment payload
+  const payload = await x402Client.createPaymentPayload(
+    paymentRequired.accepts[0],
+    '/data',
+    paymentRequired.extensions
+  );
+  
+  // Retry with payment
+  const paidResponse = await fetch('https://api.example.com/data', {
+    headers: {
+      'PAYMENT-SIGNATURE': encodePaymentPayload(payload),
+    },
+  });
+  
+  const data = await paidResponse.json();
+  console.log(data);
+}
+```
+
+### Custom Payment Selection
+
+```typescript
+import { X402Client, X402FetchClient, ExactTronClientMechanism, TronClientSigner } from '@bankofai/x402';
+
+// Custom selector function
+const selector = (requirements) => {
+  // Choose the cheapest option
+  return requirements.sort((a, b) => BigInt(a.amount) - BigInt(b.amount))[0];
+};
+
+const client = new X402FetchClient(x402Client, selector);
+const response = await client.get('https://api.example.com/data');
+```
+
+### Browser Integration
+
+```typescript
+// In browser with TronLink wallet
+import { X402Client, X402FetchClient, ExactTronClientMechanism, TronClientSigner } from '@bankofai/x402';
+
+// Wait for TronLink
+const tronWeb = window.tronWeb;
+if (!tronWeb) {
+  throw new Error('TronLink not found');
+}
+
+const signer = TronClientSigner.fromTronWeb(tronWeb, 'mainnet');
+const x402Client = new X402Client().register('tron:*', new ExactTronClientMechanism(signer));
+const client = new X402FetchClient(x402Client);
+
+// Make paid requests
+const response = await client.get('https://api.example.com/premium-content');
+```
+
+### Multiple Networks
+
+```typescript
+// Support multiple TRON networks
+const nileClient = new X402Client()
+  .register('tron:nile', new ExactTronClientMechanism(nileSigner))
+  .register('tron:shasta', new ExactTronClientMechanism(shastaSigner))
+  .register('tron:mainnet', new ExactTronClientMechanism(mainnetSigner));
+```
+
+## Supported Networks
+
+- **TRON Mainnet** - `tron:mainnet`
+- **TRON Shasta Testnet** - `tron:shasta`
+- **TRON Nile Testnet** - `tron:nile`
+
+## Payment Schemes
+
+### Exact Scheme
+
+The `exact` scheme allows payments for a specified exact amount. Useful for:
+
+- Pay-per-use APIs (e.g., LLM token generation)
+- Fixed-price resources
+- Predictable pricing for API calls
+
+The server charges the exact amount specified in the payment permit.
+
+## Security
+
+- **Never commit private keys** - Use environment variables
+- **TIP-712 signatures** - Cryptographically secure payment permits
+- **Token allowances** - Explicit approval required before payments
+- **Trust-minimizing** - Facilitator cannot move funds outside client authorization
+
+## Troubleshooting
+
+### "TronWeb does not support signTypedData"
+
+Upgrade to TronWeb >= 5.0:
+
+```bash
+npm i tronweb@latest
+```
+
+### "No mechanism registered for network"
+
+Ensure you've registered a mechanism for the network:
+
+```typescript
+x402Client.register('tron:nile', new ExactTronClientMechanism(signer));
+```
+
+### "Insufficient allowance"
+
+The SDK automatically handles token approvals in `auto` mode. If you're using `skip` mode, manually approve tokens:
+
+```typescript
+await signer.ensureAllowance(tokenAddress, amount, network, 'auto');
+```
+
+## Links
+
+- **Repository**: https://github.com/bankofai/x402
+- **Issues**: https://github.com/bankofai/x402/issues
+- **Contributing**: https://github.com/bankofai/CONTRIBUTING.md
+- **Documentation**: https://github.com/bankofai/x402#readme
+- **TRON Documentation**: https://developers.tron.network/
+- **TIP-712 Specification**: https://github.com/tronprotocol/tips/blob/master/tip-712.md
+
+## License
+
+MIT

package/dist/abi.d.ts

@@ -0,0 +1,112 @@
+/**
+ * ABI and EIP-712 type definitions for x402 protocol
+ * Shared across all mechanisms
+ */
+import type { DeliveryKind } from './types/payment.js';
+/** EIP-712 Primary Type for PaymentPermit */
+export declare const PAYMENT_PERMIT_PRIMARY_TYPE = "PaymentPermitDetails";
+/**
+ * EIP-712 Domain Type
+ * Based on contract: keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)")
+ * Note: NO version field!
+ */
+export declare const EIP712_DOMAIN_TYPE: readonly [{
+    readonly name: "name";
+    readonly type: "string";
+}, {
+    readonly name: "chainId";
+    readonly type: "uint256";
+}, {
+    readonly name: "verifyingContract";
+    readonly type: "address";
+}];
+/**
+ * EIP-712 type definitions for PaymentPermit
+ * Based on PermitHash.sol from the contract
+ */
+export declare const PAYMENT_PERMIT_TYPES: {
+    readonly PermitMeta: readonly [{
+        readonly name: "kind";
+        readonly type: "uint8";
+    }, {
+        readonly name: "paymentId";
+        readonly type: "bytes16";
+    }, {
+        readonly name: "nonce";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validAfter";
+        readonly type: "uint256";
+    }, {
+        readonly name: "validBefore";
+        readonly type: "uint256";
+    }];
+    readonly Payment: readonly [{
+        readonly name: "payToken";
+        readonly type: "address";
+    }, {
+        readonly name: "payAmount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "payTo";
+        readonly type: "address";
+    }];
+    readonly Fee: readonly [{
+        readonly name: "feeTo";
+        readonly type: "address";
+    }, {
+        readonly name: "feeAmount";
+        readonly type: "uint256";
+    }];
+    readonly PaymentPermitDetails: readonly [{
+        readonly name: "meta";
+        readonly type: "PermitMeta";
+    }, {
+        readonly name: "buyer";
+        readonly type: "address";
+    }, {
+        readonly name: "caller";
+        readonly type: "address";
+    }, {
+        readonly name: "payment";
+        readonly type: "Payment";
+    }, {
+        readonly name: "fee";
+        readonly type: "Fee";
+    }];
+};
+/** Kind mapping for EIP-712 (string to numeric) */
+export declare const KIND_MAP: Record<DeliveryKind, number>;
+/** ERC20 ABI for allowance/approve calls */
+export declare const ERC20_ABI: readonly [{
+    readonly name: "allowance";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "owner";
+        readonly type: "address";
+    }, {
+        readonly name: "spender";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+}, {
+    readonly name: "approve";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "spender";
+        readonly type: "address";
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "";
+        readonly type: "bool";
+    }];
+}];
+//# sourceMappingURL=abi.d.ts.map

package/dist/abi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abi.d.ts","sourceRoot":"","sources":["../src/abi.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD,6CAA6C;AAC7C,eAAO,MAAM,2BAA2B,yBAAyB,CAAC;AAElE;;;;GAIG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;EAIrB,CAAC;AAEX;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBvB,CAAC;AAEX,mDAAmD;AACnD,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,YAAY,EAAE,MAAM,CAEjD,CAAC;AAEF,4CAA4C;AAC5C,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBZ,CAAC"}

package/dist/abi.js

@@ -0,0 +1,73 @@
+/**
+ * ABI and EIP-712 type definitions for x402 protocol
+ * Shared across all mechanisms
+ */
+/** EIP-712 Primary Type for PaymentPermit */
+export const PAYMENT_PERMIT_PRIMARY_TYPE = 'PaymentPermitDetails';
+/**
+ * EIP-712 Domain Type
+ * Based on contract: keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)")
+ * Note: NO version field!
+ */
+export const EIP712_DOMAIN_TYPE = [
+    { name: 'name', type: 'string' },
+    { name: 'chainId', type: 'uint256' },
+    { name: 'verifyingContract', type: 'address' },
+];
+/**
+ * EIP-712 type definitions for PaymentPermit
+ * Based on PermitHash.sol from the contract
+ */
+export const PAYMENT_PERMIT_TYPES = {
+    PermitMeta: [
+        { name: 'kind', type: 'uint8' },
+        { name: 'paymentId', type: 'bytes16' },
+        { name: 'nonce', type: 'uint256' },
+        { name: 'validAfter', type: 'uint256' },
+        { name: 'validBefore', type: 'uint256' },
+    ],
+    Payment: [
+        { name: 'payToken', type: 'address' },
+        { name: 'payAmount', type: 'uint256' },
+        { name: 'payTo', type: 'address' },
+    ],
+    Fee: [
+        { name: 'feeTo', type: 'address' },
+        { name: 'feeAmount', type: 'uint256' },
+    ],
+    PaymentPermitDetails: [
+        { name: 'meta', type: 'PermitMeta' },
+        { name: 'buyer', type: 'address' },
+        { name: 'caller', type: 'address' },
+        { name: 'payment', type: 'Payment' },
+        { name: 'fee', type: 'Fee' },
+    ],
+};
+/** Kind mapping for EIP-712 (string to numeric) */
+export const KIND_MAP = {
+    PAYMENT_ONLY: 0,
+};
+/** ERC20 ABI for allowance/approve calls */
+export const ERC20_ABI = [
+    {
+        name: 'allowance',
+        type: 'function',
+        stateMutability: 'view',
+        inputs: [
+            { name: 'owner', type: 'address' },
+            { name: 'spender', type: 'address' },
+        ],
+        outputs: [{ name: '', type: 'uint256' }],
+    },
+    {
+        name: 'approve',
+        type: 'function',
+        stateMutability: 'nonpayable',
+        inputs: [
+            { name: 'spender', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+        ],
+        outputs: [{ name: '', type: 'bool' }],
+    },
+];
+//# sourceMappingURL=abi.js.map

package/dist/abi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abi.js","sourceRoot":"","sources":["../src/abi.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,6CAA6C;AAC7C,MAAM,CAAC,MAAM,2BAA2B,GAAG,sBAAsB,CAAC;AAElE;;;;GAIG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG;IAChC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE;IAChC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;IACpC,EAAE,IAAI,EAAE,mBAAmB,EAAE,IAAI,EAAE,SAAS,EAAE;CACtC,CAAC;AAEX;;;GAGG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG;IAClC,UAAU,EAAE;QACV,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE;QAC/B,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE;QACtC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;QAClC,EAAE,IAAI,EAAE,YAAY,EAAE,IAAI,EAAE,SAAS,EAAE;QACvC,EAAE,IAAI,EAAE,aAAa,EAAE,IAAI,EAAE,SAAS,EAAE;KACzC;IACD,OAAO,EAAE;QACP,EAAE,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE;QACrC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE;QACtC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;KACnC;IACD,GAAG,EAAE;QACH,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;QAClC,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,SAAS,EAAE;KACvC;IACD,oBAAoB,EAAE;QACpB,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE;QACpC,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;QAClC,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE;QACnC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;QACpC,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,KAAK,EAAE;KAC7B;CACO,CAAC;AAEX,mDAAmD;AACnD,MAAM,CAAC,MAAM,QAAQ,GAAiC;IACpD,YAAY,EAAE,CAAC;CAChB,CAAC;AAEF,4CAA4C;AAC5C,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB;QACE,IAAI,EAAE,WAAW;QACjB,IAAI,EAAE,UAAU;QAChB,eAAe,EAAE,MAAM;QACvB,MAAM,EAAE;YACN,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE;YAClC,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;SACrC;QACD,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC;KACzC;IACD;QACE,IAAI,EAAE,SAAS;QACf,IAAI,EAAE,UAAU;QAChB,eAAe,EAAE,YAAY;QAC7B,MAAM,EAAE;YACN,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,SAAS,EAAE;YACpC,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE;SACpC;QACD,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,CAAC;KACtC;CACO,CAAC"}

package/dist/address.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Address conversion utilities for x402 protocol
+ * Handles conversion between TRON Base58 and EVM hex formats
+ */
+/** Hex address type */
+export type Hex = `0x${string}`;
+/** Zero address in EVM hex format */
+export declare const ZERO_ADDRESS_HEX: Hex;
+/**
+ * Address converter interface
+ */
+export interface AddressConverter {
+    /** Normalize address to canonical format */
+    normalize(address: string): string;
+    /** Convert to EVM hex format (0x...) */
+    toEvmFormat(address: string): Hex;
+    /** Get zero address for this network type */
+    getZeroAddress(): string;
+    /** Convert all addresses in a message object */
+    convertMessageAddresses(message: Record<string, unknown>): Record<string, unknown>;
+}
+/**
+ * EVM address converter (passthrough)
+ */
+export declare class EvmAddressConverter implements AddressConverter {
+    normalize(address: string): string;
+    toEvmFormat(address: string): Hex;
+    getZeroAddress(): string;
+    convertMessageAddresses(message: Record<string, unknown>): Record<string, unknown>;
+}
+/**
+ * TRON address converter
+ */
+export declare class TronAddressConverter implements AddressConverter {
+    normalize(address: string): string;
+    toEvmFormat(address: string): Hex;
+    getZeroAddress(): string;
+    convertMessageAddresses(message: Record<string, unknown>): Record<string, unknown>;
+    private isAddress;
+}
+/**
+ * Convert TRON address to EVM hex format (0x...)
+ * Handles: Base58 (T...), hex with 41 prefix, and 0x format
+ */
+export declare function toEvmHex(addr: string): Hex;
+/**
+ * Convert EVM hex address to TRON Base58 format
+ */
+export declare function toBase58(addr: string): string;
+//# sourceMappingURL=address.d.ts.map

package/dist/address.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.d.ts","sourceRoot":"","sources":["../src/address.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,uBAAuB;AACvB,MAAM,MAAM,GAAG,GAAG,KAAK,MAAM,EAAE,CAAC;AAKhC,qCAAqC;AACrC,eAAO,MAAM,gBAAgB,EAAE,GAAkD,CAAC;AAElF;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,4CAA4C;IAC5C,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC;IACnC,wCAAwC;IACxC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG,CAAC;IAClC,6CAA6C;IAC7C,cAAc,IAAI,MAAM,CAAC;IACzB,gDAAgD;IAChD,uBAAuB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpF;AAED;;GAEG;AACH,qBAAa,mBAAoB,YAAW,gBAAgB;IAC1D,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAIlC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG;IAOjC,cAAc,IAAI,MAAM;IAIxB,uBAAuB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAInF;AAED;;GAEG;AACH,qBAAa,oBAAqB,YAAW,gBAAgB;IAC3D,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM;IAKlC,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG;IAIjC,cAAc,IAAI,MAAM;IAIxB,uBAAuB,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAgBlF,OAAO,CAAC,SAAS;CASlB;AAED;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAoC1C;AAgCD;;GAEG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAoB7C"}