@layerzerolabs/lz-v2-stellar-sdk 0.2.8

package/dist/generated/uln302.d.ts

@@ -0,0 +1,1227 @@
+import { Buffer } from "buffer";
+import { AssembledTransaction, Client as ContractClient, ClientOptions as ContractClientOptions, MethodOptions } from '@stellar/stellar-sdk/contract';
+import type { u32, u64, i128, Option } from '@stellar/stellar-sdk/contract';
+export * from '@stellar/stellar-sdk';
+export * as contract from '@stellar/stellar-sdk/contract';
+export * as rpc from '@stellar/stellar-sdk/rpc';
+/**
+ * Ultra Light Node configuration for message verification.
+ */
+export interface UlnConfig {
+    /**
+   * Number of block confirmations required before message verification begins.
+   */
+    confirmations: u64;
+    /**
+   * Minimum number of optional DVNs required to verify.
+   */
+    optional_dvn_threshold: u32;
+    /**
+   * List of DVN addresses from which a threshold number must verify.
+   */
+    optional_dvns: Array<string>;
+    /**
+   * List of DVN addresses that must ALL verify the message (no threshold).
+   */
+    required_dvns: Array<string>;
+}
+/**
+ * OApp-specific ULN configuration with default override flags.
+ */
+export interface OAppUlnConfig {
+    /**
+   * OApp-specific ULN configuration (used when defaults are not applied).
+   */
+    uln_config: UlnConfig;
+    /**
+   * Whether to use default confirmations.
+   */
+    use_default_confirmations: boolean;
+    /**
+   * Whether to use default optional DVNs.
+   */
+    use_default_optional_dvns: boolean;
+    /**
+   * Whether to use default required DVNs.
+   */
+    use_default_required_dvns: boolean;
+}
+/**
+ * Parameter for setting default ULN configuration for a destination/source endpoint.
+ */
+export interface SetDefaultUlnConfigParam {
+    /**
+   * The ULN configuration to set as default.
+   */
+    config: UlnConfig;
+    /**
+   * The destination endpoint ID (for send) or source endpoint ID (for receive).
+   */
+    dst_eid: u32;
+}
+/**
+ * Executor configuration for message delivery.
+ */
+export interface ExecutorConfig {
+    /**
+   * Address of the executor contract responsible for message execution.
+   */
+    executor: string;
+    /**
+   * Maximum size of messages that can be executed (in bytes).
+   */
+    max_message_size: u32;
+}
+/**
+ * OApp-specific executor configuration.
+ *
+ * If executor is `None`, the default executor is used.
+ */
+export interface OAppExecutorConfig {
+    /**
+   * Address of the executor contract to be used for message execution. None means use default configuration.
+   */
+    executor: Option<string>;
+    /**
+   * Maximum size of messages that can be executed (in bytes). 0 means use default configuration.
+   */
+    max_message_size: u32;
+}
+/**
+ * Parameter for setting default executor configuration for a destination endpoint.
+ */
+export interface SetDefaultExecutorConfigParam {
+    /**
+   * The executor configuration to set as default.
+   */
+    config: ExecutorConfig;
+    /**
+   * The destination endpoint ID.
+   */
+    dst_eid: u32;
+}
+export type UlnStorage = {
+    tag: "Endpoint";
+    values: void;
+} | {
+    tag: "Treasury";
+    values: void;
+} | {
+    tag: "DefaultExecutorConfigs";
+    values: readonly [u32];
+} | {
+    tag: "DefaultSendUlnConfigs";
+    values: readonly [u32];
+} | {
+    tag: "DefaultReceiveUlnConfigs";
+    values: readonly [u32];
+} | {
+    tag: "OAppSendUlnConfigs";
+    values: readonly [string, u32];
+} | {
+    tag: "OAppReceiveUlnConfigs";
+    values: readonly [string, u32];
+} | {
+    tag: "OAppExecutorConfigs";
+    values: readonly [string, u32];
+} | {
+    tag: "Confirmations";
+    values: readonly [string, Buffer, Buffer];
+};
+export declare const Uln302Error: {
+    1: {
+        message: string;
+    };
+    2: {
+        message: string;
+    };
+    3: {
+        message: string;
+    };
+    4: {
+        message: string;
+    };
+    5: {
+        message: string;
+    };
+    6: {
+        message: string;
+    };
+    7: {
+        message: string;
+    };
+    8: {
+        message: string;
+    };
+    9: {
+        message: string;
+    };
+    10: {
+        message: string;
+    };
+    11: {
+        message: string;
+    };
+    12: {
+        message: string;
+    };
+    13: {
+        message: string;
+    };
+    14: {
+        message: string;
+    };
+    15: {
+        message: string;
+    };
+    16: {
+        message: string;
+    };
+    17: {
+        message: string;
+    };
+    18: {
+        message: string;
+    };
+    19: {
+        message: string;
+    };
+    20: {
+        message: string;
+    };
+    21: {
+        message: string;
+    };
+    22: {
+        message: string;
+    };
+    23: {
+        message: string;
+    };
+    24: {
+        message: string;
+    };
+};
+/**
+ * Parameters for sending a cross-chain message.
+ */
+export interface MessagingParams {
+    /**
+   * Destination endpoint ID (chain identifier).
+   */
+    dst_eid: u32;
+    /**
+   * The message payload to send.
+   */
+    message: Buffer;
+    /**
+   * Encoded executor and DVN options.
+   */
+    options: Buffer;
+    /**
+   * Whether to pay fees in ZRO token instead of native token.
+   */
+    pay_in_zro: boolean;
+    /**
+   * Receiver address on the destination chain (32 bytes).
+   */
+    receiver: Buffer;
+}
+/**
+ * Source message information identifying where a cross-chain message came from.
+ */
+export interface Origin {
+    /**
+   * Nonce for this pathway.
+   */
+    nonce: u64;
+    /**
+   * Sender address on the source chain (32 bytes).
+   */
+    sender: Buffer;
+    /**
+   * Source endpoint ID (chain identifier).
+   */
+    src_eid: u32;
+}
+/**
+ * Fee structure for cross-chain messaging.
+ */
+export interface MessagingFee {
+    /**
+   * Fee paid in native token (XLM).
+   */
+    native_fee: i128;
+    /**
+   * Fee paid in ZRO token (LayerZero token).
+   */
+    zro_fee: i128;
+}
+/**
+ * Receipt returned after successfully sending a cross-chain message.
+ */
+export interface MessagingReceipt {
+    /**
+   * The fees charged for sending the message.
+   */
+    fee: MessagingFee;
+    /**
+   * Globally unique identifier for the message.
+   */
+    guid: Buffer;
+    /**
+   * The outbound nonce for this pathway.
+   */
+    nonce: u64;
+}
+/**
+ * Type of message library indicating supported operations.
+ */
+export type MessageLibType = {
+    tag: "Send";
+    values: void;
+} | {
+    tag: "Receive";
+    values: void;
+} | {
+    tag: "SendAndReceive";
+    values: void;
+};
+/**
+ * Version information for a message library.
+ *
+ * Note: `minor` and `endpoint_version` use `u32` instead of `u8` because Stellar does not
+ * support `u8` types in contract interface functions.
+ */
+export interface MessageLibVersion {
+    /**
+   * Endpoint version (should not exceed u8::MAX = 255).
+   */
+    endpoint_version: u32;
+    /**
+   * Major version number.
+   */
+    major: u64;
+    /**
+   * Minor version number (should not exceed u8::MAX = 255).
+   */
+    minor: u32;
+}
+/**
+ * Timeout configuration for receive library transitions.
+ */
+export interface Timeout {
+    /**
+   * Unix timestamp when the timeout expires.
+   */
+    expiry: u64;
+    /**
+   * The new library address to transition to.
+   */
+    lib: string;
+}
+/**
+ * Parameters for setting message library configuration.
+ */
+export interface SetConfigParam {
+    /**
+   * XDR-encoded configuration data.
+   */
+    config: Buffer;
+    /**
+   * The type of configuration (e.g., executor, ULN).
+   */
+    config_type: u32;
+    /**
+   * The endpoint ID this config applies to.
+   */
+    eid: u32;
+}
+/**
+ * Resolved library information with default status.
+ */
+export interface ResolvedLibrary {
+    /**
+   * Whether this is the default library (true) or OApp-specific (false).
+   */
+    is_default: boolean;
+    /**
+   * The resolved library address.
+   */
+    lib: string;
+}
+/**
+ * Outbound packet containing all information for cross-chain transmission.
+ */
+export interface OutboundPacket {
+    /**
+   * Destination endpoint ID.
+   */
+    dst_eid: u32;
+    /**
+   * Globally unique identifier for this message.
+   */
+    guid: Buffer;
+    /**
+   * The message payload.
+   */
+    message: Buffer;
+    /**
+   * Outbound nonce for this pathway.
+   */
+    nonce: u64;
+    /**
+   * Receiver address on destination chain (32 bytes).
+   */
+    receiver: Buffer;
+    /**
+   * Sender address on source chain.
+   */
+    sender: string;
+    /**
+   * Source endpoint ID.
+   */
+    src_eid: u32;
+}
+/**
+ * A fee recipient with the amount to be paid.
+ */
+export interface FeeRecipient {
+    /**
+   * Address to receive the fee.
+   */
+    address: string;
+    /**
+   * Amount of fee to pay.
+   */
+    amount: i128;
+}
+/**
+ * Result of send operation containing fees and encoded packet.
+ */
+export interface FeesAndPacket {
+    /**
+   * The encoded packet ready for transmission.
+   */
+    encoded_packet: Buffer;
+    /**
+   * List of native token fee recipients (executor, DVNs, treasury).
+   */
+    native_fee_recipients: Array<FeeRecipient>;
+    /**
+   * List of ZRO token fee recipients (treasury).
+   */
+    zro_fee_recipients: Array<FeeRecipient>;
+}
+export declare const PacketCodecV1Error: {
+    11001: {
+        message: string;
+    };
+    11002: {
+        message: string;
+    };
+};
+export declare const WorkerOptionsError: {
+    11101: {
+        message: string;
+    };
+    11102: {
+        message: string;
+    };
+    11103: {
+        message: string;
+    };
+    11104: {
+        message: string;
+    };
+    11105: {
+        message: string;
+    };
+    11106: {
+        message: string;
+    };
+    11107: {
+        message: string;
+    };
+    11108: {
+        message: string;
+    };
+    11109: {
+        message: string;
+    };
+};
+export declare const BufferReaderError: {
+    10000: {
+        message: string;
+    };
+    10001: {
+        message: string;
+    };
+};
+export declare const BufferWriterError: {
+    10100: {
+        message: string;
+    };
+};
+export declare const TtlError: {
+    10200: {
+        message: string;
+    };
+    10201: {
+        message: string;
+    };
+    10202: {
+        message: string;
+    };
+};
+export declare const OwnableError: {
+    10300: {
+        message: string;
+    };
+    10301: {
+        message: string;
+    };
+};
+export declare const BytesExtError: {
+    10400: {
+        message: string;
+    };
+};
+export type DefaultOwnableStorage = {
+    tag: "Owner";
+    values: void;
+};
+/**
+ * A pair of TTL values: threshold (when to trigger extension) and extend_to (target TTL).
+ */
+export interface TtlConfig {
+    /**
+   * Target TTL after extension (in ledgers).
+   */
+    extend_to: u32;
+    /**
+   * TTL threshold that triggers extension (in ledgers).
+   */
+    threshold: u32;
+}
+export type TtlConfigData = {
+    tag: "Frozen";
+    values: void;
+} | {
+    tag: "Instance";
+    values: void;
+} | {
+    tag: "Persistent";
+    values: void;
+} | {
+    tag: "Temporary";
+    values: void;
+};
+export interface Client {
+    /**
+     * Construct and simulate a verify transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Called by a DVN to verify a message with a specific number of block confirmations.
+     *
+     * Stores the DVN's verification attestation which will be checked during commit_verification.
+     */
+    verify: ({ dvn, packet_header, payload_hash, confirmations }: {
+        dvn: string;
+        packet_header: Buffer;
+        payload_hash: Buffer;
+        confirmations: u64;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a commit_verification transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Permissonless to commit a verified message to the endpoint after sufficient DVN verification.
+     *
+     * Validates the packet header and checks that enough DVNs have verified the message
+     * (all required DVNs + optional DVN threshold). Once verified, cleans up DVN confirmation
+     * storage and calls the endpoint to mark the message as verified and executable.
+     */
+    commit_verification: ({ packet_header, payload_hash }: {
+        packet_header: Buffer;
+        payload_hash: Buffer;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_default_receive_uln_configs transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Sets default receive ULN configurations for multiple source endpoints.
+     *
+     * Validates each config and stores it as the default for the specified source EID.
+     */
+    set_default_receive_uln_configs: ({ params }: {
+        params: Array<SetDefaultUlnConfigParam>;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a confirmations transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns the number of block confirmations a DVN has submitted for a specific message.
+     */
+    confirmations: ({ dvn, header_hash, payload_hash }: {
+        dvn: string;
+        header_hash: Buffer;
+        payload_hash: Buffer;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<Option<u64>>>;
+    /**
+     * Construct and simulate a verifiable transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Checks if a message has been sufficiently verified by DVNs and is ready to commit.
+     */
+    verifiable: ({ packet_header, payload_hash }: {
+        packet_header: Buffer;
+        payload_hash: Buffer;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<boolean>>;
+    /**
+     * Construct and simulate a default_receive_uln_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns the default receive ULN configuration for a source endpoint.
+     */
+    default_receive_uln_config: ({ src_eid }: {
+        src_eid: u32;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<Option<UlnConfig>>>;
+    /**
+     * Construct and simulate a oapp_receive_uln_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns the OApp-specific receive ULN configuration override for a source endpoint.
+     */
+    oapp_receive_uln_config: ({ receiver, src_eid }: {
+        receiver: string;
+        src_eid: u32;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<Option<OAppUlnConfig>>>;
+    /**
+     * Construct and simulate a effective_receive_uln_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns the effective receive ULN configuration by merging OApp config with defaults.
+     */
+    effective_receive_uln_config: ({ receiver, src_eid }: {
+        receiver: string;
+        src_eid: u32;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<UlnConfig>>;
+    /**
+     * Construct and simulate a set_default_executor_configs transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Sets default executor configurations for multiple destination endpoints.
+     */
+    set_default_executor_configs: ({ params }: {
+        params: Array<SetDefaultExecutorConfigParam>;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_default_send_uln_configs transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Sets default send ULN configurations for multiple destination endpoints.
+     */
+    set_default_send_uln_configs: ({ params }: {
+        params: Array<SetDefaultUlnConfigParam>;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a treasury transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns the treasury address for fee collection.
+     */
+    treasury: (txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<string>>;
+    /**
+     * Construct and simulate a default_executor_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns the default executor configuration for a destination endpoint.
+     */
+    default_executor_config: ({ dst_eid }: {
+        dst_eid: u32;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<Option<ExecutorConfig>>>;
+    /**
+     * Construct and simulate a oapp_executor_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns the OApp-specific executor configuration for a destination endpoint.
+     */
+    oapp_executor_config: ({ sender, dst_eid }: {
+        sender: string;
+        dst_eid: u32;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<Option<OAppExecutorConfig>>>;
+    /**
+     * Construct and simulate a effective_executor_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns the effective executor configuration by merging OApp config with default.
+     */
+    effective_executor_config: ({ sender, dst_eid }: {
+        sender: string;
+        dst_eid: u32;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<ExecutorConfig>>;
+    /**
+     * Construct and simulate a default_send_uln_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns the default send ULN configuration for a destination endpoint.
+     */
+    default_send_uln_config: ({ dst_eid }: {
+        dst_eid: u32;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<Option<UlnConfig>>>;
+    /**
+     * Construct and simulate a oapp_send_uln_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns the OApp-specific send ULN configuration for a destination endpoint.
+     */
+    oapp_send_uln_config: ({ sender, dst_eid }: {
+        sender: string;
+        dst_eid: u32;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<Option<OAppUlnConfig>>>;
+    /**
+     * Construct and simulate a effective_send_uln_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns the effective send ULN configuration by merging OApp config with default.
+     */
+    effective_send_uln_config: ({ sender, dst_eid }: {
+        sender: string;
+        dst_eid: u32;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<UlnConfig>>;
+    /**
+     * Construct and simulate a quote transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Quotes the total fee for sending a cross-chain message.
+     *
+     * Calculates fees from: executor (message execution), DVNs (verification), and treasury (protocol fee).
+     */
+    quote: ({ packet, options, pay_in_zro }: {
+        packet: OutboundPacket;
+        options: Buffer;
+        pay_in_zro: boolean;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<MessagingFee>>;
+    /**
+     * Construct and simulate a send transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Sends a cross-chain message and returns fee recipients for payment.
+     *
+     * Assigns executor and DVNs, calculates fees, and encodes the packet for transmission.
+     */
+    send: ({ packet, options, pay_in_zro }: {
+        packet: OutboundPacket;
+        options: Buffer;
+        pay_in_zro: boolean;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<FeesAndPacket>>;
+    /**
+     * Construct and simulate a set_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Sets OApp-specific configuration parameters for the message library.
+     *
+     * Called by the endpoint on behalf of the OApp to configure executor and ULN settings.
+     * Supports three config types: EXECUTOR, SEND_ULN, and RECEIVE_ULN.
+     */
+    set_config: ({ oapp, params }: {
+        oapp: string;
+        params: Array<SetConfigParam>;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a get_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns the XDR-encoded effective configuration bytes.
+     */
+    get_config: ({ eid, oapp, config_type }: {
+        eid: u32;
+        oapp: string;
+        config_type: u32;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<Buffer>>;
+    /**
+     * Construct and simulate a is_supported_eid transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns true if the message library has default send and receive ULN configurations for the endpoint ID.
+     */
+    is_supported_eid: ({ eid }: {
+        eid: u32;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<boolean>>;
+    /**
+     * Construct and simulate a version transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns the version of the message library.
+     */
+    version: (txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<MessageLibVersion>>;
+    /**
+     * Construct and simulate a message_lib_type transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns the type of the message library.
+     */
+    message_lib_type: (txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<MessageLibType>>;
+    /**
+     * Construct and simulate a endpoint transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     * Returns the LayerZero endpoint contract address.
+     */
+    endpoint: (txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<string>>;
+    /**
+     * Construct and simulate a owner transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    owner: (txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<Option<string>>>;
+    /**
+     * Construct and simulate a transfer_ownership transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    transfer_ownership: ({ new_owner }: {
+        new_owner: string;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a renounce_ownership transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    renounce_ownership: (txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_ttl_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    set_ttl_config: ({ instance, persistent, temporary }: {
+        instance: Option<TtlConfig>;
+        persistent: Option<TtlConfig>;
+        temporary: Option<TtlConfig>;
+    }, txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a ttl_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    ttl_config: (txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<readonly [Option<TtlConfig>, Option<TtlConfig>, Option<TtlConfig>]>>;
+    /**
+     * Construct and simulate a freeze_ttl_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    freeze_ttl_config: (txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a is_ttl_config_frozen transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    is_ttl_config_frozen: (txnOptions?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<boolean>>;
+}
+export declare class Client extends ContractClient {
+    readonly options: ContractClientOptions;
+    static deploy<T = Client>(
+    /** Constructor/Initialization Args for the contract's `__constructor` method */
+    { owner, endpoint, treasury }: {
+        owner: string;
+        endpoint: string;
+        treasury: string;
+    }, 
+    /** Options for initializing a Client as well as for calling a method, with extras specific to deploying. */
+    options: MethodOptions & Omit<ContractClientOptions, "contractId"> & {
+        /** The hash of the Wasm blob, which must already be installed on-chain. */
+        wasmHash: Buffer | string;
+        /** Salt used to generate the contract's ID. Passed through to {@link Operation.createCustomContract}. Default: random. */
+        salt?: Buffer | Uint8Array;
+        /** The format used to decode `wasmHash`, if it's provided as a string. */
+        format?: "hex" | "base64";
+    }): Promise<AssembledTransaction<T>>;
+    constructor(options: ContractClientOptions);
+    readonly fromJSON: {
+        verify: (json: string) => AssembledTransaction<null>;
+        commit_verification: (json: string) => AssembledTransaction<null>;
+        set_default_receive_uln_configs: (json: string) => AssembledTransaction<null>;
+        confirmations: (json: string) => AssembledTransaction<Option<bigint>>;
+        verifiable: (json: string) => AssembledTransaction<boolean>;
+        default_receive_uln_config: (json: string) => AssembledTransaction<Option<UlnConfig>>;
+        oapp_receive_uln_config: (json: string) => AssembledTransaction<Option<OAppUlnConfig>>;
+        effective_receive_uln_config: (json: string) => AssembledTransaction<UlnConfig>;
+        set_default_executor_configs: (json: string) => AssembledTransaction<null>;
+        set_default_send_uln_configs: (json: string) => AssembledTransaction<null>;
+        treasury: (json: string) => AssembledTransaction<string>;
+        default_executor_config: (json: string) => AssembledTransaction<Option<ExecutorConfig>>;
+        oapp_executor_config: (json: string) => AssembledTransaction<Option<OAppExecutorConfig>>;
+        effective_executor_config: (json: string) => AssembledTransaction<ExecutorConfig>;
+        default_send_uln_config: (json: string) => AssembledTransaction<Option<UlnConfig>>;
+        oapp_send_uln_config: (json: string) => AssembledTransaction<Option<OAppUlnConfig>>;
+        effective_send_uln_config: (json: string) => AssembledTransaction<UlnConfig>;
+        quote: (json: string) => AssembledTransaction<MessagingFee>;
+        send: (json: string) => AssembledTransaction<FeesAndPacket>;
+        set_config: (json: string) => AssembledTransaction<null>;
+        get_config: (json: string) => AssembledTransaction<Buffer<ArrayBufferLike>>;
+        is_supported_eid: (json: string) => AssembledTransaction<boolean>;
+        version: (json: string) => AssembledTransaction<MessageLibVersion>;
+        message_lib_type: (json: string) => AssembledTransaction<MessageLibType>;
+        endpoint: (json: string) => AssembledTransaction<string>;
+        owner: (json: string) => AssembledTransaction<Option<string>>;
+        transfer_ownership: (json: string) => AssembledTransaction<null>;
+        renounce_ownership: (json: string) => AssembledTransaction<null>;
+        set_ttl_config: (json: string) => AssembledTransaction<null>;
+        ttl_config: (json: string) => AssembledTransaction<readonly [Option<TtlConfig>, Option<TtlConfig>, Option<TtlConfig>]>;
+        freeze_ttl_config: (json: string) => AssembledTransaction<null>;
+        is_ttl_config_frozen: (json: string) => AssembledTransaction<boolean>;
+    };
+}