@aptos-labs/ts-sdk 5.1.2 → 5.1.4

package/src/bcs/serializable/movePrimitives.ts

@@ -8,11 +8,23 @@ import {
   MAX_U64_BIG_INT,
   MAX_U8_NUMBER,
   MAX_U256_BIG_INT,
+  MIN_I8_NUMBER,
+  MAX_I8_NUMBER,
+  MIN_I16_NUMBER,
+  MAX_I16_NUMBER,
+  MIN_I32_NUMBER,
+  MAX_I32_NUMBER,
+  MIN_I64_BIG_INT,
+  MAX_I64_BIG_INT,
+  MIN_I128_BIG_INT,
+  MAX_I128_BIG_INT,
+  MIN_I256_BIG_INT,
+  MAX_I256_BIG_INT,
 } from "../consts";
 import { Deserializer } from "../deserializer";
 import { Serializable, Serializer, ensureBoolean, validateNumberInRange } from "../serializer";
 import { TransactionArgument } from "../../transactions/instances/transactionArgument";
-import { AnyNumber, Uint16, Uint32, Uint8, ScriptTransactionArgumentVariants } from "../../types";
+import { AnyNumber, Uint16, Uint32, Uint8, Int8, Int16, Int32, ScriptTransactionArgumentVariants } from "../../types";
 
 /**
  * Represents a boolean value that can be serialized and deserialized.
@@ -326,3 +338,227 @@ export class U256 extends Serializable implements TransactionArgument {
     return new U256(deserializer.deserializeU256());
   }
 }
+
+/**
+ * Represents an 8-bit signed integer (I8) value.
+ * This class extends the Serializable class and provides methods for serialization and deserialization of I8 values.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category BCS
+ */
+export class I8 extends Serializable implements TransactionArgument {
+  public readonly value: Int8;
+
+  constructor(value: Int8) {
+    super();
+    validateNumberInRange(value, MIN_I8_NUMBER, MAX_I8_NUMBER);
+    this.value = value;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeI8(this.value);
+  }
+
+  serializeForEntryFunction(serializer: Serializer): void {
+    const bcsBytes = this.bcsToBytes();
+    serializer.serializeBytes(bcsBytes);
+  }
+
+  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);
+  }
+
+  static deserialize(deserializer: Deserializer): I8 {
+    return new I8(deserializer.deserializeI8());
+  }
+}
+
+/**
+ * Represents a 16-bit signed integer (I16) value.
+ * This class extends the Serializable class and provides methods for serialization
+ * and deserialization of the I16 value.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category BCS
+ */
+export class I16 extends Serializable implements TransactionArgument {
+  public readonly value: Int16;
+
+  constructor(value: Int16) {
+    super();
+    validateNumberInRange(value, MIN_I16_NUMBER, MAX_I16_NUMBER);
+    this.value = value;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeI16(this.value);
+  }
+
+  serializeForEntryFunction(serializer: Serializer): void {
+    const bcsBytes = this.bcsToBytes();
+    serializer.serializeBytes(bcsBytes);
+  }
+
+  serializeForScriptFunction(serializer: Serializer): void {
+    const bcsBytes = this.bcsToBytes();
+    serializer.serializeBytes(bcsBytes);
+  }
+
+  static deserialize(deserializer: Deserializer): I16 {
+    return new I16(deserializer.deserializeI16());
+  }
+}
+
+/**
+ * Represents a 32-bit signed integer (I32) that can be serialized and deserialized.
+ * This class ensures that the value is within the valid range for an I32.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category BCS
+ */
+export class I32 extends Serializable implements TransactionArgument {
+  public readonly value: Int32;
+
+  constructor(value: Int32) {
+    super();
+    validateNumberInRange(value, MIN_I32_NUMBER, MAX_I32_NUMBER);
+    this.value = value;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeI32(this.value);
+  }
+
+  serializeForEntryFunction(serializer: Serializer): void {
+    const bcsBytes = this.bcsToBytes();
+    serializer.serializeBytes(bcsBytes);
+  }
+
+  serializeForScriptFunction(serializer: Serializer): void {
+    const bcsBytes = this.bcsToBytes();
+    serializer.serializeBytes(bcsBytes);
+  }
+
+  static deserialize(deserializer: Deserializer): I32 {
+    return new I32(deserializer.deserializeI32());
+  }
+}
+
+/**
+ * Represents a 64-bit signed integer (I64) and provides methods for serialization.
+ *
+ * This class ensures that the value is within the valid range for an I64 and provides
+ * functionality to serialize the value for various use cases, including entry functions
+ * and script functions.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category BCS
+ */
+export class I64 extends Serializable implements TransactionArgument {
+  public readonly value: bigint;
+
+  constructor(value: AnyNumber) {
+    super();
+    validateNumberInRange(value, MIN_I64_BIG_INT, MAX_I64_BIG_INT);
+    this.value = BigInt(value);
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeI64(this.value);
+  }
+
+  serializeForEntryFunction(serializer: Serializer): void {
+    const bcsBytes = this.bcsToBytes();
+    serializer.serializeBytes(bcsBytes);
+  }
+
+  serializeForScriptFunction(serializer: Serializer): void {
+    const bcsBytes = this.bcsToBytes();
+    serializer.serializeBytes(bcsBytes);
+  }
+
+  static deserialize(deserializer: Deserializer): I64 {
+    return new I64(deserializer.deserializeI64());
+  }
+}
+
+/**
+ * Represents a 128-bit signed integer value.
+ * This class provides methods for serialization and deserialization
+ * of I128 values, ensuring that the values are within the valid range.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category BCS
+ */
+export class I128 extends Serializable implements TransactionArgument {
+  public readonly value: bigint;
+
+  constructor(value: AnyNumber) {
+    super();
+    validateNumberInRange(value, MIN_I128_BIG_INT, MAX_I128_BIG_INT);
+    this.value = BigInt(value);
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeI128(this.value);
+  }
+
+  serializeForEntryFunction(serializer: Serializer): void {
+    const bcsBytes = this.bcsToBytes();
+    serializer.serializeBytes(bcsBytes);
+  }
+
+  serializeForScriptFunction(serializer: Serializer): void {
+    const bcsBytes = this.bcsToBytes();
+    serializer.serializeBytes(bcsBytes);
+  }
+
+  static deserialize(deserializer: Deserializer): I128 {
+    return new I128(deserializer.deserializeI128());
+  }
+}
+
+/**
+ * Represents a 256-bit signed integer (I256) that extends the Serializable class.
+ * This class provides methods for serialization and deserialization of I256 values,
+ * ensuring that the values are within the valid range.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category BCS
+ */
+export class I256 extends Serializable implements TransactionArgument {
+  public readonly value: bigint;
+
+  constructor(value: AnyNumber) {
+    super();
+    validateNumberInRange(value, MIN_I256_BIG_INT, MAX_I256_BIG_INT);
+    this.value = BigInt(value);
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeI256(this.value);
+  }
+
+  serializeForEntryFunction(serializer: Serializer): void {
+    const bcsBytes = this.bcsToBytes();
+    serializer.serializeBytes(bcsBytes);
+  }
+
+  serializeForScriptFunction(serializer: Serializer): void {
+    const bcsBytes = this.bcsToBytes();
+    serializer.serializeBytes(bcsBytes);
+  }
+
+  static deserialize(deserializer: Deserializer): I256 {
+    return new I256(deserializer.deserializeI256());
+  }
+}

package/src/bcs/serializer.ts

@@ -9,6 +9,18 @@ import {
   MAX_U64_BIG_INT,
   MAX_U8_NUMBER,
   MAX_U256_BIG_INT,
+  MIN_I8_NUMBER,
+  MAX_I8_NUMBER,
+  MIN_I16_NUMBER,
+  MAX_I16_NUMBER,
+  MIN_I32_NUMBER,
+  MAX_I32_NUMBER,
+  MIN_I64_BIG_INT,
+  MAX_I64_BIG_INT,
+  MIN_I128_BIG_INT,
+  MAX_I128_BIG_INT,
+  MIN_I256_BIG_INT,
+  MAX_I256_BIG_INT,
 } from "./consts";
 import { Hex } from "../core/hex";
 import { AnyNumber, Uint16, Uint32, Uint8 } from "../types";
@@ -338,6 +350,105 @@ export class Serializer {
     this.serializeU128(high);
   }
 
+  /**
+   * Serializes an 8-bit signed integer value.
+   * BCS layout for "int8": One byte. Binary format in little-endian representation.
+   *
+   * @param value - The 8-bit signed integer value to serialize.
+   * @group Implementation
+   * @category BCS
+   */
+  @checkNumberRange(MIN_I8_NUMBER, MAX_I8_NUMBER)
+  serializeI8(value: number) {
+    this.serializeWithFunction(DataView.prototype.setInt8, 1, value);
+  }
+
+  /**
+   * Serializes a 16-bit signed integer value into a binary format.
+   * BCS layout for "int16": Two bytes. Binary format in little-endian representation.
+   *
+   * @param value - The 16-bit signed integer value to serialize.
+   * @group Implementation
+   * @category BCS
+   */
+  @checkNumberRange(MIN_I16_NUMBER, MAX_I16_NUMBER)
+  serializeI16(value: number) {
+    this.serializeWithFunction(DataView.prototype.setInt16, 2, value);
+  }
+
+  /**
+   * Serializes a 32-bit signed integer value into a binary format.
+   *
+   * @param value - The 32-bit signed integer value to serialize.
+   * @group Implementation
+   * @category BCS
+   */
+  @checkNumberRange(MIN_I32_NUMBER, MAX_I32_NUMBER)
+  serializeI32(value: number) {
+    this.serializeWithFunction(DataView.prototype.setInt32, 4, value);
+  }
+
+  /**
+   * Serializes a 64-bit signed integer into a format suitable for storage or transmission.
+   * This function uses two's complement representation for negative values.
+   *
+   * @param value - The 64-bit signed integer to serialize.
+   * @group Implementation
+   * @category BCS
+   */
+  @checkNumberRange(MIN_I64_BIG_INT, MAX_I64_BIG_INT)
+  serializeI64(value: AnyNumber) {
+    const val = BigInt(value);
+    // Convert to unsigned representation using two's complement
+    const unsigned = val < 0 ? (BigInt(1) << BigInt(64)) + val : val;
+    const low = unsigned & BigInt(MAX_U32_NUMBER);
+    const high = unsigned >> BigInt(32);
+
+    // write little endian number
+    this.serializeU32(Number(low));
+    this.serializeU32(Number(high));
+  }
+
+  /**
+   * Serializes a 128-bit signed integer value.
+   *
+   * @param value - The 128-bit signed integer value to serialize.
+   * @group Implementation
+   * @category BCS
+   */
+  @checkNumberRange(MIN_I128_BIG_INT, MAX_I128_BIG_INT)
+  serializeI128(value: AnyNumber) {
+    const val = BigInt(value);
+    // Convert to unsigned representation using two's complement
+    const unsigned = val < 0 ? (BigInt(1) << BigInt(128)) + val : val;
+    const low = unsigned & MAX_U64_BIG_INT;
+    const high = unsigned >> BigInt(64);
+
+    // write little endian number
+    this.serializeU64(low);
+    this.serializeU64(high);
+  }
+
+  /**
+   * Serializes a 256-bit signed integer value.
+   *
+   * @param value - The 256-bit signed integer value to serialize.
+   * @group Implementation
+   * @category BCS
+   */
+  @checkNumberRange(MIN_I256_BIG_INT, MAX_I256_BIG_INT)
+  serializeI256(value: AnyNumber) {
+    const val = BigInt(value);
+    // Convert to unsigned representation using two's complement
+    const unsigned = val < 0 ? (BigInt(1) << BigInt(256)) + val : val;
+    const low = unsigned & MAX_U128_BIG_INT;
+    const high = unsigned >> BigInt(128);
+
+    // write little endian number
+    this.serializeU128(low);
+    this.serializeU128(high);
+  }
+
   /**
    * Serializes a 32-bit unsigned integer as a variable-length ULEB128 encoded byte array.
    * BCS uses uleb128 encoding in two cases: (1) lengths of variable-length sequences and (2) tags of enum values

package/src/transactions/typeTag/index.ts

@@ -63,6 +63,18 @@ export abstract class TypeTag extends Serializable {
         return TypeTagU32.load(deserializer);
       case TypeTagVariants.U256:
         return TypeTagU256.load(deserializer);
+      case TypeTagVariants.I8:
+        return TypeTagI8.load(deserializer);
+      case TypeTagVariants.I16:
+        return TypeTagI16.load(deserializer);
+      case TypeTagVariants.I32:
+        return TypeTagI32.load(deserializer);
+      case TypeTagVariants.I64:
+        return TypeTagI64.load(deserializer);
+      case TypeTagVariants.I128:
+        return TypeTagI128.load(deserializer);
+      case TypeTagVariants.I256:
+        return TypeTagI256.load(deserializer);
       case TypeTagVariants.Generic:
         // This is only used for ABI representation, and cannot actually be used as a type.
         return TypeTagGeneric.load(deserializer);
@@ -206,6 +218,26 @@ export abstract class TypeTag extends Serializable {
     return this instanceof TypeTagU256;
   }
 
+  /** Signed integer helpers */
+  isI8(): this is TypeTagI8 {
+    return this instanceof TypeTagI8;
+  }
+  isI16(): this is TypeTagI16 {
+    return this instanceof TypeTagI16;
+  }
+  isI32(): this is TypeTagI32 {
+    return this instanceof TypeTagI32;
+  }
+  isI64(): this is TypeTagI64 {
+    return this instanceof TypeTagI64;
+  }
+  isI128(): this is TypeTagI128 {
+    return this instanceof TypeTagI128;
+  }
+  isI256(): this is TypeTagI256 {
+    return this instanceof TypeTagI256;
+  }
+
   isPrimitive(): boolean {
     return (
       this instanceof TypeTagSigner ||
@@ -216,7 +248,13 @@ export abstract class TypeTag extends Serializable {
       this instanceof TypeTagU32 ||
       this instanceof TypeTagU64 ||
       this instanceof TypeTagU128 ||
-      this instanceof TypeTagU256
+      this instanceof TypeTagU256 ||
+      this instanceof TypeTagI8 ||
+      this instanceof TypeTagI16 ||
+      this instanceof TypeTagI32 ||
+      this instanceof TypeTagI64 ||
+      this instanceof TypeTagI128 ||
+      this instanceof TypeTagI256
     );
   }
 }
@@ -290,6 +328,29 @@ export class TypeTagU8 extends TypeTag {
   }
 }
 
+/**
+ * Represents a type tag for an 8-bit signed integer (i8).
+ * This class extends the base TypeTag class and provides methods
+ * for serialization and deserialization specific to the i8 type.
+ *
+ * @extends TypeTag
+ * @group Implementation
+ * @category Transactions
+ */
+export class TypeTagI8 extends TypeTag {
+  toString(): string {
+    return "i8";
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TypeTagVariants.I8);
+  }
+
+  static load(_deserializer: Deserializer): TypeTagI8 {
+    return new TypeTagI8();
+  }
+}
+
 /**
  * Represents a type tag for unsigned 16-bit integers (u16).
  * This class extends the base TypeTag class and provides methods for serialization and deserialization.
@@ -312,6 +373,28 @@ export class TypeTagU16 extends TypeTag {
   }
 }
 
+/**
+ * Represents a type tag for signed 16-bit integers (i16).
+ * This class extends the base TypeTag class and provides methods for serialization and deserialization.
+ *
+ * @extends TypeTag
+ * @group Implementation
+ * @category Transactions
+ */
+export class TypeTagI16 extends TypeTag {
+  toString(): string {
+    return "i16";
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TypeTagVariants.I16);
+  }
+
+  static load(_deserializer: Deserializer): TypeTagI16 {
+    return new TypeTagI16();
+  }
+}
+
 /**
  * Represents a type tag for a 32-bit unsigned integer (u32).
  * This class extends the base TypeTag class and provides methods for serialization
@@ -335,6 +418,29 @@ export class TypeTagU32 extends TypeTag {
   }
 }
 
+/**
+ * Represents a type tag for a 32-bit signed integer (i32).
+ * This class extends the base TypeTag class and provides methods for serialization
+ * and deserialization specific to the i32 type.
+ *
+ * @extends TypeTag
+ * @group Implementation
+ * @category Transactions
+ */
+export class TypeTagI32 extends TypeTag {
+  toString(): string {
+    return "i32";
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TypeTagVariants.I32);
+  }
+
+  static load(_deserializer: Deserializer): TypeTagI32 {
+    return new TypeTagI32();
+  }
+}
+
 /**
  * Represents a type tag for 64-bit unsigned integers (u64).
  * This class extends the base TypeTag class and provides methods for serialization and deserialization.
@@ -357,6 +463,28 @@ export class TypeTagU64 extends TypeTag {
   }
 }
 
+/**
+ * Represents a type tag for 64-bit signed integers (i64).
+ * This class extends the base TypeTag class and provides methods for serialization and deserialization.
+ *
+ * @extends TypeTag
+ * @group Implementation
+ * @category Transactions
+ */
+export class TypeTagI64 extends TypeTag {
+  toString(): string {
+    return "i64";
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TypeTagVariants.I64);
+  }
+
+  static load(_deserializer: Deserializer): TypeTagI64 {
+    return new TypeTagI64();
+  }
+}
+
 /**
  * Represents a type tag for the u128 data type.
  * This class extends the base TypeTag class and provides methods for serialization and deserialization.
@@ -379,6 +507,28 @@ export class TypeTagU128 extends TypeTag {
   }
 }
 
+/**
+ * Represents a type tag for the i128 data type.
+ * This class extends the base TypeTag class and provides methods for serialization and deserialization.
+ *
+ * @extends TypeTag
+ * @group Implementation
+ * @category Transactions
+ */
+export class TypeTagI128 extends TypeTag {
+  toString(): string {
+    return "i128";
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TypeTagVariants.I128);
+  }
+
+  static load(_deserializer: Deserializer): TypeTagI128 {
+    return new TypeTagI128();
+  }
+}
+
 /**
  * Represents a type tag for the U256 data type.
  * This class extends the base TypeTag class and provides methods for serialization and deserialization.
@@ -401,6 +551,28 @@ export class TypeTagU256 extends TypeTag {
   }
 }
 
+/**
+ * Represents a type tag for the I256 data type.
+ * This class extends the base TypeTag class and provides methods for serialization and deserialization.
+ *
+ * @extends TypeTag
+ * @group Implementation
+ * @category Transactions
+ */
+export class TypeTagI256 extends TypeTag {
+  toString(): string {
+    return "i256";
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TypeTagVariants.I256);
+  }
+
+  static load(_deserializer: Deserializer): TypeTagI256 {
+    return new TypeTagI256();
+  }
+}
+
 /**
  * Represents a type tag for an address in the system.
  * This class extends the TypeTag class and provides functionality

package/src/transactions/typeTag/parser.ts

@@ -16,6 +16,12 @@ import {
   TypeTagU32,
   TypeTagU64,
   TypeTagU8,
+  TypeTagI8,
+  TypeTagI16,
+  TypeTagI32,
+  TypeTagI64,
+  TypeTagI128,
+  TypeTagI256,
   TypeTagVector,
 } from ".";
 import { AccountAddress } from "../../core";
@@ -79,6 +85,12 @@ function isPrimitive(str: string) {
     case "u64":
     case "u128":
     case "u256":
+    case "i8":
+    case "i16":
+    case "i32":
+    case "i64":
+    case "i128":
+    case "i256":
       return true;
     default:
       return false;
@@ -354,6 +366,18 @@ function parseTypeTagInner(str: string, types: Array<TypeTag>, allowGenerics: bo
       return new TypeTagU128();
     case "u256":
       return new TypeTagU256();
+    case "i8":
+      return new TypeTagI8();
+    case "i16":
+      return new TypeTagI16();
+    case "i32":
+      return new TypeTagI32();
+    case "i64":
+      return new TypeTagI64();
+    case "i128":
+      return new TypeTagI128();
+    case "i256":
+      return new TypeTagI256();
     case "vector":
       if (types.length !== 1) {
         throw new TypeTagParserError(str, TypeTagParserErrorType.UnexpectedVectorTypeArgumentCount);

package/src/types/types.ts

@@ -46,6 +46,12 @@ export enum TypeTagVariants {
   U16 = 8,
   U32 = 9,
   U256 = 10,
+  I8 = 11,
+  I16 = 12,
+  I32 = 13,
+  I64 = 14,
+  I128 = 15,
+  I256 = 16,
   Reference = 254, // This is specifically a placeholder and does not represent a real type
   Generic = 255, // This is specifically a placeholder and does not represent a real type
 }
@@ -246,6 +252,36 @@ export type Uint128 = bigint;
  */
 export type Uint256 = bigint;
 
+/**
+ * A signed 8-bit integer.
+ */
+export type Int8 = number;
+
+/**
+ * A signed 16-bit integer.
+ */
+export type Int16 = number;
+
+/**
+ * A signed 32-bit integer.
+ */
+export type Int32 = number;
+
+/**
+ * A signed 64-bit integer.
+ */
+export type Int64 = bigint;
+
+/**
+ * A signed 128-bit integer.
+ */
+export type Int128 = bigint;
+
+/**
+ * A signed 256-bit integer.
+ */
+export type Int256 = bigint;
+
 /**
  * A number or a bigint value.
  */

package/src/version.ts

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