@aptos-labs/ts-sdk 1.29.1 → 1.31.0

package/src/transactions/instances/multiAgentTransaction.ts

@@ -9,7 +9,12 @@ import { AccountAddress } from "../../core";
 import { RawTransaction } from "./rawTransaction";
 
 /**
- * Representation of a Raw Transaction that can serialized and deserialized
+ * Represents a multi-agent transaction that can be serialized and deserialized.
+ * This transaction includes a raw transaction, optional fee payer address, and multiple secondary signer addresses.
+ *
+ * @param rawTransaction The raw transaction to be executed.
+ * @param secondarySignerAddresses An array of secondary signer addresses involved in the transaction.
+ * @param feePayerAddress An optional account address that sponsors the transaction's gas fees.
  */
 export class MultiAgentTransaction extends Serializable {
   public rawTransaction: RawTransaction;
@@ -19,14 +24,12 @@ export class MultiAgentTransaction extends Serializable {
   public secondarySignerAddresses: AccountAddress[];
 
   /**
-   * SimpleTransaction represents a simple transaction type of a single signer that
-   * can be submitted to Aptos chain for execution.
+   * Represents a MultiAgentTransaction that can be submitted to the Aptos chain for execution.
+   * This class encapsulates the raw transaction data, the secondary signer addresses, and an optional fee payer address.
    *
-   * SimpleTransaction metadata contains the Raw Transaction and an optional
-   * sponsor Account Address to pay the gas fees.
-   *
-   * @param rawTransaction The Raw Tranasaction
-   * @param feePayerAddress The sponsor Account Address
+   * @param rawTransaction The raw transaction data.
+   * @param secondarySignerAddresses An array of secondary signer addresses.
+   * @param feePayerAddress An optional account address that sponsors the gas fees.
    */
   constructor(
     rawTransaction: RawTransaction,
@@ -39,6 +42,12 @@ export class MultiAgentTransaction extends Serializable {
     this.secondarySignerAddresses = secondarySignerAddresses;
   }
 
+  /**
+   * Serializes the transaction data, including the raw transaction, secondary signer addresses, and fee payer address.
+   * This function is essential for preparing the transaction for transmission or storage in a serialized format.
+   *
+   * @param serializer - The serializer instance used to serialize the transaction data.
+   */
   serialize(serializer: Serializer): void {
     this.rawTransaction.serialize(serializer);
 
@@ -52,14 +61,21 @@ export class MultiAgentTransaction extends Serializable {
     }
   }
 
+  /**
+   * Deserializes a MultiAgentTransaction from the provided deserializer.
+   * This function allows you to reconstruct a MultiAgentTransaction object from its serialized form, including any secondary
+   * signer addresses and the fee payer address if present.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   */
   static deserialize(deserializer: Deserializer): MultiAgentTransaction {
     const rawTransaction = RawTransaction.deserialize(deserializer);
 
     const secondarySignerAddresses = deserializer.deserializeVector(AccountAddress);
 
-    const feepayerPresent = deserializer.deserializeBool();
+    const feePayerPresent = deserializer.deserializeBool();
     let feePayerAddress;
-    if (feepayerPresent) {
+    if (feePayerPresent) {
       feePayerAddress = AccountAddress.deserialize(deserializer);
     }
 

package/src/transactions/instances/rawTransaction.ts

@@ -11,7 +11,9 @@ import { TransactionPayload } from "./transactionPayload";
 import { TransactionVariants } from "../../types";
 
 /**
- * Representation of a Raw Transaction that can serialized and deserialized
+ * Represents a raw transaction that can be serialized and deserialized.
+ * Raw transactions contain the metadata and payloads that can be submitted to the Aptos chain for execution.
+ * They must be signed before the Aptos chain can execute them.
  */
 export class RawTransaction extends Serializable {
   public readonly sender: AccountAddress;
@@ -62,6 +64,13 @@ export class RawTransaction extends Serializable {
     this.chain_id = chain_id;
   }
 
+  /**
+   * Serializes the transaction data, including the fee payer transaction type, raw transaction, secondary signer addresses,
+   * and fee payer address.
+   * This function is essential for preparing the transaction for transmission or storage in a serialized format.
+   *
+   * @param serializer - The serializer instance used to serialize the transaction data.
+   */
   serialize(serializer: Serializer): void {
     this.sender.serialize(serializer);
     serializer.serializeU64(this.sequence_number);
@@ -72,6 +81,12 @@ export class RawTransaction extends Serializable {
     this.chain_id.serialize(serializer);
   }
 
+  /**
+   * Deserialize a Raw Transaction With Data.
+   * This function retrieves the appropriate raw transaction based on the variant index provided by the deserializer.
+   *
+   * @param deserializer - An instance of the Deserializer used to read the serialized data.
+   */
   static deserialize(deserializer: Deserializer): RawTransaction {
     const sender = AccountAddress.deserialize(deserializer);
     const sequence_number = deserializer.deserializeU64();
@@ -93,7 +108,9 @@ export class RawTransaction extends Serializable {
 }
 
 /**
- * Representation of a Raw Transaction With Data that can serialized and deserialized
+ * Represents a raw transaction with associated data that can be serialized and deserialized.
+ *
+ * @extends Serializable
  */
 export abstract class RawTransactionWithData extends Serializable {
   /**
@@ -119,7 +136,9 @@ export abstract class RawTransactionWithData extends Serializable {
 }
 
 /**
- * Representation of a Multi Agent Transaction that can serialized and deserialized
+ * Represents a multi-agent transaction that can be serialized and deserialized.
+ *
+ * @extends RawTransactionWithData
  */
 export class MultiAgentRawTransaction extends RawTransactionWithData {
   /**
@@ -144,6 +163,14 @@ export class MultiAgentRawTransaction extends RawTransactionWithData {
     serializer.serializeVector(this.secondary_signer_addresses);
   }
 
+  /**
+   * Deserializes a Fee Payer Raw Transaction from the provided deserializer.
+   * This function allows you to reconstruct a Fee Payer Raw Transaction object, which includes the raw transaction data,
+   * secondary signer addresses, and the fee payer address.
+   *
+   * @param deserializer - The deserializer used to read the raw transaction data.
+   * @returns A FeePayerRawTransaction object constructed from the deserialized data.
+   */
   static load(deserializer: Deserializer): MultiAgentRawTransaction {
     const rawTxn = RawTransaction.deserialize(deserializer);
     const secondarySignerAddresses = deserializer.deserializeVector(AccountAddress);
@@ -153,7 +180,7 @@ export class MultiAgentRawTransaction extends RawTransactionWithData {
 }
 
 /**
- * Representation of a Fee Payer Transaction that can serialized and deserialized
+ * Represents a Fee Payer Transaction that can be serialized and deserialized.
  */
 export class FeePayerRawTransaction extends RawTransactionWithData {
   /**

package/src/transactions/instances/rotationProofChallenge.ts

@@ -8,8 +8,7 @@ import { PublicKey } from "../../core/crypto";
 import { MoveString, MoveVector, U64, U8 } from "../../bcs";
 
 /**
- * Representation of the challenge which is needed to sign by owner of the account
- * to rotate the authentication key.
+ * Represents a challenge required for the account owner to sign in order to rotate the authentication key.
  */
 export class RotationProofChallenge extends Serializable {
   // Resource account address
@@ -33,6 +32,16 @@ export class RotationProofChallenge extends Serializable {
   // Sequence number of the account
   public readonly sequenceNumber: U64;
 
+  /**
+   * Initializes a new instance of the class with the specified parameters.
+   * This constructor sets up the necessary attributes for managing account keys.
+   *
+   * @param args - The parameters required to create the instance.
+   * @param args.sequenceNumber - The sequence number associated with the transaction.
+   * @param args.originator - The account address of the originator.
+   * @param args.currentAuthKey - The current authentication key of the account.
+   * @param args.newPublicKey - The new public key to be set for the account.
+   */
   constructor(args: {
     sequenceNumber: AnyNumber;
     originator: AccountAddress;
@@ -46,6 +55,19 @@ export class RotationProofChallenge extends Serializable {
     this.newPublicKey = MoveVector.U8(args.newPublicKey.toUint8Array());
   }
 
+  /**
+   * Serializes the properties of the current instance for transmission or storage.
+   * This function helps in converting the instance data into a format suitable for serialization.
+   *
+   * @param serializer - The serializer used to serialize the instance properties.
+   * @param serializer.accountAddress - The account address to serialize.
+   * @param serializer.moduleName - The module name to serialize.
+   * @param serializer.structName - The struct name to serialize.
+   * @param serializer.sequenceNumber - The sequence number to serialize.
+   * @param serializer.originator - The originator to serialize.
+   * @param serializer.currentAuthKey - The current authentication key to serialize.
+   * @param serializer.newPublicKey - The new public key to serialize.
+   */
   serialize(serializer: Serializer): void {
     serializer.serialize(this.accountAddress);
     serializer.serialize(this.moduleName);

package/src/transactions/instances/signedTransaction.ts

@@ -8,20 +8,30 @@ import { Deserializer } from "../../bcs/deserializer";
 import { Serializable, Serializer } from "../../bcs/serializer";
 import { RawTransaction } from "./rawTransaction";
 
+/**
+ * Represents a signed transaction that includes a raw transaction and an authenticator.
+ * The authenticator contains a client's public key and the signature of the raw transaction.
+ *
+ * @see {@link https://aptos.dev/integration/creating-a-signed-transaction | Creating a Signed Transaction}
+ * @param raw_txn - The raw transaction to be signed.
+ * @param authenticator - Contains a client's public key and the signature of the raw transaction.
+ * Authenticator can have three variations: single signature, multi-signature, and multi-agent.
+ * @see {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs} for details.
+ */
 export class SignedTransaction extends Serializable {
   public readonly raw_txn: RawTransaction;
 
   public readonly authenticator: TransactionAuthenticator;
 
   /**
-   * A SignedTransaction consists of a raw transaction and an authenticator. The authenticator
-   * contains a client's public key and the signature of the raw transaction.
+   * Represents a signed transaction that includes a raw transaction and an authenticator.
+   * The authenticator contains a client's public key and the signature of the raw transaction,
+   * which can be of three types: single signature, multi-signature, and multi-agent.
    *
+   * @param raw_txn The raw transaction to be signed.
+   * @param authenticator Contains a client's public key and the signature of the raw transaction. The authenticator has 3
+   * flavors: single signature, multi-signature and multi-agent.
    * @see {@link https://aptos.dev/integration/creating-a-signed-transaction | Creating a Signed Transaction}
-   *
-   * @param raw_txn
-   * @param authenticator Contains a client's public key and the signature of the raw transaction.
-   * Authenticator has 3 flavors: single signature, multi-signature and multi-agent.
    * @see {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs} for details.
    */
   constructor(raw_txn: RawTransaction, authenticator: TransactionAuthenticator) {
@@ -30,11 +40,23 @@ export class SignedTransaction extends Serializable {
     this.authenticator = authenticator;
   }
 
+  /**
+   * Serializes the raw transaction and its authenticator using the provided serializer.
+   * This function is essential for preparing the transaction data for transmission or storage.
+   *
+   * @param serializer - The serializer instance used to serialize the transaction and authenticator.
+   */
   serialize(serializer: Serializer): void {
     this.raw_txn.serialize(serializer);
     this.authenticator.serialize(serializer);
   }
 
+  /**
+   * Deserializes a signed transaction from the provided deserializer.
+   * This function allows you to reconstruct a SignedTransaction object from its serialized form, enabling further processing or validation.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   */
   static deserialize(deserializer: Deserializer): SignedTransaction {
     const raw_txn = RawTransaction.deserialize(deserializer);
     const authenticator = TransactionAuthenticator.deserialize(deserializer);

package/src/transactions/instances/simpleTransaction.ts

@@ -9,26 +9,29 @@ import { AccountAddress } from "../../core";
 import { RawTransaction } from "./rawTransaction";
 
 /**
- * Representation of a SimpleTransaction that can serialized and deserialized
+ * Represents a simple transaction type that can be submitted to the Aptos chain for execution.
+ *
+ * This transaction type is designed for a single signer and includes metadata such as the Raw Transaction
+ * and an optional sponsor Account Address to cover gas fees.
+ *
+ * @param rawTransaction - The Raw Transaction.
+ * @param feePayerAddress - The optional sponsor Account Address.
  */
 export class SimpleTransaction extends Serializable {
   public rawTransaction: RawTransaction;
 
   public feePayerAddress?: AccountAddress | undefined;
 
-  // We dont really need it, we add it for type checkings we do
+  // We don't really need it, we add it for type checking we do
   // throughout the SDK
   public readonly secondarySignerAddresses: undefined;
 
   /**
-   * SimpleTransaction represents a simple transaction type of a single signer that
-   * can be submitted to Aptos chain for execution.
+   * SimpleTransaction represents a transaction signed by a single account that
+   * can be submitted to the Aptos chain for execution.
    *
-   * SimpleTransaction metadata contains the Raw Transaction and an optional
-   * sponsor Account Address to pay the gas fees.
-   *
-   * @param rawTransaction The Raw Tranasaction
-   * @param feePayerAddress The sponsor Account Address
+   * @param rawTransaction The Raw Transaction.
+   * @param feePayerAddress The optional sponsor Account Address to pay the gas fees.
    */
   constructor(rawTransaction: RawTransaction, feePayerAddress?: AccountAddress) {
     super();
@@ -36,6 +39,12 @@ export class SimpleTransaction extends Serializable {
     this.feePayerAddress = feePayerAddress;
   }
 
+  /**
+   * Serializes the transaction data using the provided serializer.
+   * This function ensures that the raw transaction and fee payer address are properly serialized for further processing.
+   *
+   * @param serializer - The serializer instance used to serialize the transaction data.
+   */
   serialize(serializer: Serializer): void {
     this.rawTransaction.serialize(serializer);
 
@@ -47,11 +56,17 @@ export class SimpleTransaction extends Serializable {
     }
   }
 
+  /**
+   * Deserializes a SimpleTransaction from the given deserializer.
+   * This function helps in reconstructing a SimpleTransaction object from its serialized form.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   */
   static deserialize(deserializer: Deserializer): SimpleTransaction {
     const rawTransaction = RawTransaction.deserialize(deserializer);
-    const feepayerPresent = deserializer.deserializeBool();
+    const feePayerPresent = deserializer.deserializeBool();
     let feePayerAddress;
-    if (feepayerPresent) {
+    if (feePayerPresent) {
       feePayerAddress = AccountAddress.deserialize(deserializer);
     }
 

package/src/transactions/instances/transactionArgument.ts

@@ -6,20 +6,46 @@ import { Hex } from "../../core/hex";
 
 export interface TransactionArgument extends EntryFunctionArgument, ScriptFunctionArgument {}
 
+/**
+ * Represents an argument for entry functions, providing methods to serialize the argument
+ * to BCS-serialized bytes and convert it to different formats.
+ */
 export interface EntryFunctionArgument {
   /**
    * Serialize an argument to BCS-serialized bytes.
+   *
+   * @param serializer - The serializer instance used for serialization.
    */
   serialize(serializer: Serializer): void;
+
   /**
+   * Serialize an argument to BCS-serialized bytes.
    * Serialize an argument as a type-agnostic, fixed byte sequence. The byte sequence contains
    * the number of the following bytes followed by the BCS-serialized bytes for a typed argument.
+   *
+   * @param serializer - The serializer used to convert the argument.
    */
   serializeForEntryFunction(serializer: Serializer): void;
 
+  /**
+   * Convert the argument to BCS-serialized bytes.
+   *
+   * @returns Uint8Array representing the BCS-serialized bytes of the argument.
+   */
   bcsToBytes(): Uint8Array;
+
+  /**
+   * Converts the BCS-serialized bytes of an argument into a hexadecimal representation.
+   * This function is useful for obtaining a Hex instance that encapsulates the BCS-serialized bytes,
+   * allowing for easier manipulation and representation of the data.
+   * @returns A Hex instance containing the BCS-serialized bytes.
+   */
   bcsToHex(): Hex;
 }
+
+/**
+ * Represents an argument for script functions, providing methods to serialize and convert to bytes.
+ */
 export interface ScriptFunctionArgument {
   /**
    * Serialize an argument to BCS-serialized bytes.

package/src/transactions/instances/transactionPayload.ts

@@ -16,7 +16,12 @@ import { MoveModuleId, ScriptTransactionArgumentVariants, TransactionPayloadVari
 import { TypeTag } from "../typeTag";
 
 /**
- * Deserialize a Script Transaction Argument
+ * Deserialize a Script Transaction Argument.
+ * This function retrieves and deserializes various types of script transaction arguments based on the provided deserializer.
+ *
+ * @param deserializer - The deserializer used to read the script transaction argument.
+ * @returns The deserialized script transaction argument.
+ * @throws Error if the variant index is unknown.
  */
 export function deserializeFromScriptArgument(deserializer: Deserializer): TransactionArgument {
   // index enum variant
@@ -48,8 +53,11 @@ export function deserializeFromScriptArgument(deserializer: Deserializer): Trans
 }
 
 /**
- * Representation of the supported Transaction Payload
- * that can serialized and deserialized
+ * Represents a supported Transaction Payload that can be serialized and deserialized.
+ *
+ * This class serves as a base for different types of transaction payloads, allowing for
+ * their serialization into a format suitable for transmission and deserialization back
+ * into their original form.
  */
 export abstract class TransactionPayload extends Serializable {
   /**
@@ -60,6 +68,13 @@ export abstract class TransactionPayload extends Serializable {
   /**
    * Deserialize a Transaction Payload
    */
+
+  /**
+   * Deserializes a multisig transaction payload from the provided deserializer.
+   * This function enables the reconstruction of a MultiSigTransactionPayload object from its serialized form.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   */
   static deserialize(deserializer: Deserializer): TransactionPayload {
     // index enum variant
     const index = deserializer.deserializeUleb128AsU32();
@@ -77,21 +92,42 @@ export abstract class TransactionPayload extends Serializable {
 }
 
 /**
- * Representation of a Transaction Payload Script that can serialized and deserialized
+ * Represents a transaction payload script that can be serialized and deserialized.
+ *
+ * This class encapsulates a script that defines the logic for a transaction payload.
+ *
+ * @extends TransactionPayload
  */
 export class TransactionPayloadScript extends TransactionPayload {
   public readonly script: Script;
 
+  /**
+   * Initializes a multi-sig account transaction with the provided payload.
+   *
+   * @param script - The payload of the multi-sig transaction. This can only be an EntryFunction for now, but Script might be
+   * supported in the future.
+   */
   constructor(script: Script) {
     super();
     this.script = script;
   }
 
+  /**
+   * Serializes the transaction payload, enabling future support for multiple types of inner transaction payloads.
+   *
+   * @param serializer - The serializer instance used to serialize the transaction data.
+   */
   serialize(serializer: Serializer): void {
     serializer.serializeU32AsUleb128(TransactionPayloadVariants.Script);
     this.script.serialize(serializer);
   }
 
+  /**
+   * Loads a MultiSig transaction payload from the provided deserializer.
+   * This function helps in reconstructing a MultiSig transaction payload from its serialized form.
+   *
+   * @param deserializer - The deserializer used to read the serialized data.
+   */
   static load(deserializer: Deserializer): TransactionPayloadScript {
     const script = Script.deserialize(deserializer);
     return new TransactionPayloadScript(script);
@@ -99,7 +135,9 @@ export class TransactionPayloadScript extends TransactionPayload {
 }
 
 /**
- * Representation of a Transaction Payload Entry Function that can serialized and deserialized
+ * Represents a transaction payload entry function that can be serialized and deserialized.
+ *
+ * @extends TransactionPayload
  */
 export class TransactionPayloadEntryFunction extends TransactionPayload {
   public readonly entryFunction: EntryFunction;
@@ -121,7 +159,7 @@ export class TransactionPayloadEntryFunction extends TransactionPayload {
 }
 
 /**
- * Representation of a Transaction Payload Multi-sig that can serialized and deserialized
+ * Represents a multi-signature transaction payload that can be serialized and deserialized.
  */
 export class TransactionPayloadMultiSig extends TransactionPayload {
   public readonly multiSig: MultiSig;
@@ -143,7 +181,14 @@ export class TransactionPayloadMultiSig extends TransactionPayload {
 }
 
 /**
- * Representation of a EntryFunction that can serialized and deserialized
+ * Represents an entry function that can be serialized and deserialized.
+ * This class encapsulates the details required to invoke a function within a module,
+ * including the module name, function name, type arguments, and function arguments.
+ *
+ * @param module_name - Fully qualified module name in the format "account_address::module_name" (e.g., "0x1::coin").
+ * @param function_name - The name of the function (e.g., "transfer").
+ * @param type_args - Type arguments required by the Move function.
+ * @param args - Arguments to the Move function.
  */
 export class EntryFunction {
   public readonly module_name: ModuleId;
@@ -186,24 +231,24 @@ export class EntryFunction {
   }
 
   /**
-   * A helper function to build a EntryFunction payload from raw primitive values
+   * Build an EntryFunction payload from raw primitive values.
    *
-   * @param module_id Fully qualified module name in format "AccountAddress::module_id" e.g. "0x1::coin"
-   * @param function_name Function name
-   * @param type_args Type arguments that move function requires.
+   * @param module_id - Fully qualified module name in the format "AccountAddress::module_id", e.g., "0x1::coin".
+   * @param function_name - The name of the function to be called.
+   * @param type_args - Type arguments that the Move function requires.
+   * @param args - Arguments to the Move function.
    *
    * @example
    * A coin transfer function has one type argument "CoinType".
    * ```
-   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
+   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)
    * ```
-   * @param args Arguments to the move function.
    *
-   * @example
-   * A coin transfer function has three arguments "from", "to" and "amount".
+   * A coin transfer function has three arguments "from", "to", and "amount".
    * ```
-   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
+   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)
    * ```
+   *
    * @returns EntryFunction
    */
   static build(
@@ -262,7 +307,8 @@ export class EntryFunction {
 }
 
 /**
- * Representation of a Script that can serialized and deserialized
+ * Represents a Script that can be serialized and deserialized.
+ * Scripts contain the Move bytecode payload that can be submitted to the Aptos chain for execution.
  */
 export class Script {
   /**
@@ -289,14 +335,14 @@ export class Script {
    * @example
    * A coin transfer function has one type argument "CoinType".
    * ```
-   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
+   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)
    * ```
    * @param args The arguments that the bytecode function requires.
    *
    * @example
    * A coin transfer function has three arguments "from", "to" and "amount".
    * ```
-   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64,)
+   * public(script) fun transfer<CoinType>(from: &signer, to: address, amount: u64)
    * ```
    */
   constructor(bytecode: Uint8Array, type_args: Array<TypeTag>, args: Array<ScriptFunctionArgument>) {
@@ -331,7 +377,10 @@ export class Script {
 }
 
 /**
- * Representation of a MultiSig that can serialized and deserialized
+ * Represents a MultiSig account that can be serialized and deserialized.
+ *
+ * This class encapsulates the functionality to manage multi-signature transactions, including the address of the
+ * multi-sig account and the associated transaction payload.
  */
 export class MultiSig {
   public readonly multisig_address: AccountAddress;
@@ -375,12 +424,10 @@ export class MultiSig {
 }
 
 /**
- * Representation of a MultiSig Transaction Payload from `multisig_account.move`
- * that can be serialized and deserialized
-
- * This class exists right now to represent an extensible transaction payload class for
- * transactions used in `multisig_account.move`. Eventually, this class will be able to
- * support script payloads when the `multisig_account.move` module supports them.
+ * Represents a multi-signature transaction payload that can be serialized and deserialized.
+ * This class is designed to encapsulate the transaction payload for multi-sig account transactions
+ * as defined in the `multisig_account.move` module. Future enhancements may allow support for script
+ * payloads as the `multisig_account.move` module evolves.
  */
 export class MultiSigTransactionPayload extends Serializable {
   public readonly transaction_payload: EntryFunction;