@aptos-labs/ts-sdk 7.2.0 → 7.4.0

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -8,6 +8,7 @@
  */
 import { sha3_256 as sha3Hash } from "@noble/hashes/sha3.js";
 import { AptosConfig } from "../../api/aptosConfig.js";
+import { Serialized } from "../../bcs/index.js";
 import { MAX_U64_BIG_INT } from "../../bcs/consts.js";
 import { AccountAddress, AccountAddressInput, Hex, PublicKey } from "../../core/index.js";
 import {
@@ -56,6 +57,7 @@ import {
   TransactionPayloadScript,
 } from "../instances/index.js";
 import { SignedTransaction } from "../instances/signedTransaction.js";
+import { StructTag, TypeTag, TypeTagReference, TypeTagStruct, TypeTagVector } from "../typeTag/index.js";
 import {
   AnyRawTransaction,
   AnyTransactionPayloadInstance,
@@ -65,6 +67,7 @@ import {
   InputGenerateSingleSignerRawTransactionArgs,
   InputGenerateTransactionOptions,
   InputScriptData,
+  InputMultiSigScriptData,
   InputSimulateTransactionData,
   InputMultiSigDataWithRemoteABI,
   InputEntryFunctionDataWithRemoteABI,
@@ -76,8 +79,11 @@ import {
   InputViewFunctionDataWithRemoteABI,
   InputViewFunctionDataWithABI,
   FunctionABI,
+  ScriptFunctionArgumentTypes,
+  SimpleEntryFunctionArgumentTypes,
 } from "../types.js";
 import { convertArgument, fetchEntryFunctionAbi, fetchViewFunctionAbi, standardizeTypeTags } from "./remoteAbi.js";
+import { parseScriptAbi } from "./scriptAbi.js";
 import { memoizeAsync } from "../../utils/memoize.js";
 import { isScriptDataInput } from "./helpers.js";
 import { SimpleTransaction } from "../instances/simpleTransaction.js";
@@ -110,6 +116,11 @@ import { buildEncryptedPayload } from "./encryptPayload.js";
  * @group Implementation
  * @category Transactions
  */
+export async function generateTransactionPayload(args: InputMultiSigScriptData): Promise<TransactionPayloadMultiSig>;
+/**
+ * @group Implementation
+ * @category Transactions
+ */
 export async function generateTransactionPayload(args: InputScriptData): Promise<TransactionPayloadScript>;
 /**
  * @group Implementation
@@ -345,13 +356,93 @@ export function generateViewFunctionPayloadWithABI(args: InputViewFunctionDataWi
  * @group Implementation
  * @category Transactions
  */
-function generateTransactionPayloadScript(args: InputScriptData) {
+function isScriptFunctionArgument(
+  arg: ScriptFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes,
+): arg is ScriptFunctionArgumentTypes {
+  return (
+    typeof arg === "object" &&
+    arg !== null &&
+    "serializeForScriptFunction" in arg &&
+    typeof arg.serializeForScriptFunction === "function"
+  );
+}
+
+function instantiateScriptType(type: TypeTag, typeArguments: Array<TypeTag>): TypeTag {
+  if (type.isGeneric()) {
+    const resolved = typeArguments[type.value];
+    if (resolved === undefined) {
+      throw new Error(`Generic argument ${type.toString()} is invalid for script parameter`);
+    }
+    return resolved;
+  }
+  if (type.isVector()) {
+    return new TypeTagVector(instantiateScriptType(type.value, typeArguments));
+  }
+  if (type instanceof TypeTagReference) {
+    return new TypeTagReference(instantiateScriptType(type.value, typeArguments));
+  }
+  if (type instanceof TypeTagStruct) {
+    return new TypeTagStruct(
+      new StructTag(
+        type.value.address,
+        type.value.moduleName,
+        type.value.name,
+        type.value.typeArgs.map((argument) => instantiateScriptType(argument, typeArguments)),
+      ),
+    );
+  }
+  return type;
+}
+
+function isNativeScriptArgumentType(type: TypeTag): boolean {
+  if (type.isVector()) return type.value.isU8();
+  return type.isPrimitive() && !type.isSigner();
+}
+
+function generateTransactionPayloadScript(args: InputScriptData): TransactionPayloadScript {
+  const typeArguments = standardizeTypeTags(args.typeArguments);
+
+  if (args.functionArguments.every(isScriptFunctionArgument)) {
+    return new TransactionPayloadScript(
+      new Script(Hex.fromHexInput(args.bytecode).toUint8Array(), typeArguments, args.functionArguments),
+    );
+  }
+
+  const abi = parseScriptAbi(args.bytecode);
+  if (typeArguments.length !== abi.typeParameters.length) {
+    throw new Error(
+      `Type argument count mismatch, expected ${abi.typeParameters.length}, received ${typeArguments.length}`,
+    );
+  }
+  if (args.functionArguments.length !== abi.parameters.length) {
+    throw new Error(
+      `Script function argument count mismatch, expected ${abi.parameters.length}, received ${args.functionArguments.length}`,
+    );
+  }
+
+  const parameterTypes = abi.parameters.map((parameter) => instantiateScriptType(parameter, typeArguments));
+  const instantiatedAbi = { ...abi, parameters: parameterTypes };
+  const functionArguments = args.functionArguments.map((arg, index): ScriptFunctionArgumentTypes => {
+    if (isScriptFunctionArgument(arg)) return arg;
+    let converted: EntryFunctionArgumentTypes;
+    try {
+      converted = convertArgument("script", instantiatedAbi, arg, index, typeArguments);
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith("Struct/enum arguments require async conversion.")) {
+        throw new Error(
+          `Script custom struct/enum arguments must be passed as Serialized containing the BCS-encoded bytes. ` +
+            `Type: '${parameterTypes[index].toString()}', position: ${index}`,
+        );
+      }
+      throw error;
+    }
+    return isNativeScriptArgumentType(parameterTypes[index]) && isScriptFunctionArgument(converted)
+      ? converted
+      : new Serialized(converted.bcsToBytes());
+  });
+
   return new TransactionPayloadScript(
-    new Script(
-      Hex.fromHexInput(args.bytecode).toUint8Array(),
-      standardizeTypeTags(args.typeArguments),
-      args.functionArguments,
-    ),
+    new Script(Hex.fromHexInput(args.bytecode).toUint8Array(), typeArguments, functionArguments),
   );
 }
 

package/src/transactions/types.ts

@@ -339,7 +339,7 @@ export type InputMultiSigDataWithRemoteABI = {
 export type InputScriptData = {
   bytecode: HexInput;
   typeArguments?: Array<TypeArgument>;
-  functionArguments: Array<ScriptFunctionArgumentTypes>;
+  functionArguments: Array<ScriptFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
 };
 
 /**
@@ -412,6 +412,11 @@ export type FunctionABI = {
   parameters: Array<TypeTag>;
 };
 
+export type ScriptABI = FunctionABI & {
+  /** Number of leading signer parameters supplied by transaction authentication. */
+  signers: number;
+};
+
 /**
  * Interface for an Entry function's ABI, enabling type checking and input conversion for ABI-based transaction submissions.
  * @group Implementation
@@ -503,10 +508,10 @@ export type InputSimulateTransactionData = {
    */
   transaction: AnyRawTransaction;
   /**
-   * For a single signer transaction
+   * The primary sender's public key. Omit it to skip the sender's public/authentication-key check during
+   * simulation.
    * @group Implementation
    * @category Transactions
-   * This is optional and can be undefined to skip the public/auth key check during the transaction simulation.
    */
   signerPublicKey?: PublicKey;
   /**
@@ -516,7 +521,8 @@ export type InputSimulateTransactionData = {
    */
   secondarySignersPublicKeys?: Array<PublicKey | undefined>;
   /**
-   * For a fee payer transaction (aka Sponsored Transaction)
+   * The public key for the fee payer in a sponsored transaction. Omit it to skip the fee payer's
+   * public/authentication-key check during simulation.
    * @group Implementation
    * @category Transactions
    */

package/src/types/keyless.ts

@@ -30,12 +30,12 @@ export type ProverResponse = {
  * @category Types
  */
 export type PepperFetchRequest = {
-  jwt_b64: number;
+  jwt_b64: string;
   epk: string;
   exp_date_secs: number;
   epk_blinder: string;
   uid_key: string;
-  derivation_path: string;
+  derivation_path?: string;
 };
 
 /**

package/src/types/types.ts

@@ -346,6 +346,12 @@ export type AptosSettings = {
   readonly transactionGenerationConfig?: TransactionGenerationConfig;
 
   readonly pluginSettings?: PluginSettings;
+
+  /**
+   * Whether reads of pruned history are retried against the archival endpoint the node advertises.
+   * Defaults to `true`.
+   */
+  readonly archivalFallback?: boolean;
 };
 
 /**
@@ -1034,7 +1040,7 @@ export type WriteSetChangeDeleteTableItem = {
   state_key_hash: string;
   handle: string;
   key: string;
-  data?: DeletedTableData;
+  data?: DeletedTableData | null;
 };
 
 /**
@@ -1066,7 +1072,7 @@ export type WriteSetChangeWriteTableItem = {
   handle: string;
   key: string;
   value: string;
-  data?: DecodedTableData;
+  data?: DecodedTableData | null;
 };
 
 /**

package/src/utils/const.ts

@@ -67,6 +67,18 @@ export const DEFAULT_TXN_EXP_SEC_FROM_NOW = 20;
  */
 export const DEFAULT_TXN_TIMEOUT_SEC = 20;
 
+/**
+ * The default number of seconds to wait for an indexer processor to catch up
+ * to a requested ledger version.
+ *
+ * Public networks and a busy local testnet can lag several seconds behind the
+ * fullnode. Callers that need a different budget can pass `timeoutMilliseconds`
+ * to `waitForIndexer`.
+ * @group Implementation
+ * @category Utils
+ */
+export const DEFAULT_INDEXER_SYNC_TIMEOUT_SEC = 10;
+
 /**
  * The default gas currency for the network.
  * @group Implementation

package/src/version.ts

@@ -6,4 +6,4 @@
  *
  * hardcoded for now, we would want to have it injected dynamically
  */
-export const VERSION = "7.2.0";
+export const VERSION = "7.4.0";