@layerzerolabs/protocol-stellar-v2 0.2.18 → 0.2.20

package/sdk/dist/generated/layerzero_view.d.ts

@@ -0,0 +1,1271 @@
+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';
+/**
+ * Embedded WASM bytecode (base64-encoded)
+ * Size: 34031 bytes (33.23 KB)
+ */
+export declare const WASM_BASE64 = "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";
+/**
+ * Pre-computed WASM hash (SHA-256)
+ * Use this when the WASM is already uploaded on-chain
+ */
+export declare const WASM_HASH = "246b8137f2eeccf75191b9fc9862067103af6569599e9bf3df5aa8b8612498dc";
+/**
+ * Get the WASM bytecode as a Buffer
+ * Use this to upload the WASM to the network
+ */
+export declare function getWasmBuffer(): Buffer;
+/**
+ * Errors for LayerZeroView contract.
+ */
+export declare const LayerZeroViewError: {
+    /**
+     * Invalid packet header (dst_eid mismatch).
+     */
+    1: {
+        message: string;
+    };
+};
+export type LayerZeroViewStorage = {
+    tag: "Endpoint";
+    values: void;
+} | {
+    tag: "Uln302";
+    values: void;
+} | {
+    tag: "LocalEid";
+    values: void;
+};
+/**
+ * Represents the execution state of a cross-chain message.
+ *
+ * Used by executors to determine when a message is ready to be delivered.
+ */
+export type ExecutionState = {
+    tag: "NotExecutable";
+    values: void;
+} | {
+    tag: "VerifiedButNotExecutable";
+    values: void;
+} | {
+    tag: "Executable";
+    values: void;
+} | {
+    tag: "Executed";
+    values: void;
+};
+/**
+ * Represents the verification state of a cross-chain message at the ULN level.
+ *
+ * Used by DVNs and executors to track verification progress.
+ */
+export type VerificationState = {
+    tag: "Verifying";
+    values: void;
+} | {
+    tag: "Verifiable";
+    values: void;
+} | {
+    tag: "Verified";
+    values: void;
+} | {
+    tag: "NotInitializable";
+    values: void;
+};
+export declare const EndpointError: {
+    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;
+    };
+    25: {
+        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 {
+    /**
+   * Amount of fee to pay.
+   */
+    amount: i128;
+    /**
+   * The address to send the fee to.
+   */
+    to: string;
+}
+/**
+ * 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>;
+}
+/**
+ * PacketCodecV1Error: 1100-1109
+ */
+export declare const PacketCodecV1Error: {
+    1100: {
+        message: string;
+    };
+    1101: {
+        message: string;
+    };
+};
+/**
+ * WorkerOptionsError: 1110-1119
+ */
+export declare const WorkerOptionsError: {
+    1110: {
+        message: string;
+    };
+    1111: {
+        message: string;
+    };
+    1112: {
+        message: string;
+    };
+    1113: {
+        message: string;
+    };
+    1114: {
+        message: string;
+    };
+    1115: {
+        message: string;
+    };
+    1116: {
+        message: string;
+    };
+    1117: {
+        message: string;
+    };
+    1118: {
+        message: string;
+    };
+};
+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;
+    };
+};
+/**
+ * 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).
+   */
+    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;
+}
+/**
+ * BufferReaderError: 1000-1009
+ */
+export declare const BufferReaderError: {
+    1000: {
+        message: string;
+    };
+    1001: {
+        message: string;
+    };
+};
+/**
+ * BufferWriterError: 1010-1019
+ */
+export declare const BufferWriterError: {
+    1010: {
+        message: string;
+    };
+};
+/**
+ * TtlConfigurableError: 1020-1029
+ */
+export declare const TtlConfigurableError: {
+    1020: {
+        message: string;
+    };
+    1021: {
+        message: string;
+    };
+    1022: {
+        message: string;
+    };
+};
+/**
+ * OwnableError: 1030-1039
+ */
+export declare const OwnableError: {
+    1030: {
+        message: string;
+    };
+    1031: {
+        message: string;
+    };
+    1032: {
+        message: string;
+    };
+    1033: {
+        message: string;
+    };
+    1034: {
+        message: string;
+    };
+    1035: {
+        message: string;
+    };
+};
+/**
+ * BytesExtError: 1040-1049
+ */
+export declare const BytesExtError: {
+    1040: {
+        message: string;
+    };
+};
+/**
+ * UpgradeableError: 1050-1059
+ */
+export declare const UpgradeableError: {
+    1050: {
+        message: string;
+    };
+    1051: {
+        message: string;
+    };
+    1052: {
+        message: string;
+    };
+};
+/**
+ * MultisigError: 1060-1069
+ */
+export declare const MultisigError: {
+    1060: {
+        message: string;
+    };
+    1061: {
+        message: string;
+    };
+    1062: {
+        message: string;
+    };
+    1063: {
+        message: string;
+    };
+    1064: {
+        message: string;
+    };
+    1065: {
+        message: string;
+    };
+    1066: {
+        message: string;
+    };
+    1067: {
+        message: string;
+    };
+};
+export type MultisigStorage = {
+    tag: "Signers";
+    values: void;
+} | {
+    tag: "Threshold";
+    values: void;
+};
+export type OwnableStorage = {
+    tag: "Owner";
+    values: void;
+} | {
+    tag: "PendingOwner";
+    values: void;
+};
+/**
+ * TTL configuration: threshold (when to extend) 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 TtlConfigStorage = {
+    tag: "Frozen";
+    values: void;
+} | {
+    tag: "Instance";
+    values: void;
+} | {
+    tag: "Persistent";
+    values: void;
+};
+export type UpgradeableStorage = {
+    tag: "Frozen";
+    values: void;
+} | {
+    tag: "Migrating";
+    values: void;
+};
+export interface Client {
+    /**
+     * Construct and simulate a authorizer 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.
+     */
+    authorizer: (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 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 endpoint 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 uln302 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 Uln302 address.
+     */
+    uln302: (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 local_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 the local endpoint ID.
+     */
+    local_eid: (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<u32>>;
+    /**
+     * Construct and simulate a initializable 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 messaging path can be initialized for the given origin and receiver.
+     */
+    initializable: ({ origin, receiver }: {
+        origin: Origin;
+        receiver: 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<boolean>>;
+    /**
+     * 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 can be verified at the endpoint.
+     *
+     * Verifies:
+     * 1. Receive library is valid for this receiver and source
+     * 2. Endpoint nonce check passes
+     * 3. Payload hash is not empty
+     */
+    verifiable: ({ origin, receiver, receive_lib, payload_hash }: {
+        origin: Origin;
+        receiver: string;
+        receive_lib: string;
+        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 executable 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 execution state of a message.
+     */
+    executable: ({ origin, receiver }: {
+        origin: Origin;
+        receiver: 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<ExecutionState>>;
+    /**
+     * Construct and simulate a uln_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.
+     * Returns the combined verification state of a message.
+     *
+     * This function checks:
+     * 1. Packet header validity (dst_eid matches local_eid)
+     * 2. Endpoint initializable status
+     * 3. Endpoint verifiable status
+     * 4. ULN verifiable status (DVN confirmations)
+     */
+    uln_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<VerificationState>>;
+    /**
+     * Construct and simulate a set_ttl_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 TTL configs for instance and persistent storage.
+     *
+     * - `None` values remove the corresponding config (disables auto-extension for that type)
+     * - Validates that `threshold <= extend_to <= MAX_TTL`
+     *
+     * # Arguments
+     * - `instance` - TTL config for instance storage
+     * - `persistent` - TTL config for persistent storage
+     *
+     * # Panics
+     * - `TtlConfigFrozen` if configs are frozen
+     * - `InvalidTtlConfig` if validation fails
+     */
+    set_ttl_configs: ({ instance, persistent }: {
+        instance: Option<TtlConfig>;
+        persistent: 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_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.
+     * Returns the current TTL configs as (instance_config, persistent_config).
+     */
+    ttl_configs: (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>]>>;
+    /**
+     * Construct and simulate a freeze_ttl_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.
+     * Permanently freezes TTL configs, preventing any future modifications.
+     *
+     * This is irreversible and provides immutability guarantees to users.
+     * Emits `TtlConfigsFrozen` event.
+     *
+     * # Panics
+     * - `TtlConfigAlreadyFrozen` if already frozen
+     */
+    freeze_ttl_configs: (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_configs_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.
+     * Returns whether TTL configs are frozen.
+     */
+    is_ttl_configs_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>>;
+    /**
+     * Construct and simulate a extend_instance_ttl 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.
+     * Extends the instance TTL.
+     *
+     * # Arguments
+     *
+     * * `threshold` - The threshold to extend the TTL (if current TTL is below this, extend).
+     * * `extend_to` - The TTL to extend to.
+     */
+    extend_instance_ttl: ({ threshold, extend_to }: {
+        threshold: u32;
+        extend_to: 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<null>>;
+    /**
+     * 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.
+     * Returns the current owner address, or None if no owner is set.
+     */
+    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 pending_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.
+     * Returns the pending owner address for 2-step transfer, or None if no transfer is pending.
+     */
+    pending_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.
+     * Transfers ownership immediately to a new address.
+     *
+     * Use with caution - if you transfer to a wrong address, ownership is lost forever.
+     * Consider using `propose_ownership_transfer` instead.
+     *
+     * # Panics
+     * - `OwnerNotSet` if no owner is currently set
+     * - `TransferInProgress` if a 2-step transfer is in progress
+     */
+    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 propose_ownership_transfer 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.
+     * Proposes an ownership transfer to a new address.
+     *
+     * The new owner must call `accept_ownership()` within `ttl` ledgers
+     * to complete the transfer. The pending transfer will automatically expire after.
+     *
+     * # Arguments
+     * - `new_owner` - The proposed new owner
+     * - `ttl` - Number of ledgers the new owner has to accept.
+     * Use `0` to cancel a pending transfer (new_owner must match pending).
+     *
+     * # Panics
+     * - `OwnerNotSet` if no owner is currently set
+     * - `NoPendingTransfer` when cancelling and no pending transfer exists
+     * - `InvalidTtl` if ttl exceeds max TTL
+     * - `InvalidPendingOwner` when cancelling with wrong new_owner address
+     */
+    propose_ownership_transfer: ({ new_owner, ttl }: {
+        new_owner: string;
+        ttl: 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<null>>;
+    /**
+     * Construct and simulate a accept_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.
+     * Accepts a pending 2-step ownership transfer.
+     *
+     * Must be called by the pending owner before the TTL expires.
+     *
+     * # Panics
+     * - `NoPendingTransfer` if there is no pending transfer (or it expired)
+     */
+    accept_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 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.
+     * Permanently renounces ownership.
+     *
+     * # Panics
+     * - `OwnerNotSet` if no owner is currently set
+     * - `TransferInProgress` if a 2-step transfer is in progress (cancel it first)
+     */
+    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 upgrade 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.
+     * The type of data required for migration.
+     * Upgrades the contract to new WASM bytecode.
+     * Sets a migration flag that must be cleared by calling `migrate`.
+     */
+    upgrade: ({ new_wasm_hash }: {
+        new_wasm_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 migrate 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.
+     * Runs migration logic after an upgrade.
+     * Can only be called when the migration flag is set by a previous `upgrade` call.
+     */
+    migrate: ({ migration_data }: {
+        migration_data: 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 freeze 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.
+     * Permanently freezes the contract, preventing any future upgrades.
+     * This action is irreversible.
+     */
+    freeze: (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_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.
+     * Returns whether the contract is frozen (upgrades disabled).
+     */
+    is_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, uln302 }: {
+        owner: string;
+        endpoint: string;
+        uln302: 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: {
+        authorizer: (json: string) => AssembledTransaction<string>;
+        endpoint: (json: string) => AssembledTransaction<string>;
+        uln302: (json: string) => AssembledTransaction<string>;
+        local_eid: (json: string) => AssembledTransaction<number>;
+        initializable: (json: string) => AssembledTransaction<boolean>;
+        verifiable: (json: string) => AssembledTransaction<boolean>;
+        executable: (json: string) => AssembledTransaction<ExecutionState>;
+        uln_verifiable: (json: string) => AssembledTransaction<VerificationState>;
+        set_ttl_configs: (json: string) => AssembledTransaction<null>;
+        ttl_configs: (json: string) => AssembledTransaction<readonly [Option<TtlConfig>, Option<TtlConfig>]>;
+        freeze_ttl_configs: (json: string) => AssembledTransaction<null>;
+        is_ttl_configs_frozen: (json: string) => AssembledTransaction<boolean>;
+        extend_instance_ttl: (json: string) => AssembledTransaction<null>;
+        owner: (json: string) => AssembledTransaction<Option<string>>;
+        pending_owner: (json: string) => AssembledTransaction<Option<string>>;
+        transfer_ownership: (json: string) => AssembledTransaction<null>;
+        propose_ownership_transfer: (json: string) => AssembledTransaction<null>;
+        accept_ownership: (json: string) => AssembledTransaction<null>;
+        renounce_ownership: (json: string) => AssembledTransaction<null>;
+        upgrade: (json: string) => AssembledTransaction<null>;
+        migrate: (json: string) => AssembledTransaction<null>;
+        freeze: (json: string) => AssembledTransaction<null>;
+        is_frozen: (json: string) => AssembledTransaction<boolean>;
+    };
+}