@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.18

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

@@ -85,6 +85,9 @@ export declare const EndpointError: {
     24: {
         message: string;
     };
+    25: {
+        message: string;
+    };
 };
 /**
  * Parameters for sending a cross-chain message.
@@ -297,6 +300,9 @@ export interface FeesAndPacket {
    */
     zro_fee_recipients: Array<FeeRecipient>;
 }
+/**
+ * OAppError: 2000-2099
+ */
 export declare const OAppError: {
     2000: {
         message: string;
@@ -327,14 +333,20 @@ export type OAppOptionsType3Storage = {
     tag: "EnforcedOptions";
     values: readonly [u32, u32];
 };
+/**
+ * OFTError: 3000-3099
+ */
 export declare const OFTError: {
-    2100: {
+    3000: {
         message: string;
     };
-    2101: {
+    3001: {
         message: string;
     };
-    2102: {
+    3002: {
+        message: string;
+    };
+    3003: {
         message: string;
     };
 };
@@ -419,35 +431,78 @@ export type OFTStorage = {
  * Parameters for sending OFT tokens cross-chain
  */
 export interface SendParam {
+    /**
+   * The amount to send in local decimals
+   */
     amount_ld: i128;
+    /**
+   * Compose message to execute on the destination (Optional)
+   */
     compose_msg: Buffer;
+    /**
+   * The destination endpoint ID
+   */
     dst_eid: u32;
+    /**
+   * Additional options for the LayerZero message (Optional)
+   */
     extra_options: Buffer;
+    /**
+   * The minimum amount to receive in local decimals (slippage protection)
+   */
     min_amount_ld: i128;
+    /**
+   * OFT command for custom behavior (Optional)
+   */
     oft_cmd: Buffer;
+    /**
+   * The recipient address on the destination chain (32 bytes)
+   */
     to: Buffer;
 }
 /**
  * Transfer limits for OFT operations
  */
 export interface OFTLimit {
+    /**
+   * The maximum amount to send in local decimals
+   */
     max_amount_ld: i128;
+    /**
+   * The minimum amount to send in local decimals
+   */
     min_amount_ld: i128;
 }
 /**
  * Receipt containing amounts sent and received in an OFT transfer
  */
 export interface OFTReceipt {
+    /**
+   * The amount received in local decimals on the remote
+   */
     amount_received_ld: i128;
+    /**
+   * The amount sent in local decimals
+   */
     amount_sent_ld: i128;
 }
 /**
  * Details about fees charged in an OFT operation
  */
 export interface OFTFeeDetail {
+    /**
+   * The description of the fee
+   */
     description: Buffer;
+    /**
+   * The amount of the fee in local decimals. Positive values represent fees charged,
+   * while negative values represent rewards given.
+   */
     fee_amount_ld: i128;
 }
+/**
+ * BufferReaderError: 1000-1009
+ */
 export declare const BufferReaderError: {
     1000: {
         message: string;
@@ -456,39 +511,90 @@ export declare const BufferReaderError: {
         message: string;
     };
 };
+/**
+ * BufferWriterError: 1010-1019
+ */
 export declare const BufferWriterError: {
-    1100: {
+    1010: {
         message: string;
     };
 };
+/**
+ * TtlConfigurableError: 1020-1029
+ */
 export declare const TtlConfigurableError: {
-    1200: {
+    1020: {
         message: string;
     };
-    1201: {
+    1021: {
         message: string;
     };
-    1202: {
+    1022: {
         message: string;
     };
 };
+/**
+ * OwnableError: 1030-1039
+ */
 export declare const OwnableError: {
-    1300: {
+    1030: {
         message: string;
     };
-    1301: {
+    1031: {
         message: string;
     };
 };
+/**
+ * BytesExtError: 1040-1049
+ */
 export declare const BytesExtError: {
-    1400: {
+    1040: {
         message: string;
     };
 };
+/**
+ * UpgradeableError: 1050-1059
+ */
 export declare const UpgradeableError: {
-    1500: {
+    1050: {
+        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";
@@ -523,42 +629,9 @@ export type UpgradeableStorage = {
 };
 export interface Client {
     /**
-     * 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.
-     * * `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 lz_receive 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.
+     * 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.
      */
-    lz_receive: ({ executor, origin, guid, message, extra_data, value }: {
-        executor: string;
-        origin: Origin;
-        guid: Buffer;
-        message: Buffer;
-        extra_data: Buffer;
-        value: i128;
-    }, txnOptions?: {
+    authorizer: (txnOptions?: {
         /**
          * The fee to pay for the transaction. Default: BASE_FEE
          */
@@ -571,7 +644,7 @@ export interface Client {
          * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
          */
         simulate?: boolean;
-    }) => Promise<AssembledTransaction<null>>;
+    }) => Promise<AssembledTransaction<string>>;
     /**
      * Construct and simulate a mode 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 mode of operation for this OFT (LockUnlock or MintBurn)
@@ -1062,6 +1135,14 @@ export interface Client {
     }) => Promise<AssembledTransaction<i128>>;
     /**
      * Construct and simulate a enforced_options 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.
+     * Retrieves the enforced options for a given endpoint and message type.
+     *
+     * # Arguments
+     * * `eid` - The endpoint ID
+     * * `msg_type` - The OApp message type
+     *
+     * # Returns
+     * The enforced options for the given endpoint and message type
      */
     enforced_options: ({ eid, msg_type }: {
         eid: u32;
@@ -1082,6 +1163,16 @@ export interface Client {
     }) => Promise<AssembledTransaction<Buffer>>;
     /**
      * Construct and simulate a set_enforced_options 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 the enforced options for specific endpoint and message type combinations.
+     *
+     * Only the `authorizer` of the OApp can call this function.
+     * Provides a way for the OApp to enforce things like paying for PreCrime, AND/OR minimum dst lzReceive gas amounts etc.
+     * These enforced options can vary as the potential options/execution on the remote may differ as per the msg_type.
+     * e.g. Amount of lzReceive() gas necessary to deliver a lzCompose() message adds overhead you don't want to pay
+     * if you are only making a standard LayerZero message ie. lzReceive() WITHOUT sendCompose().
+     *
+     * # Arguments
+     * * `options` - A vector of EnforcedOptionParam structures specifying enforced options
      */
     set_enforced_options: ({ options }: {
         options: Array<EnforcedOptionParam>;
@@ -1101,6 +1192,20 @@ export interface Client {
     }) => Promise<AssembledTransaction<null>>;
     /**
      * Construct and simulate a combine_options 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.
+     * Combines options for a given endpoint and message type.
+     *
+     * If there is an enforced lzReceive option:
+     * - {gas_limit: 200k, value: 1 XLM} AND a caller supplies a lzReceive option: {gas_limit: 100k, value: 0.5 XLM}
+     * - The resulting options will be {gas_limit: 300k, value: 1.5 XLM} when the message is executed on the remote lz_receive() function.
+     * The presence of duplicated options is handled off-chain in the verifier/executor.
+     *
+     * # Arguments
+     * * `eid` - The endpoint ID
+     * * `msg_type` - The OApp message type
+     * * `extra_options` - Additional options passed by the caller
+     *
+     * # Returns
+     * The combination of caller specified options AND enforced options
      */
     combine_options: ({ eid, msg_type, extra_options }: {
         eid: u32;
@@ -1148,12 +1253,19 @@ export interface Client {
     }) => Promise<AssembledTransaction<boolean>>;
     /**
      * Construct and simulate a next_nonce 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 next expected nonce for ordered message delivery.
-     * 0 means there is NO nonce ordered enforcement.
+     * Retrieves the next nonce for a given source endpoint and sender address.
+     *
+     * The path nonce starts from 1. If 0 is returned it means that there is NO nonce ordered enforcement.
+     * This is required by the off-chain executor to determine if the OApp expects message execution to be ordered.
+     * This is also enforced by the OApp.
+     * By default this is NOT enabled, i.e. next_nonce is hardcoded to return 0.
      *
      * # Arguments
      * * `src_eid` - The source endpoint ID
      * * `sender` - The sender OApp address
+     *
+     * # Returns
+     * The next nonce
      */
     next_nonce: ({ src_eid, sender }: {
         src_eid: u32;
@@ -1172,6 +1284,45 @@ export interface Client {
          */
         simulate?: boolean;
     }) => Promise<AssembledTransaction<u64>>;
+    /**
+     * Construct and simulate a lz_receive 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.
+     * Entry point for receiving messages or packets from the LayerZero endpoint.
+     *
+     * The default implementation calls `clear_payload_and_transfer` to validate the message
+     * and clear it from the endpoint, then delegates to `__lz_receive` for application logic.
+     *
+     * # Arguments
+     * * `executor` - The address of the executor for the received message
+     * * `origin` - The origin information containing the source endpoint and sender address:
+     * - `src_eid`: The source chain endpoint ID
+     * - `sender`: The sender address on the source chain
+     * - `nonce`: The nonce of the message
+     * * `guid` - The unique identifier for the received LayerZero message
+     * * `message` - The payload of the received message
+     * * `extra_data` - Additional arbitrary data provided by the corresponding executor
+     * * `value` - The native token value sent with the message
+     */
+    lz_receive: ({ executor, origin, guid, message, extra_data, value }: {
+        executor: string;
+        origin: Origin;
+        guid: Buffer;
+        message: Buffer;
+        extra_data: Buffer;
+        value: i128;
+    }, 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_compose_msg_sender 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.
      * Indicates whether an address is an approved composeMsg sender to the Endpoint.
@@ -1211,8 +1362,8 @@ export interface Client {
      *
      * # Returns
      * A tuple containing:
-     * - `sender_version`: The version of the OAppSender implementation
-     * - `receiver_version`: The version of the OAppReceiver implementation
+     * - `sender_version`: The version of the OAppSender
+     * - `receiver_version`: The version of the OAppReceiver
      */
     oapp_version: (txnOptions?: {
         /**
@@ -1230,10 +1381,10 @@ export interface Client {
     }) => Promise<AssembledTransaction<readonly [u64, u64]>>;
     /**
      * 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.
-     * Retrieves the LayerZero endpoint associated with the OApp.
+     * Retrieves the LayerZero endpoint address associated with the OApp.
      *
      * # Returns
-     * The LayerZero endpoint client
+     * The LayerZero endpoint address
      */
     endpoint: (txnOptions?: {
         /**
@@ -1415,6 +1566,32 @@ export interface Client {
          */
         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.
@@ -1495,8 +1672,7 @@ export declare class Client extends ContractClient {
     }): Promise<AssembledTransaction<T>>;
     constructor(options: ContractClientOptions);
     readonly fromJSON: {
-        extend_instance_ttl: (json: string) => AssembledTransaction<null>;
-        lz_receive: (json: string) => AssembledTransaction<null>;
+        authorizer: (json: string) => AssembledTransaction<string>;
         mode: (json: string) => AssembledTransaction<OFTMode>;
         quote_oft: (json: string) => AssembledTransaction<readonly [OFTLimit, OFTFeeDetail[], OFTReceipt]>;
         quote_send: (json: string) => AssembledTransaction<MessagingFee>;
@@ -1527,6 +1703,7 @@ export declare class Client extends ContractClient {
         combine_options: (json: string) => AssembledTransaction<Buffer<ArrayBufferLike>>;
         allow_initialize_path: (json: string) => AssembledTransaction<boolean>;
         next_nonce: (json: string) => AssembledTransaction<bigint>;
+        lz_receive: (json: string) => AssembledTransaction<null>;
         is_compose_msg_sender: (json: string) => AssembledTransaction<boolean>;
         oapp_version: (json: string) => AssembledTransaction<readonly [bigint, bigint]>;
         endpoint: (json: string) => AssembledTransaction<string>;
@@ -1537,6 +1714,7 @@ export declare class Client extends ContractClient {
         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>>;
         transfer_ownership: (json: string) => AssembledTransaction<null>;
         renounce_ownership: (json: string) => AssembledTransaction<null>;