@sun-protocol/sun-sdk-core 0.1.0-beta.0

package/dist/index.d.ts

@@ -0,0 +1,628 @@
+import JSBI from 'jsbi';
+import { BigNumber } from '@ethersproject/bignumber';
+import { BytesLike } from '@ethersproject/bytes';
+
+declare enum ChainId {
+    MAINNET = 1,
+    GOERLI = 5,
+    SEPOLIA = 11155111,
+    OPTIMISM = 10,
+    OPTIMISM_GOERLI = 420,
+    OPTIMISM_SEPOLIA = 11155420,
+    ARBITRUM_ONE = 42161,
+    ARBITRUM_GOERLI = 421613,
+    ARBITRUM_SEPOLIA = 421614,
+    POLYGON = 137,
+    POLYGON_MUMBAI = 80001,
+    CELO = 42220,
+    CELO_ALFAJORES = 44787,
+    GNOSIS = 100,
+    MOONBEAM = 1284,
+    BNB = 56,
+    AVALANCHE = 43114,
+    BASE_GOERLI = 84531,
+    BASE_SEPOLIA = 84532,
+    BASE = 8453,
+    ZORA = 7777777,
+    ZORA_SEPOLIA = 999999999,
+    ROOTSTOCK = 30,
+    BLAST = 81457,
+    ZKSYNC = 324,
+    WORLDCHAIN = 480,
+    UNICHAIN_SEPOLIA = 1301,
+    UNICHAIN = 130,
+    MONAD_TESTNET = 10143,
+    SONEIUM = 1868,
+    MONAD = 143,
+    XLAYER = 196,
+    LINEA = 59144,
+    TEMPO = 4217,
+    MEGAETH = 4326,
+    ARC = 5042,
+    ROBINHOOD = 4663,
+    INK = 57073
+}
+/**
+ * Average block time in seconds, per chain. Fractional values are intentional
+ * for sub-second chains so block-from-timestamp math stays accurate. Used as a
+ * single source of truth across UniswapX services and GPA to avoid drift.
+ *
+ * Values reflect each chain's most recent published target as of the last
+ * update; update here when chains alter their block cadence.
+ */
+declare const AVERAGE_BLOCK_TIMES_SECONDS: {
+    [chainId: number]: number;
+};
+/**
+ * Returns the average block time in seconds for a chain. Throws if the chain
+ * is not registered — callers must extend AVERAGE_BLOCK_TIMES_SECONDS rather
+ * than silently fall back to a mainnet-shaped default that would undercount
+ * blocks on faster chains.
+ */
+declare function getAverageBlockTimeSecs(chainId: number): number;
+/**
+ * Converts a wallclock duration in seconds to a block count for the given
+ * chain, rounding up so the resulting window fully covers the requested time.
+ * Throws if the chain is not registered in AVERAGE_BLOCK_TIMES_SECONDS.
+ */
+declare function secondsToBlocks(seconds: number, chainId: number): number;
+declare const SUPPORTED_CHAINS: readonly [ChainId.MAINNET, ChainId.OPTIMISM, ChainId.OPTIMISM_GOERLI, ChainId.OPTIMISM_SEPOLIA, ChainId.ARBITRUM_ONE, ChainId.ARBITRUM_GOERLI, ChainId.ARBITRUM_SEPOLIA, ChainId.POLYGON, ChainId.POLYGON_MUMBAI, ChainId.GOERLI, ChainId.SEPOLIA, ChainId.CELO_ALFAJORES, ChainId.CELO, ChainId.BNB, ChainId.AVALANCHE, ChainId.BASE, ChainId.BASE_GOERLI, ChainId.BASE_SEPOLIA, ChainId.ZORA, ChainId.ZORA_SEPOLIA, ChainId.ROOTSTOCK, ChainId.BLAST, ChainId.ZKSYNC, ChainId.WORLDCHAIN, ChainId.UNICHAIN_SEPOLIA, ChainId.UNICHAIN, ChainId.MONAD_TESTNET, ChainId.SONEIUM, ChainId.MONAD, ChainId.XLAYER, ChainId.LINEA, ChainId.TEMPO, ChainId.MEGAETH, ChainId.ARC, ChainId.ROBINHOOD, ChainId.INK];
+type SupportedChainsType = (typeof SUPPORTED_CHAINS)[number];
+declare enum NativeCurrencyName {
+    ETHER = "ETH",
+    MATIC = "MATIC",
+    CELO = "CELO",
+    GNOSIS = "XDAI",
+    MOONBEAM = "GLMR",
+    BNB = "BNB",
+    AVAX = "AVAX",
+    ROOTSTOCK = "RBTC"
+}
+
+type AddressMap = {
+    [chainId: number]: string;
+};
+type ChainAddresses = {
+    v3CoreFactoryAddress: string;
+    multicallAddress: string;
+    quoterAddress: string;
+    v3MigratorAddress?: string;
+    nonfungiblePositionManagerAddress?: string;
+    tickLensAddress?: string;
+    swapRouter02Address?: string;
+    mixedRouteQuoterV1Address?: string;
+    mixedRouteQuoterV2Address?: string;
+    v4PoolManagerAddress?: string;
+    v4PositionManagerAddress?: string;
+    v4StateView?: string;
+    v4QuoterAddress?: string;
+    permissionedV4PositionManagerAddress?: string;
+};
+declare const UNI_ADDRESSES: AddressMap;
+declare const UNISWAP_NFT_AIRDROP_CLAIM_ADDRESS = "0x8B799381ac40b838BBA4131ffB26197C432AFe78";
+/**
+ * @deprecated use V2_FACTORY_ADDRESSES instead
+ */
+declare const V2_FACTORY_ADDRESS = "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f";
+declare const V2_FACTORY_ADDRESSES: AddressMap;
+/**
+ * @deprecated use V2_ROUTER_ADDRESSES instead
+ */
+declare const V2_ROUTER_ADDRESS = "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D";
+declare const V2_ROUTER_ADDRESSES: AddressMap;
+declare const CHAIN_TO_ADDRESSES_MAP: Record<SupportedChainsType, ChainAddresses>;
+declare const V3_CORE_FACTORY_ADDRESSES: AddressMap;
+declare const V3_MIGRATOR_ADDRESSES: AddressMap;
+declare const MULTICALL_ADDRESSES: AddressMap;
+/**
+ * The oldest V0 governance address
+ */
+declare const GOVERNANCE_ALPHA_V0_ADDRESSES: AddressMap;
+/**
+ * The older V1 governance address
+ */
+declare const GOVERNANCE_ALPHA_V1_ADDRESSES: AddressMap;
+/**
+ * The latest governor bravo that is currently admin of timelock
+ */
+declare const GOVERNANCE_BRAVO_ADDRESSES: AddressMap;
+declare const TIMELOCK_ADDRESSES: AddressMap;
+declare const MERKLE_DISTRIBUTOR_ADDRESS: AddressMap;
+declare const ARGENT_WALLET_DETECTOR_ADDRESS: AddressMap;
+declare const QUOTER_ADDRESSES: AddressMap;
+declare const NONFUNGIBLE_POSITION_MANAGER_ADDRESSES: AddressMap;
+declare const ENS_REGISTRAR_ADDRESSES: AddressMap;
+declare const SOCKS_CONTROLLER_ADDRESSES: AddressMap;
+declare const TICK_LENS_ADDRESSES: AddressMap;
+declare const MIXED_ROUTE_QUOTER_V1_ADDRESSES: AddressMap;
+declare const SWAP_ROUTER_02_ADDRESSES: (chainId: number) => string;
+
+type BigintIsh = JSBI | string | number;
+declare enum TradeType {
+    EXACT_INPUT = 0,
+    EXACT_OUTPUT = 1
+}
+declare enum Rounding {
+    ROUND_DOWN = 0,
+    ROUND_HALF_UP = 1,
+    ROUND_UP = 2
+}
+declare const MaxUint256: JSBI;
+
+/**
+ * Represents an ERC20 token with a unique address and some metadata.
+ */
+declare class Token extends BaseCurrency {
+    readonly isNative: false;
+    readonly isToken: true;
+    /**
+     * The contract address on the chain on which this token lives
+     */
+    readonly address: string;
+    /**
+     * Relevant for fee-on-transfer (FOT) token taxes,
+     * Not every ERC20 token is FOT token, so this field is optional
+     */
+    readonly buyFeeBps?: BigNumber | undefined;
+    readonly sellFeeBps?: BigNumber | undefined;
+    /**
+     *
+     * @param chainId {@link BaseCurrency#chainId}
+     * @param address The contract address on the chain on which this token lives
+     * @param decimals {@link BaseCurrency#decimals}
+     * @param symbol {@link BaseCurrency#symbol}
+     * @param name {@link BaseCurrency#name}
+     * @param bypassChecksum If true it only checks for length === 42, startsWith 0x and contains only hex characters
+     * @param buyFeeBps Buy fee tax for FOT tokens, in basis points
+     * @param sellFeeBps Sell fee tax for FOT tokens, in basis points
+     */
+    constructor(chainId: number, address: string, decimals: number, symbol?: string, name?: string, bypassChecksum?: boolean, buyFeeBps?: BigNumber, sellFeeBps?: BigNumber);
+    /**
+     * Returns true if the two tokens are equivalent, i.e. have the same chainId and address.
+     * @param other other token to compare
+     */
+    equals(other: Currency): boolean;
+    /**
+     * Returns true if the address of this token sorts before the address of the other token
+     * @param other other token to compare
+     * @throws if the tokens have the same address
+     * @throws if the tokens are on different chains
+     */
+    sortsBefore(other: Token): boolean;
+    /**
+     * Return this token, which does not need to be wrapped
+     */
+    get wrapped(): Token;
+}
+
+/**
+ * A currency is any fungible financial instrument, including Ether, all ERC20 tokens, and other chain-native currencies
+ */
+declare abstract class BaseCurrency {
+    /**
+     * Returns whether the currency is native to the chain and must be wrapped (e.g. Ether)
+     */
+    abstract readonly isNative: boolean;
+    /**
+     * Returns whether the currency is a token that is usable in Uniswap without wrapping
+     */
+    abstract readonly isToken: boolean;
+    /**
+     * The chain ID on which this currency resides
+     */
+    readonly chainId: number;
+    /**
+     * The decimals used in representing currency amounts
+     */
+    readonly decimals: number;
+    /**
+     * The symbol of the currency, i.e. a short textual non-unique identifier
+     */
+    readonly symbol?: string | undefined;
+    /**
+     * The name of the currency, i.e. a descriptive textual non-unique identifier
+     */
+    readonly name?: string | undefined;
+    /**
+     * Constructs an instance of the base class `BaseCurrency`.
+     * @param chainId the chain ID on which this currency resides
+     * @param decimals decimals of the currency
+     * @param symbol symbol of the currency
+     * @param name of the currency
+     */
+    protected constructor(chainId: number, decimals: number, symbol?: string, name?: string);
+    /**
+     * Returns whether this currency is functionally equivalent to the other currency
+     * @param other the other currency
+     */
+    abstract equals(other: Currency): boolean;
+    /**
+     * Return the wrapped version of this currency that can be used with the Uniswap contracts. Currencies must
+     * implement this to be used in Uniswap
+     */
+    abstract get wrapped(): Token;
+}
+
+/**
+ * Represents the native currency of the chain on which it resides, e.g.
+ */
+declare abstract class NativeCurrency extends BaseCurrency {
+    readonly isNative: true;
+    readonly isToken: false;
+}
+
+type Currency = NativeCurrency | Token;
+
+declare class Fraction {
+    readonly numerator: JSBI;
+    readonly denominator: JSBI;
+    constructor(numerator: BigintIsh, denominator?: BigintIsh);
+    private static tryParseFraction;
+    get quotient(): JSBI;
+    get remainder(): Fraction;
+    invert(): Fraction;
+    add(other: Fraction | BigintIsh): Fraction;
+    subtract(other: Fraction | BigintIsh): Fraction;
+    lessThan(other: Fraction | BigintIsh): boolean;
+    equalTo(other: Fraction | BigintIsh): boolean;
+    greaterThan(other: Fraction | BigintIsh): boolean;
+    multiply(other: Fraction | BigintIsh): Fraction;
+    divide(other: Fraction | BigintIsh): Fraction;
+    toSignificant(significantDigits: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces: number, format?: object, rounding?: Rounding): string;
+    /**
+     * Helper method for converting any super class back to a fraction
+     */
+    get asFraction(): Fraction;
+}
+
+declare class CurrencyAmount<T extends Currency> extends Fraction {
+    readonly currency: T;
+    readonly decimalScale: JSBI;
+    /**
+     * Returns a new currency amount instance from the unitless amount of token, i.e. the raw amount
+     * @param currency the currency in the amount
+     * @param rawAmount the raw token or ether amount
+     */
+    static fromRawAmount<T extends Currency>(currency: T, rawAmount: BigintIsh): CurrencyAmount<T>;
+    /**
+     * Construct a currency amount with a denominator that is not equal to 1
+     * @param currency the currency
+     * @param numerator the numerator of the fractional token amount
+     * @param denominator the denominator of the fractional token amount
+     */
+    static fromFractionalAmount<T extends Currency>(currency: T, numerator: BigintIsh, denominator: BigintIsh): CurrencyAmount<T>;
+    protected constructor(currency: T, numerator: BigintIsh, denominator?: BigintIsh);
+    add(other: CurrencyAmount<T>): CurrencyAmount<T>;
+    subtract(other: CurrencyAmount<T>): CurrencyAmount<T>;
+    multiply(other: Fraction | BigintIsh): CurrencyAmount<T>;
+    divide(other: Fraction | BigintIsh): CurrencyAmount<T>;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+    toExact(format?: object): string;
+    get wrapped(): CurrencyAmount<Token>;
+}
+
+declare class Percent extends Fraction {
+    /**
+     * This boolean prevents a fraction from being interpreted as a Percent
+     */
+    readonly isPercent: true;
+    add(other: Fraction | BigintIsh): Percent;
+    subtract(other: Fraction | BigintIsh): Percent;
+    multiply(other: Fraction | BigintIsh): Percent;
+    divide(other: Fraction | BigintIsh): Percent;
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+}
+
+declare class Price<TBase extends Currency, TQuote extends Currency> extends Fraction {
+    readonly baseCurrency: TBase;
+    readonly quoteCurrency: TQuote;
+    readonly scalar: Fraction;
+    /**
+     * Construct a price, either with the base and quote currency amount, or the
+     * @param args
+     */
+    constructor(...args: [TBase, TQuote, BigintIsh, BigintIsh] | [{
+        baseAmount: CurrencyAmount<TBase>;
+        quoteAmount: CurrencyAmount<TQuote>;
+    }]);
+    /**
+     * Flip the price, switching the base and quote currency
+     */
+    invert(): Price<TQuote, TBase>;
+    /**
+     * Multiply the price by another price, returning a new price. The other price must have the same base currency as this price's quote currency
+     * @param other the other price
+     */
+    multiply<TOtherQuote extends Currency>(other: Price<TQuote, TOtherQuote>): Price<TBase, TOtherQuote>;
+    /**
+     * Return the amount of quote currency corresponding to a given amount of the base currency
+     * @param currencyAmount the amount of base currency to quote against the price
+     */
+    quote(currencyAmount: CurrencyAmount<TBase>): CurrencyAmount<TQuote>;
+    /**
+     * Get the value scaled by decimals for formatting
+     * @private
+     */
+    private get adjustedForDecimals();
+    toSignificant(significantDigits?: number, format?: object, rounding?: Rounding): string;
+    toFixed(decimalPlaces?: number, format?: object, rounding?: Rounding): string;
+}
+
+/**
+ * Ether keeps the upstream sdk-core class/export shape while representing native TRX for Sun SDK chains.
+ */
+declare class Ether extends NativeCurrency {
+    protected constructor(chainId: number);
+    get wrapped(): Token;
+    private static _etherCache;
+    static onChain(chainId: number): Ether;
+    equals(other: Currency): boolean;
+}
+
+/**
+ * Known WTRX implementation addresses, used in our implementation of Ether#wrapped.
+ * TRON base58 addresses are represented here as EVM-style 20-byte addresses so Token remains sdk-core compatible.
+ */
+declare const WETH9: {
+    [chainId: number]: Token;
+};
+declare const WTRX: {
+    [chainId: number]: Token;
+};
+
+/**
+ * Returns the percent difference between the mid price and the execution price, i.e. price impact.
+ * @param midPrice mid price before the trade
+ * @param inputAmount the input amount of the trade
+ * @param outputAmount the output amount of the trade
+ */
+declare function computePriceImpact<TBase extends Currency, TQuote extends Currency>(midPrice: Price<TBase, TQuote>, inputAmount: CurrencyAmount<TBase>, outputAmount: CurrencyAmount<TQuote>): Percent;
+
+declare function computeZksyncCreate2Address(sender: string, bytecodeHash: BytesLike, salt: BytesLike, input?: BytesLike): string;
+
+declare function sortedInsert<T>(items: T[], add: T, maxSize: number, comparator: (a: T, b: T) => number): T | null;
+
+/**
+ * Computes floor(sqrt(value))
+ * @param value the value for which to compute the square root, rounded down
+ */
+declare function sqrt(value: JSBI): JSBI;
+
+/**
+ * Validates an address and returns the parsed (checksummed) version of that address
+ * @param address the unchecksummed hex address
+ */
+declare function validateAndParseAddress(address: string): string;
+
+type TronAddress = string & {
+    readonly __tronAddress: unique symbol;
+};
+type TronHexAddress = string & {
+    readonly __tronHexAddress: unique symbol;
+};
+interface TronAddressCodec {
+    toHex(address: TronAddress): TronHexAddress | string;
+    fromHex(hex: TronHexAddress): TronAddress | string;
+}
+declare const TRON_ZERO_ADDRESS: TronAddress;
+declare function isTronBase58Address(value: string): value is TronAddress;
+declare function isTronHexAddress(value: string): value is TronHexAddress;
+declare function assertTronAddress(value: string, label?: string): TronAddress;
+declare function assertTronHexAddress(value: string, label?: string): TronHexAddress;
+declare function toTronHexAddress(address: TronAddress | string, codec: TronAddressCodec): TronHexAddress;
+declare function toTronBase58Address(hex: TronHexAddress | string, codec: TronAddressCodec): TronAddress;
+
+declare function parseUnits(value: string, decimals: number): bigint;
+declare function formatUnits(value: bigint, decimals: number): string;
+
+declare const SDK_ERROR_CODES: {
+    readonly SDK_INVALID_ARGUMENT: "SDK_INVALID_ARGUMENT";
+    readonly SDK_UNSUPPORTED_NETWORK: "SDK_UNSUPPORTED_NETWORK";
+    readonly SDK_WALLET_CAPABILITY_ERROR: "SDK_WALLET_CAPABILITY_ERROR";
+    readonly SDK_WALLET_ACCOUNT_MISMATCH: "SDK_WALLET_ACCOUNT_MISMATCH";
+    readonly SDK_WALLET_REJECTED: "SDK_WALLET_REJECTED";
+    readonly SDK_RUNTIME_ERROR: "SDK_RUNTIME_ERROR";
+    readonly SDK_API_ERROR: "SDK_API_ERROR";
+    readonly SDK_NO_ROUTE: "SDK_NO_ROUTE";
+    readonly SDK_CONTRACT_ERROR: "SDK_CONTRACT_ERROR";
+    readonly SDK_TX_BUILD_ERROR: "SDK_TX_BUILD_ERROR";
+    readonly SDK_TX_BROADCAST_ERROR: "SDK_TX_BROADCAST_ERROR";
+};
+type SDKErrorCode = keyof typeof SDK_ERROR_CODES;
+type Network = 'mainnet' | 'nile';
+declare class SDKError<TCode extends string = SDKErrorCode> extends Error {
+    readonly code: TCode;
+    readonly context: Record<string, unknown> | undefined;
+    constructor(code: TCode, message: string, context?: Record<string, unknown>);
+}
+declare function normalizeSDKError<TCode extends string>(error: unknown, code: TCode, message: string, context?: Record<string, unknown>): SDKError<string>;
+declare function sdkInvariant<TCode extends string>(condition: unknown, code: TCode, message: string, context?: Record<string, unknown>): asserts condition;
+
+/**
+ * Protocol identifiers intentionally remain open so protocol packages can
+ * publish stable identifiers without coupling core to every integration.
+ */
+type ProtocolId = string;
+type TransactionIntentDomain = 'swap' | 'liquidity' | 'position' | 'pump' | 'migration';
+interface TransactionIntentScope<Domain extends TransactionIntentDomain = TransactionIntentDomain> {
+    readonly domain: Domain;
+    readonly protocol: ProtocolId;
+    readonly operation?: string;
+}
+/**
+ * A notification-ready token amount. `value` is a non-localized decimal in
+ * token units; presentation concerns such as grouping belong to consumers.
+ */
+interface IntentAmount {
+    readonly value: string;
+    readonly symbol: string;
+}
+type TransactionIntent = {
+    readonly kind: 'approve';
+    readonly scope: TransactionIntentScope;
+    readonly tokenSymbol: string;
+} | {
+    readonly kind: 'swap';
+    readonly scope: TransactionIntentScope<'swap'>;
+    readonly from: IntentAmount;
+    readonly to: IntentAmount;
+    readonly recipient?: TronAddress;
+} | {
+    readonly kind: 'wrap' | 'unwrap';
+    readonly scope: TransactionIntentScope<'swap'>;
+    readonly amount: string;
+} | {
+    readonly kind: 'create-pool';
+    readonly scope: TransactionIntentScope<'liquidity'>;
+    readonly poolId: string;
+} | {
+    readonly kind: 'add-liquidity';
+    readonly scope: TransactionIntentScope<'liquidity'>;
+    readonly positionId?: string;
+} | {
+    readonly kind: 'remove-liquidity';
+    readonly scope: TransactionIntentScope<'liquidity' | 'position'>;
+    readonly positionId?: string;
+} | {
+    readonly kind: 'collect-fees';
+    readonly scope: TransactionIntentScope<'position'>;
+    readonly positionId: string;
+} | {
+    readonly kind: 'pump-buy' | 'pump-sell';
+    readonly scope: TransactionIntentScope<'pump'>;
+    readonly token: TronAddress;
+};
+
+type TransactionActionType = 'approve' | 'typed-data-signature' | 'contract-call' | 'deferred-contract-call' | 'http-request';
+type TransactionActionStatus = 'planned';
+type TransactionActionExecutor = 'runtime' | 'wallet-signature' | 'api';
+/**
+ * Receipt level required before an action is considered ready for its dependents.
+ *
+ * - `included`: the transaction has been included and executed in the FullNode's
+ *   latest head. This is suitable for dependencies such as approve -> swap, but
+ *   the containing block is not yet irreversible and may theoretically be
+ *   reorganized.
+ * - `solidified`: the receipt is visible from the SolidityNode's solidified
+ *   state. This is irreversible/final, but normally takes materially longer.
+ */
+type TransactionReceiptFinality = 'included' | 'solidified';
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonObject | JsonArray;
+interface JsonObject {
+    readonly [key: string]: JsonValue;
+}
+type JsonArray = readonly JsonValue[];
+interface ContractParameterComponent {
+    readonly name?: string;
+    readonly type: string;
+    readonly components?: readonly ContractParameterComponent[];
+}
+interface ContractParameter {
+    readonly type: string;
+    readonly value: unknown;
+    readonly components?: readonly ContractParameterComponent[];
+}
+interface TokenRequirement {
+    readonly token: TronAddress;
+    readonly amount: string;
+    readonly spender: TronAddress;
+    readonly approval: 'approve-or-permit2';
+}
+interface HttpRequestSpec {
+    readonly method: 'GET' | 'POST';
+    readonly url: string;
+    readonly headers?: Record<string, string>;
+    readonly body?: unknown;
+}
+interface BaseTransactionAction {
+    readonly id: string;
+    readonly type: TransactionActionType;
+    readonly status: TransactionActionStatus;
+    readonly execute: TransactionActionExecutor;
+    /**
+     * Wait for this receipt level before continuing. When omitted, successful
+     * broadcast is sufficient and execution continues without polling a receipt.
+     */
+    readonly waitForReceipt?: TransactionReceiptFinality;
+    readonly metadata?: Record<string, unknown>;
+}
+interface ContractCallAction extends BaseTransactionAction {
+    readonly type: 'contract-call' | 'approve';
+    readonly execute: 'runtime';
+    readonly intent?: TransactionIntent;
+    readonly target: TronAddress;
+    readonly functionSelector: string;
+    readonly parameters?: readonly ContractParameter[];
+    readonly abiFunction?: unknown;
+    readonly rawParameter?: string;
+    readonly callValue?: bigint;
+    readonly feeLimit?: number;
+    readonly tokenRequirements?: readonly TokenRequirement[];
+}
+interface DeferredContractCallMaterialization {
+    readonly kind: string;
+    readonly data: JsonObject;
+}
+interface DeferredContractCallAction extends BaseTransactionAction {
+    readonly type: 'deferred-contract-call';
+    readonly execute: 'runtime';
+    readonly intent?: TransactionIntent;
+    readonly materialization: DeferredContractCallMaterialization;
+}
+interface TypedDataSignatureAction extends BaseTransactionAction {
+    readonly type: 'typed-data-signature';
+    readonly execute: 'wallet-signature';
+    readonly typedData: unknown;
+}
+interface HttpRequestAction extends BaseTransactionAction {
+    readonly type: 'http-request';
+    readonly execute: 'api';
+    readonly request: HttpRequestSpec;
+}
+type TransactionAction = ContractCallAction | DeferredContractCallAction | TypedDataSignatureAction | HttpRequestAction;
+declare function createContractCallAction(input: {
+    id: string;
+    target: TronAddress;
+    functionSelector: string;
+    parameters?: readonly ContractParameter[];
+    abiFunction?: unknown;
+    rawParameter?: string;
+    callValue?: bigint;
+    feeLimit?: number;
+    tokenRequirements?: readonly TokenRequirement[];
+    waitForReceipt?: TransactionReceiptFinality;
+    metadata?: Record<string, unknown>;
+    intent?: TransactionIntent;
+}): ContractCallAction;
+declare function createApproveAction(input: {
+    id: string;
+    target: TronAddress;
+    spender: string;
+    amount: string;
+    feeLimit?: number;
+    metadata?: Record<string, unknown>;
+    intent?: TransactionIntent;
+}): ContractCallAction;
+declare function createDeferredContractCallAction(input: {
+    id: string;
+    materialization: DeferredContractCallMaterialization;
+    waitForReceipt?: TransactionReceiptFinality;
+    metadata?: Record<string, unknown>;
+    intent?: TransactionIntent;
+}): DeferredContractCallAction;
+declare function createTypedDataSignatureAction(input: {
+    id: string;
+    typedData: unknown;
+    metadata?: Record<string, unknown>;
+}): TypedDataSignatureAction;
+declare function createHttpRequestAction(input: {
+    id: string;
+    request: HttpRequestSpec;
+    metadata?: Record<string, unknown>;
+}): HttpRequestAction;
+
+export { ARGENT_WALLET_DETECTOR_ADDRESS, AVERAGE_BLOCK_TIMES_SECONDS, type BaseTransactionAction, type BigintIsh, CHAIN_TO_ADDRESSES_MAP, ChainId, type ContractCallAction, type ContractParameter, type ContractParameterComponent, type Currency, CurrencyAmount, type DeferredContractCallAction, type DeferredContractCallMaterialization, ENS_REGISTRAR_ADDRESSES, Ether, Fraction, GOVERNANCE_ALPHA_V0_ADDRESSES, GOVERNANCE_ALPHA_V1_ADDRESSES, GOVERNANCE_BRAVO_ADDRESSES, type HttpRequestAction, type HttpRequestSpec, type IntentAmount, type JsonArray, type JsonObject, type JsonPrimitive, type JsonValue, MERKLE_DISTRIBUTOR_ADDRESS, MIXED_ROUTE_QUOTER_V1_ADDRESSES, MULTICALL_ADDRESSES, MaxUint256, NONFUNGIBLE_POSITION_MANAGER_ADDRESSES, NativeCurrency, NativeCurrencyName, type Network, Percent, Price, type ProtocolId, QUOTER_ADDRESSES, Rounding, SDKError, type SDKErrorCode, SDK_ERROR_CODES, SOCKS_CONTROLLER_ADDRESSES, SUPPORTED_CHAINS, SWAP_ROUTER_02_ADDRESSES, type SupportedChainsType, TICK_LENS_ADDRESSES, TIMELOCK_ADDRESSES, TRON_ZERO_ADDRESS, Token, type TokenRequirement, TradeType, type TransactionAction, type TransactionActionExecutor, type TransactionActionStatus, type TransactionActionType, type TransactionIntent, type TransactionIntentDomain, type TransactionIntentScope, type TransactionReceiptFinality, type TronAddress, type TronAddressCodec, type TronHexAddress, type TypedDataSignatureAction, UNISWAP_NFT_AIRDROP_CLAIM_ADDRESS, UNI_ADDRESSES, V2_FACTORY_ADDRESS, V2_FACTORY_ADDRESSES, V2_ROUTER_ADDRESS, V2_ROUTER_ADDRESSES, V3_CORE_FACTORY_ADDRESSES, V3_MIGRATOR_ADDRESSES, WETH9, WTRX, assertTronAddress, assertTronHexAddress, computePriceImpact, computeZksyncCreate2Address, createApproveAction, createContractCallAction, createDeferredContractCallAction, createHttpRequestAction, createTypedDataSignatureAction, formatUnits, getAverageBlockTimeSecs, isTronBase58Address, isTronHexAddress, normalizeSDKError, parseUnits, sdkInvariant, secondsToBlocks, sortedInsert, sqrt, toTronBase58Address, toTronHexAddress, validateAndParseAddress };