@aptos-labs/ts-sdk 5.2.0 → 6.0.0

package/src/transactions/instances/transactionPayload.ts

@@ -6,7 +6,21 @@
 import { Deserializer } from "../../bcs/deserializer";
 import { Serializable, Serializer } from "../../bcs/serializer";
 import { EntryFunctionBytes } from "../../bcs/serializable/entryFunctionBytes";
-import { Bool, U128, U16, U256, U32, U64, U8 } from "../../bcs/serializable/movePrimitives";
+import {
+  Bool,
+  U128,
+  U16,
+  U256,
+  U32,
+  U64,
+  U8,
+  I8,
+  I16,
+  I32,
+  I64,
+  I128,
+  I256,
+} from "../../bcs/serializable/movePrimitives";
 import { MoveVector, Serialized } from "../../bcs/serializable/moveStructs";
 import { AccountAddress, Hex } from "../../core";
 import { Identifier } from "./identifier";
@@ -57,6 +71,18 @@ export function deserializeFromScriptArgument(deserializer: Deserializer): Trans
       return U256.deserialize(deserializer);
     case ScriptTransactionArgumentVariants.Serialized:
       return Serialized.deserialize(deserializer);
+    case ScriptTransactionArgumentVariants.I8:
+      return I8.deserialize(deserializer);
+    case ScriptTransactionArgumentVariants.I16:
+      return I16.deserialize(deserializer);
+    case ScriptTransactionArgumentVariants.I32:
+      return I32.deserialize(deserializer);
+    case ScriptTransactionArgumentVariants.I64:
+      return I64.deserialize(deserializer);
+    case ScriptTransactionArgumentVariants.I128:
+      return I128.deserialize(deserializer);
+    case ScriptTransactionArgumentVariants.I256:
+      return I256.deserialize(deserializer);
     default:
       throw new Error(`Unknown variant index for ScriptTransactionArgument: ${index}`);
   }

package/src/transactions/transactionBuilder/helpers.ts

@@ -8,7 +8,25 @@ import {
   InputScriptData,
   SimpleEntryFunctionArgumentTypes,
 } from "../types";
-import { Bool, FixedBytes, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from "../../bcs";
+import {
+  Bool,
+  FixedBytes,
+  I128,
+  I16,
+  I256,
+  I32,
+  I64,
+  I8,
+  MoveOption,
+  MoveString,
+  MoveVector,
+  U128,
+  U16,
+  U256,
+  U32,
+  U64,
+  U8,
+} from "../../bcs";
 import { AccountAddress } from "../../core";
 import { MoveFunction } from "../../types";
 
@@ -192,6 +210,12 @@ export function isEncodedEntryFunctionArgument(
      * @category Transactions
      */
     isBcsFixedBytes(arg) ||
+    isBcsI8(arg) ||
+    isBcsI16(arg) ||
+    isBcsI32(arg) ||
+    isBcsI64(arg) ||
+    isBcsI128(arg) ||
+    isBcsI256(arg) ||
     arg instanceof MoveVector ||
     arg instanceof MoveOption
   );
@@ -268,6 +292,48 @@ export function isBcsU128(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionA
 export function isBcsU256(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is U256 {
   return arg instanceof U256;
 }
+/**
+ * @group Implementation
+ * @category Transactions
+ */
+export function isBcsI8(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is I8 {
+  return arg instanceof I8;
+}
+/**
+ * @group Implementation
+ * @category Transactions
+ */
+export function isBcsI16(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is I16 {
+  return arg instanceof I16;
+}
+/**
+ * @group Implementation
+ * @category Transactions
+ */
+export function isBcsI32(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is I32 {
+  return arg instanceof I32;
+}
+/**
+ * @group Implementation
+ * @category Transactions
+ */
+export function isBcsI64(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is I64 {
+  return arg instanceof I64;
+}
+/**
+ * @group Implementation
+ * @category Transactions
+ */
+export function isBcsI128(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is I128 {
+  return arg instanceof I128;
+}
+/**
+ * @group Implementation
+ * @category Transactions
+ */
+export function isBcsI256(arg: EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes): arg is I256 {
+  return arg instanceof I256;
+}
 
 /**
  * Determines if the provided argument contains script data input by checking for the presence of bytecode.

package/src/transactions/transactionBuilder/remoteAbi.ts

@@ -6,6 +6,12 @@ import {
   TypeTag,
   TypeTagAddress,
   TypeTagBool,
+  TypeTagI128,
+  TypeTagI16,
+  TypeTagI256,
+  TypeTagI32,
+  TypeTagI64,
+  TypeTagI8,
   TypeTagStruct,
   TypeTagU128,
   TypeTagU16,
@@ -23,7 +29,25 @@ import {
   FunctionABI,
   TypeArgument,
 } from "../types";
-import { Bool, FixedBytes, MoveOption, MoveString, MoveVector, U128, U16, U256, U32, U64, U8 } from "../../bcs";
+import {
+  Bool,
+  FixedBytes,
+  I128,
+  I16,
+  I256,
+  I32,
+  I64,
+  I8,
+  MoveOption,
+  MoveString,
+  MoveVector,
+  U128,
+  U16,
+  U256,
+  U32,
+  U64,
+  U8,
+} from "../../bcs";
 import { AccountAddress } from "../../core";
 import { getModule } from "../../internal/account";
 import {
@@ -44,6 +68,12 @@ import {
   isString,
   throwTypeMismatch,
   convertNumber,
+  isBcsI8,
+  isBcsI16,
+  isBcsI32,
+  isBcsI64,
+  isBcsI128,
+  isBcsI256,
 } from "./helpers";
 import { MoveFunction, MoveModule } from "../../types";
 
@@ -420,6 +450,45 @@ function parseArg(
     }
     throwTypeMismatch("bigint | number | string", position);
   }
+  if (param.isI8()) {
+    const num = convertNumber(arg);
+    if (num !== undefined) {
+      return new I8(num);
+    }
+    throwTypeMismatch("number | string", position);
+  }
+  if (param.isI16()) {
+    const num = convertNumber(arg);
+    if (num !== undefined) {
+      return new I16(num);
+    }
+    throwTypeMismatch("number | string", position);
+  }
+  if (param.isI32()) {
+    const num = convertNumber(arg);
+    if (num !== undefined) {
+      return new I32(num);
+    }
+    throwTypeMismatch("number | string", position);
+  }
+  if (param.isI64()) {
+    if (isLargeNumber(arg)) {
+      return new I64(BigInt(arg));
+    }
+    throwTypeMismatch("bigint | number | string", position);
+  }
+  if (param.isI128()) {
+    if (isLargeNumber(arg)) {
+      return new I128(BigInt(arg));
+    }
+    throwTypeMismatch("bigint | number | string", position);
+  }
+  if (param.isI256()) {
+    if (isLargeNumber(arg)) {
+      return new I256(BigInt(arg));
+    }
+    throwTypeMismatch("bigint | number | string", position);
+  }
 
   // Generic needs to use the subtype
   if (param.isGeneric()) {
@@ -522,6 +591,24 @@ function parseArg(
         if (innerParam instanceof TypeTagU256) {
           return new MoveOption<U256>(null);
         }
+        if (innerParam instanceof TypeTagI8) {
+          return new MoveOption<I8>(null);
+        }
+        if (innerParam instanceof TypeTagI16) {
+          return new MoveOption<I16>(null);
+        }
+        if (innerParam instanceof TypeTagI32) {
+          return new MoveOption<I32>(null);
+        }
+        if (innerParam instanceof TypeTagI64) {
+          return new MoveOption<I64>(null);
+        }
+        if (innerParam instanceof TypeTagI128) {
+          return new MoveOption<I128>(null);
+        }
+        if (innerParam instanceof TypeTagI256) {
+          return new MoveOption<I256>(null);
+        }
 
         // In all other cases, we will use a placeholder, it doesn't actually matter what the type is, but it will be obvious
         // Note: This is a placeholder U8 type, and does not match the actual type, as that can't be dynamically grabbed
@@ -612,6 +699,42 @@ function checkType(param: TypeTag, arg: EntryFunctionArgumentTypes, position: nu
     }
     throwTypeMismatch("U256", position);
   }
+  if (param.isI8()) {
+    if (isBcsI8(arg)) {
+      return;
+    }
+    throwTypeMismatch("I8", position);
+  }
+  if (param.isI16()) {
+    if (isBcsI16(arg)) {
+      return;
+    }
+    throwTypeMismatch("I16", position);
+  }
+  if (param.isI32()) {
+    if (isBcsI32(arg)) {
+      return;
+    }
+    throwTypeMismatch("I32", position);
+  }
+  if (param.isI64()) {
+    if (isBcsI64(arg)) {
+      return;
+    }
+    throwTypeMismatch("I64", position);
+  }
+  if (param.isI128()) {
+    if (isBcsI128(arg)) {
+      return;
+    }
+    throwTypeMismatch("I128", position);
+  }
+  if (param.isI256()) {
+    if (isBcsI256(arg)) {
+      return;
+    }
+    throwTypeMismatch("I256", position);
+  }
   if (param.isVector()) {
     if (arg instanceof MoveVector) {
       // If there's anything in it, check that the inner types match

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -201,7 +201,7 @@ export function generateTransactionPayloadWithABI(
   }
 
   // Check all BCS types, and convert any non-BCS types
-  const functionArguments: Array<EntryFunctionArgumentTypes> = args.functionArguments.map((arg, i) =>
+  const functionArguments: Array<EntryFunctionArgumentTypes> | undefined = args.functionArguments?.map((arg, i) =>
     /**
      * Converts the argument for a specified function using its ABI and type arguments.
      * This function helps ensure that the correct number of arguments is provided for the function call.
@@ -220,10 +220,10 @@ export function generateTransactionPayloadWithABI(
   );
 
   // Check that all arguments are accounted for
-  if (functionArguments.length !== functionAbi.parameters.length) {
+  if ((functionArguments?.length ?? 0) !== functionAbi.parameters.length) {
     throw new Error(
       // eslint-disable-next-line max-len
-      `Too few arguments for '${moduleAddress}::${moduleName}::${functionName}', expected ${functionAbi.parameters.length} but got ${functionArguments.length}`,
+      `Too few arguments for '${moduleAddress}::${moduleName}::${functionName}', expected ${functionAbi.parameters.length} but got ${functionArguments?.length ?? 0}`,
     );
   }
 
@@ -232,7 +232,7 @@ export function generateTransactionPayloadWithABI(
     `${moduleAddress}::${moduleName}`,
     functionName,
     typeArguments,
-    functionArguments,
+    functionArguments ?? [],
   );
 
   // Send it as multi sig if it's a multisig payload

package/src/transactions/types.ts

@@ -3,7 +3,7 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { MoveOption, MoveString, MoveVector } from "../bcs/serializable/moveStructs";
-import { Bool, U128, U16, U256, U32, U64, U8 } from "../bcs/serializable/movePrimitives";
+import { Bool, I128, I16, I256, I32, I64, I8, U128, U16, U256, U32, U64, U8 } from "../bcs/serializable/movePrimitives";
 import { FixedBytes } from "../bcs/serializable/fixedBytes";
 import { AccountAddress, AccountAddressInput } from "../core";
 import { PublicKey } from "../core/crypto";
@@ -60,6 +60,12 @@ export type EntryFunctionArgumentTypes =
   | U64
   | U128
   | U256
+  | I8
+  | I16
+  | I32
+  | I64
+  | I128
+  | I256
   | AccountAddress
   | MoveVector<EntryFunctionArgumentTypes>
   | MoveOption<EntryFunctionArgumentTypes>
@@ -79,6 +85,12 @@ export type ScriptFunctionArgumentTypes =
   | U64
   | U128
   | U256
+  | I8
+  | I16
+  | I32
+  | I64
+  | I128
+  | I256
   | AccountAddress
   | MoveVector<ScriptFunctionArgumentTypes>
   | MoveString
@@ -97,6 +109,12 @@ export type ScriptFunctionArgumentTypes =
  * - u64
  * - u128
  * - u256
+ * - i8
+ * - i16
+ * - i32
+ * - i64
+ * - i128
+ * - i256
  * - bool
  * - address
  * - signer
@@ -186,7 +204,7 @@ export type InputGenerateTransactionPayloadDataWithRemoteABI =
 export type InputEntryFunctionData = {
   function: MoveFunctionId;
   typeArguments?: Array<TypeArgument>;
-  functionArguments: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
+  functionArguments?: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
   abi?: EntryFunctionABI;
 };
 

package/src/types/ans.ts

@@ -0,0 +1,110 @@
+import { type GetANSNameResponse } from "./indexer";
+
+export type RawANSName = GetANSNameResponse[0];
+
+/**
+ * The token standard for the ANS name. v1 is the original token standard, v2 is
+ * the new token standard. v1 has been deprecated.
+ */
+export type AnsTokenStandard = "v1" | "v2";
+
+/**
+ * Policy for determining how subdomains expire in relation to their parent domain.
+ */
+export enum SubdomainExpirationPolicy {
+  /**
+   * The subdomain will expire independently of the domain. The owner of the
+   * domain can manually set when the subdomain expires.
+   */
+  Independent = 0,
+  /**
+   * The subdomain will expire at the same time as the domain.
+   */
+  FollowsDomain = 1,
+}
+
+/**
+ * The status of the name.
+ */
+export enum ExpirationStatus {
+  /**
+   * The name no longer functions as a primary or target name. It is open to
+   * being claimed by the public.
+   */
+  Expired = "expired",
+  /**
+   * The name is past it's expiration date, but only claimable by the current
+   * owner of the name. It does not function as a primary or target name.
+   */
+  InGracePeriod = "in_grace_period",
+  /**
+   * The name is in good standing.
+   */
+  Active = "active",
+}
+
+export interface AnsName extends RawANSName {
+  /**
+   * The domain name. ie "aptos.apt" would have a domain of "aptos"
+   */
+  domain: string;
+  /**
+   * The subdomain name, if the name is a subdomain. ie "name.aptos.apt" would have a subdomain of "name"
+   */
+  subdomain?: string;
+  /**
+   * The expiration timestamp of the name in milliseconds since epoch. Note, if
+   * the name is not a subdomain, this will be the same as the domain expiration
+   * timestamp.
+   */
+  expiration_timestamp: string;
+  /**
+   * The expiration timestamp of the domain in milliseconds since epoch.
+   */
+  domain_expiration_timestamp: string;
+  /**
+   * This is a derived date value. It takes into consideration if the name is a
+   * subdomain and its expiration policy.
+   */
+  expiration: Date;
+
+  /**
+   * The status of the name's expiration.
+   *
+   * 1. Expired: The name has expired and is no longer resolvable.
+   * 2. InGracePeriod: The name is within the grace period and is still
+   *    resolvable if it is renewed.
+   * 3. Active: The name is active and is resolvable.
+   *
+   * @see {@link ExpirationStatus}
+   */
+  expiration_status: ExpirationStatus;
+  /**
+   * The address that the name points to. For example, if you send a transaction
+   * to "aptos.apt" with a target address of "0x1", the registered_address will
+   * be "0x1".
+   */
+  registered_address?: string;
+  /**
+   * The token standard for the name. See {@link AnsTokenStandard} for more details.
+   */
+  token_standard: AnsTokenStandard;
+  /**
+   * If the name is registered as a primary name for _any_ account. It is
+   * possible to have multiple primary names returned in a single query.
+   */
+  is_primary: boolean;
+  /**
+   * The address of the wallet that owns the name.
+   */
+  owner_address?: string;
+  /**
+   * The expiration policy for the subdomain. See {@link SubdomainExpirationPolicy} for more details.
+   */
+  subdomain_expiration_policy: SubdomainExpirationPolicy;
+  /**
+   * Whether the name is in the renewable period. This incorporates leading time
+   * before the name expires and the grace period after the name expires.
+   */
+  isInRenewablePeriod: boolean;
+}

package/src/types/generated/operations.ts

@@ -545,6 +545,7 @@ export type GetNamesQuery = {
     subdomain_expiration_policy?: any | null;
     domain_expiration_timestamp?: any | null;
   }>;
+  current_aptos_names_aggregate: { aggregate?: { count: number } | null };
 };
 
 export type GetNumberOfDelegatorsQueryVariables = Types.Exact<{