@aptos-labs/ts-sdk 5.2.0 → 5.2.1

package/src/bcs/serializable/movePrimitives.ts

@@ -366,10 +366,8 @@ export class I8 extends Serializable implements TransactionArgument {
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
-    // Note: Script functions don't have variants for signed integers yet
-    // This will serialize as bytes
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.I8);
+    serializer.serialize(this);
   }
 
   static deserialize(deserializer: Deserializer): I8 {
@@ -405,8 +403,8 @@ export class I16 extends Serializable implements TransactionArgument {
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.I16);
+    serializer.serialize(this);
   }
 
   static deserialize(deserializer: Deserializer): I16 {
@@ -441,8 +439,8 @@ export class I32 extends Serializable implements TransactionArgument {
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.I32);
+    serializer.serialize(this);
   }
 
   static deserialize(deserializer: Deserializer): I32 {
@@ -480,8 +478,8 @@ export class I64 extends Serializable implements TransactionArgument {
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.I64);
+    serializer.serialize(this);
   }
 
   static deserialize(deserializer: Deserializer): I64 {
@@ -517,8 +515,8 @@ export class I128 extends Serializable implements TransactionArgument {
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.I128);
+    serializer.serialize(this);
   }
 
   static deserialize(deserializer: Deserializer): I128 {
@@ -554,8 +552,8 @@ export class I256 extends Serializable implements TransactionArgument {
   }
 
   serializeForScriptFunction(serializer: Serializer): void {
-    const bcsBytes = this.bcsToBytes();
-    serializer.serializeBytes(bcsBytes);
+    serializer.serializeU32AsUleb128(ScriptTransactionArgumentVariants.I256);
+    serializer.serialize(this);
   }
 
   static deserialize(deserializer: Deserializer): I256 {

package/src/bcs/serializable/moveStructs.ts

@@ -1,7 +1,7 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Bool, U128, U16, U256, U32, U64, U8 } from "./movePrimitives";
+import { Bool, U128, U16, U256, U32, U64, U8, I8, I16, I32, I64, I128, I256 } from "./movePrimitives";
 import { Serializable, Serializer } from "../serializer";
 import { Deserializable, Deserializer } from "../deserializer";
 import { AnyNumber, HexInput, ScriptTransactionArgumentVariants } from "../../types";
@@ -256,6 +256,108 @@ export class MoveVector<T extends Serializable & EntryFunctionArgument>
     return new MoveVector<Bool>(values.map((v) => new Bool(v)));
   }
 
+  /**
+   * Factory method to generate a MoveVector<I8> from an array of numbers.
+   *
+   * @param values - The values used to fill the MoveVector.
+   * @returns A MoveVector<I8> with the inner values.
+   *
+   * @example
+   * ```typescript
+   * const v = MoveVector.I8([-1, 0, 1, 127]);
+   * ```
+   * @group Implementation
+   * @category BCS
+   */
+  static I8(values: Array<number>): MoveVector<I8> {
+    return new MoveVector<I8>(values.map((v) => new I8(v)));
+  }
+
+  /**
+   * Factory method to generate a MoveVector<I16> from an array of numbers.
+   *
+   * @param values - The values used to fill the MoveVector.
+   * @returns A MoveVector<I16> with the inner values.
+   *
+   * @example
+   * ```typescript
+   * const v = MoveVector.I16([-1, 0, 1, 32767]);
+   * ```
+   * @group Implementation
+   * @category BCS
+   */
+  static I16(values: Array<number>): MoveVector<I16> {
+    return new MoveVector<I16>(values.map((v) => new I16(v)));
+  }
+
+  /**
+   * Factory method to generate a MoveVector<I32> from an array of numbers.
+   *
+   * @param values - The values used to fill the MoveVector.
+   * @returns A MoveVector<I32> with the inner values.
+   *
+   * @example
+   * ```typescript
+   * const v = MoveVector.I32([-1, 0, 1, 2147483647]);
+   * ```
+   * @group Implementation
+   * @category BCS
+   */
+  static I32(values: Array<number>): MoveVector<I32> {
+    return new MoveVector<I32>(values.map((v) => new I32(v)));
+  }
+
+  /**
+   * Factory method to generate a MoveVector<I64> from an array of numbers or bigints.
+   *
+   * @param values - The values used to fill the MoveVector.
+   * @returns A MoveVector<I64> with the inner values.
+   *
+   * @example
+   * ```typescript
+   * const v = MoveVector.I64([-1n, 0n, 1n, 9223372036854775807n]);
+   * ```
+   * @group Implementation
+   * @category BCS
+   */
+  static I64(values: Array<AnyNumber>): MoveVector<I64> {
+    return new MoveVector<I64>(values.map((v) => new I64(v)));
+  }
+
+  /**
+   * Factory method to generate a MoveVector<I128> from an array of numbers or bigints.
+   *
+   * @param values - The values used to fill the MoveVector.
+   * @returns A MoveVector<I128> with the inner values.
+   *
+   * @example
+   * ```typescript
+   * const v = MoveVector.I128([-1n, 0n, 1n]);
+   * ```
+   * @group Implementation
+   * @category BCS
+   */
+  static I128(values: Array<AnyNumber>): MoveVector<I128> {
+    return new MoveVector<I128>(values.map((v) => new I128(v)));
+  }
+
+  /**
+   * Factory method to generate a MoveVector<I256> from an array of numbers or bigints.
+   *
+   * @param values - The values used to fill the MoveVector.
+   * @returns A MoveVector<I256> with the inner values.
+   *
+   * @example
+   * ```typescript
+   * const v = MoveVector.I256([-1n, 0n, 1n]);
+   * ```
+   * @group Implementation
+   * @category BCS
+   */
+  static I256(values: Array<AnyNumber>): MoveVector<I256> {
+    return new MoveVector<I256>(values.map((v) => new I256(v)));
+  }
+
   /**
    * Factory method to generate a MoveVector<MoveString> from a `string` or `undefined`.
    * This function creates a MoveVector that encapsulates a MoveString if the provided value is not null or undefined.
@@ -593,6 +695,108 @@ export class MoveOption<T extends Serializable & EntryFunctionArgument>
     return new MoveOption<Bool>(value !== null && value !== undefined ? new Bool(value) : undefined);
   }
 
+  /**
+   * Factory method to generate a MoveOption<I8> from a `number` or `undefined`.
+   *
+   * @example
+   * MoveOption.I8(1).isSome() === true;
+   * MoveOption.I8().isSome() === false;
+   * MoveOption.I8(undefined).isSome() === false;
+   * @param value the value used to fill the MoveOption. If `value` is undefined
+   * the resulting MoveOption's .isSome() method will return false.
+   * @returns a MoveOption<I8> with an inner value `value`
+   * @group Implementation
+   * @category BCS
+   */
+  static I8(value?: number | null): MoveOption<I8> {
+    return new MoveOption<I8>(value !== null && value !== undefined ? new I8(value) : undefined);
+  }
+
+  /**
+   * Factory method to generate a MoveOption<I16> from a `number` or `undefined`.
+   *
+   * @example
+   * MoveOption.I16(1).isSome() === true;
+   * MoveOption.I16().isSome() === false;
+   * MoveOption.I16(undefined).isSome() === false;
+   * @param value the value used to fill the MoveOption. If `value` is undefined
+   * the resulting MoveOption's .isSome() method will return false.
+   * @returns a MoveOption<I16> with an inner value `value`
+   * @group Implementation
+   * @category BCS
+   */
+  static I16(value?: number | null): MoveOption<I16> {
+    return new MoveOption<I16>(value !== null && value !== undefined ? new I16(value) : undefined);
+  }
+
+  /**
+   * Factory method to generate a MoveOption<I32> from a `number` or `undefined`.
+   *
+   * @example
+   * MoveOption.I32(1).isSome() === true;
+   * MoveOption.I32().isSome() === false;
+   * MoveOption.I32(undefined).isSome() === false;
+   * @param value the value used to fill the MoveOption. If `value` is undefined
+   * the resulting MoveOption's .isSome() method will return false.
+   * @returns a MoveOption<I32> with an inner value `value`
+   * @group Implementation
+   * @category BCS
+   */
+  static I32(value?: number | null): MoveOption<I32> {
+    return new MoveOption<I32>(value !== null && value !== undefined ? new I32(value) : undefined);
+  }
+
+  /**
+   * Factory method to generate a MoveOption<I64> from a `number` or a `bigint` or `undefined`.
+   *
+   * @example
+   * MoveOption.I64(1).isSome() === true;
+   * MoveOption.I64().isSome() === false;
+   * MoveOption.I64(undefined).isSome() === false;
+   * @param value the value used to fill the MoveOption. If `value` is undefined
+   * the resulting MoveOption's .isSome() method will return false.
+   * @returns a MoveOption<I64> with an inner value `value`
+   * @group Implementation
+   * @category BCS
+   */
+  static I64(value?: AnyNumber | null): MoveOption<I64> {
+    return new MoveOption<I64>(value !== null && value !== undefined ? new I64(value) : undefined);
+  }
+
+  /**
+   * Factory method to generate a MoveOption<I128> from a `number` or a `bigint` or `undefined`.
+   *
+   * @example
+   * MoveOption.I128(1).isSome() === true;
+   * MoveOption.I128().isSome() === false;
+   * MoveOption.I128(undefined).isSome() === false;
+   * @param value the value used to fill the MoveOption. If `value` is undefined
+   * the resulting MoveOption's .isSome() method will return false.
+   * @returns a MoveOption<I128> with an inner value `value`
+   * @group Implementation
+   * @category BCS
+   */
+  static I128(value?: AnyNumber | null): MoveOption<I128> {
+    return new MoveOption<I128>(value !== null && value !== undefined ? new I128(value) : undefined);
+  }
+
+  /**
+   * Factory method to generate a MoveOption<I256> from a `number` or a `bigint` or `undefined`.
+   *
+   * @example
+   * MoveOption.I256(1).isSome() === true;
+   * MoveOption.I256().isSome() === false;
+   * MoveOption.I256(undefined).isSome() === false;
+   * @param value the value used to fill the MoveOption. If `value` is undefined
+   * the resulting MoveOption's .isSome() method will return false.
+   * @returns a MoveOption<I256> with an inner value `value`
+   * @group Implementation
+   * @category BCS
+   */
+  static I256(value?: AnyNumber | null): MoveOption<I256> {
+    return new MoveOption<I256>(value !== null && value !== undefined ? new I256(value) : undefined);
+  }
+
   /**
    * Factory method to generate a MoveOption<MoveString> from a `string` or `undefined`.
    *

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/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