@moveindustries/ts-sdk 5.1.4

package/src/transactions/index.ts

@@ -0,0 +1,10 @@
+// Copyright © Move Industries
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./authenticator";
+export * from "./instances";
+export * from "./transactionBuilder";
+export * from "./types";
+export * from "./typeTag";
+export * from "./typeTag/parser";
+

package/src/transactions/instances/chainId.ts

@@ -0,0 +1,53 @@
+// Copyright © Move Industries
+// SPDX-License-Identifier: Apache-2.0
+
+import { Deserializer } from "../../bcs/deserializer";
+import { Serializable, Serializer } from "../../bcs/serializer";
+
+/**
+ * Represents a ChainId that can be serialized and deserialized.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category Transactions
+ */
+export class ChainId extends Serializable {
+  public readonly chainId: number;
+
+  /**
+   * Initializes a new instance of the class with the specified chain ID.
+   *
+   * @param chainId - The ID of the blockchain network to be used.
+   * @group Implementation
+   * @category Transactions
+   */
+  constructor(chainId: number) {
+    super();
+    this.chainId = chainId;
+  }
+
+  /**
+   * Serializes the current object using the provided serializer.
+   * This function helps in converting the object into a format suitable for transmission or storage.
+   *
+   * @param serializer - The serializer instance used to perform the serialization.
+   * @group Implementation
+   * @category Transactions
+   */
+  serialize(serializer: Serializer): void {
+    serializer.serializeU8(this.chainId);
+  }
+
+  /**
+   * Deserializes a ChainId from the provided deserializer.
+   * This function allows you to reconstruct a ChainId object from serialized data.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   * @group Implementation
+   * @category Transactions
+   */
+  static deserialize(deserializer: Deserializer): ChainId {
+    const chainId = deserializer.deserializeU8();
+    return new ChainId(chainId);
+  }
+}

package/src/transactions/instances/identifier.ts

@@ -0,0 +1,54 @@
+// Copyright © Move Industries
+// SPDX-License-Identifier: Apache-2.0
+
+import { Deserializer } from "../../bcs/deserializer";
+import { Serializable, Serializer } from "../../bcs/serializer";
+
+/**
+ * Represents an Identifier that can be serialized and deserialized.
+ * This class is used to denote the module "name" in "ModuleId" and
+ * the "function name" in "EntryFunction".
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category Transactions
+ */
+export class Identifier extends Serializable {
+  public identifier: string;
+
+  /**
+   * Creates an instance of the class with a specified identifier.
+   *
+   * @param identifier - The unique identifier for the instance.
+   * @group Implementation
+   * @category Transactions
+   */
+  constructor(identifier: string) {
+    super();
+    this.identifier = identifier;
+  }
+
+  /**
+   * Serializes the identifier of the current instance using the provided serializer.
+   *
+   * @param serializer - The serializer instance used to perform the serialization.
+   * @group Implementation
+   * @category Transactions
+   */
+  public serialize(serializer: Serializer): void {
+    serializer.serializeStr(this.identifier);
+  }
+
+  /**
+   * Deserializes an identifier from the provided deserializer.
+   * This function is useful for reconstructing an Identifier object from a serialized format.
+   *
+   * @param deserializer - The deserializer instance used to read the serialized data.
+   * @group Implementation
+   * @category Transactions
+   */
+  static deserialize(deserializer: Deserializer): Identifier {
+    const identifier = deserializer.deserializeStr();
+    return new Identifier(identifier);
+  }
+}

package/src/transactions/instances/index.ts

@@ -0,0 +1,14 @@
+// Copyright © Move Industries
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./chainId";
+export * from "./identifier";
+export * from "./moduleId";
+export * from "./multiAgentTransaction";
+export * from "./rawTransaction";
+export * from "./rotationProofChallenge";
+export * from "./signedTransaction";
+export * from "./simpleTransaction";
+export * from "./transactionArgument";
+export * from "./transactionPayload";
+

package/src/transactions/instances/moduleId.ts

@@ -0,0 +1,77 @@
+// Copyright © Move Industries
+// SPDX-License-Identifier: Apache-2.0
+
+import { Deserializer } from "../../bcs/deserializer";
+import { Serializable, Serializer } from "../../bcs/serializer";
+import { AccountAddress } from "../../core";
+import { MoveModuleId } from "../../types";
+import { Identifier } from "./identifier";
+
+/**
+ * Represents a ModuleId that can be serialized and deserialized.
+ * A ModuleId consists of a module address (e.g., "0x1") and a module name (e.g., "coin").
+ * @group Implementation
+ * @category Transactions
+ */
+export class ModuleId extends Serializable {
+  public readonly address: AccountAddress;
+
+  public readonly name: Identifier;
+
+  /**
+   * Initializes a new instance of the module with the specified account address and name.
+   *
+   * @param address - The account address, e.g., "0x1".
+   * @param name - The module name under the specified address, e.g., "coin".
+   * @group Implementation
+   * @category Transactions
+   */
+  constructor(address: AccountAddress, name: Identifier) {
+    super();
+    this.address = address;
+    this.name = name;
+  }
+
+  /**
+   * Converts a string literal in the format "account_address::module_name" to a ModuleId.
+   * @param moduleId - A string literal representing the module identifier.
+   * @throws Error if the provided moduleId is not in the correct format.
+   * @returns ModuleId - The corresponding ModuleId object.
+   * @group Implementation
+   * @category Transactions
+   */
+  static fromStr(moduleId: MoveModuleId): ModuleId {
+    const parts = moduleId.split("::");
+    if (parts.length !== 2) {
+      throw new Error("Invalid module id.");
+    }
+    return new ModuleId(AccountAddress.fromString(parts[0]), new Identifier(parts[1]));
+  }
+
+  /**
+   * Serializes the address and name properties using the provided serializer.
+   * This function is essential for converting the object's data into a format suitable for transmission or storage.
+   *
+   * @param serializer - The serializer instance used to perform the serialization.
+   * @group Implementation
+   * @category Transactions
+   */
+  serialize(serializer: Serializer): void {
+    this.address.serialize(serializer);
+    this.name.serialize(serializer);
+  }
+
+  /**
+   * Deserializes a ModuleId from the provided deserializer.
+   * This function retrieves the account address and identifier to construct a ModuleId instance.
+   *
+   * @param deserializer - The deserializer instance used to read the data.
+   * @group Implementation
+   * @category Transactions
+   */
+  static deserialize(deserializer: Deserializer): ModuleId {
+    const address = AccountAddress.deserialize(deserializer);
+    const name = Identifier.deserialize(deserializer);
+    return new ModuleId(address, name);
+  }
+}

package/src/transactions/instances/multiAgentTransaction.ts

@@ -0,0 +1,92 @@
+// Copyright © Move Industries
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import { Deserializer } from "../../bcs/deserializer";
+import { Serializable, Serializer } from "../../bcs/serializer";
+import { AccountAddress } from "../../core";
+import { RawTransaction } from "./rawTransaction";
+
+/**
+ * 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.
+ * @group Implementation
+ * @category Transactions
+ */
+export class MultiAgentTransaction extends Serializable {
+  public rawTransaction: RawTransaction;
+
+  public feePayerAddress?: AccountAddress | undefined;
+
+  public secondarySignerAddresses: AccountAddress[];
+
+  /**
+   * Represents a MultiAgentTransaction that can be submitted to the Movement chain for execution.
+   * This class encapsulates the raw transaction data, the secondary signer addresses, and an optional fee payer 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.
+   * @group Implementation
+   * @category Transactions
+   */
+  constructor(
+    rawTransaction: RawTransaction,
+    secondarySignerAddresses: AccountAddress[],
+    feePayerAddress?: AccountAddress,
+  ) {
+    super();
+    this.rawTransaction = rawTransaction;
+    this.feePayerAddress = feePayerAddress;
+    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.
+   * @group Implementation
+   * @category Transactions
+   */
+  serialize(serializer: Serializer): void {
+    this.rawTransaction.serialize(serializer);
+
+    serializer.serializeVector<AccountAddress>(this.secondarySignerAddresses);
+
+    if (this.feePayerAddress === undefined) {
+      serializer.serializeBool(false);
+    } else {
+      serializer.serializeBool(true);
+      this.feePayerAddress.serialize(serializer);
+    }
+  }
+
+  /**
+   * 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.
+   * @group Implementation
+   * @category Transactions
+   */
+  static deserialize(deserializer: Deserializer): MultiAgentTransaction {
+    const rawTransaction = RawTransaction.deserialize(deserializer);
+
+    const secondarySignerAddresses = deserializer.deserializeVector(AccountAddress);
+
+    const feePayerPresent = deserializer.deserializeBool();
+    let feePayerAddress;
+    if (feePayerPresent) {
+      feePayerAddress = AccountAddress.deserialize(deserializer);
+    }
+
+    return new MultiAgentTransaction(rawTransaction, secondarySignerAddresses, feePayerAddress);
+  }
+}

package/src/transactions/instances/rawTransaction.ts

@@ -0,0 +1,256 @@
+// Copyright © Move Industries
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import { Deserializer } from "../../bcs/deserializer";
+import { Serializable, Serializer } from "../../bcs/serializer";
+import { AccountAddress } from "../../core";
+import { TransactionVariants } from "../../types";
+import { ChainId } from "./chainId";
+import { TransactionPayload } from "./transactionPayload";
+
+/**
+ * Represents a raw transaction that can be serialized and deserialized.
+ * Raw transactions contain the metadata and payloads that can be submitted to the Movement chain for execution.
+ * They must be signed before the Movement chain can execute them.
+ * @group Implementation
+ * @category Transactions
+ */
+export class RawTransaction extends Serializable {
+  public readonly sender: AccountAddress;
+
+  public readonly sequence_number: bigint;
+
+  public readonly payload: TransactionPayload;
+
+  public readonly max_gas_amount: bigint;
+
+  public readonly gas_unit_price: bigint;
+
+  public readonly expiration_timestamp_secs: bigint;
+
+  public readonly chain_id: ChainId;
+
+  /**
+   * RawTransactions contain the metadata and payloads that can be submitted to Movement chain for execution.
+   * RawTransactions must be signed before Movement chain can execute them.
+   *
+   * @param sender The sender Account Address
+   * @param sequence_number Sequence number of this transaction. This must match the sequence number stored in
+   *   the sender's account at the time the transaction executes.
+   * @param payload Instructions for the Movement Blockchain, including publishing a module,
+   *   execute an entry function or execute a script payload.
+   * @param max_gas_amount Maximum total gas to spend for this transaction. The account must have more
+   *   than this gas or the transaction will be discarded during validation.
+   * @param gas_unit_price Price to be paid per gas unit.
+   * @param expiration_timestamp_secs The blockchain timestamp at which the blockchain would discard this transaction.
+   * @param chain_id The chain ID of the blockchain that this transaction is intended to be run on.
+   * @group Implementation
+   * @category Transactions
+   */
+  constructor(
+    sender: AccountAddress,
+    sequence_number: bigint,
+    payload: TransactionPayload,
+    max_gas_amount: bigint,
+    gas_unit_price: bigint,
+    expiration_timestamp_secs: bigint,
+    chain_id: ChainId,
+  ) {
+    super();
+    this.sender = sender;
+    this.sequence_number = sequence_number;
+    this.payload = payload;
+    this.max_gas_amount = max_gas_amount;
+    this.gas_unit_price = gas_unit_price;
+    this.expiration_timestamp_secs = expiration_timestamp_secs;
+    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.
+   * @group Implementation
+   * @category Transactions
+   */
+  serialize(serializer: Serializer): void {
+    this.sender.serialize(serializer);
+    serializer.serializeU64(this.sequence_number);
+    this.payload.serialize(serializer);
+    serializer.serializeU64(this.max_gas_amount);
+    serializer.serializeU64(this.gas_unit_price);
+    serializer.serializeU64(this.expiration_timestamp_secs);
+    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.
+   * @group Implementation
+   * @category Transactions
+   */
+  static deserialize(deserializer: Deserializer): RawTransaction {
+    const sender = AccountAddress.deserialize(deserializer);
+    const sequence_number = deserializer.deserializeU64();
+    const payload = TransactionPayload.deserialize(deserializer);
+    const max_gas_amount = deserializer.deserializeU64();
+    const gas_unit_price = deserializer.deserializeU64();
+    const expiration_timestamp_secs = deserializer.deserializeU64();
+    const chain_id = ChainId.deserialize(deserializer);
+    return new RawTransaction(
+      sender,
+      sequence_number,
+      payload,
+      max_gas_amount,
+      gas_unit_price,
+      expiration_timestamp_secs,
+      chain_id,
+    );
+  }
+}
+
+/**
+ * Represents a raw transaction with associated data that can be serialized and deserialized.
+ *
+ * @extends Serializable
+ * @group Implementation
+ * @category Transactions
+ */
+export abstract class RawTransactionWithData extends Serializable {
+  /**
+   * Serialize a Raw Transaction With Data
+   * @group Implementation
+   * @category Transactions
+   */
+  abstract serialize(serializer: Serializer): void;
+
+  /**
+   * Deserialize a Raw Transaction With Data
+   * @group Implementation
+   * @category Transactions
+   */
+  static deserialize(deserializer: Deserializer): RawTransactionWithData {
+    // index enum variant
+    const index = deserializer.deserializeUleb128AsU32();
+    switch (index) {
+      case TransactionVariants.MultiAgentTransaction:
+        return MultiAgentRawTransaction.load(deserializer);
+      case TransactionVariants.FeePayerTransaction:
+        return FeePayerRawTransaction.load(deserializer);
+      default:
+        throw new Error(`Unknown variant index for RawTransactionWithData: ${index}`);
+    }
+  }
+}
+
+/**
+ * Represents a multi-agent transaction that can be serialized and deserialized.
+ *
+ * @extends RawTransactionWithData
+ * @group Implementation
+ * @category Transactions
+ */
+export class MultiAgentRawTransaction extends RawTransactionWithData {
+  /**
+   * The raw transaction
+   * @group Implementation
+   * @category Transactions
+   */
+  public readonly raw_txn: RawTransaction;
+
+  /**
+   * The secondary signers on this transaction
+   * @group Implementation
+   * @category Transactions
+   */
+  public readonly secondary_signer_addresses: Array<AccountAddress>;
+
+  constructor(raw_txn: RawTransaction, secondary_signer_addresses: Array<AccountAddress>) {
+    super();
+    this.raw_txn = raw_txn;
+    this.secondary_signer_addresses = secondary_signer_addresses;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TransactionVariants.MultiAgentTransaction);
+    this.raw_txn.serialize(serializer);
+    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.
+   * @group Implementation
+   * @category Transactions
+   */
+  static load(deserializer: Deserializer): MultiAgentRawTransaction {
+    const rawTxn = RawTransaction.deserialize(deserializer);
+    const secondarySignerAddresses = deserializer.deserializeVector(AccountAddress);
+
+    return new MultiAgentRawTransaction(rawTxn, secondarySignerAddresses);
+  }
+}
+
+/**
+ * Represents a Fee Payer Transaction that can be serialized and deserialized.
+ * @group Implementation
+ * @category Transactions
+ */
+export class FeePayerRawTransaction extends RawTransactionWithData {
+  /**
+   * The raw transaction
+   * @group Implementation
+   * @category Transactions
+   */
+  public readonly raw_txn: RawTransaction;
+
+  /**
+   * The secondary signers on this transaction - optional and can be empty
+   * @group Implementation
+   * @category Transactions
+   */
+  public readonly secondary_signer_addresses: Array<AccountAddress>;
+
+  /**
+   * The fee payer account address
+   * @group Implementation
+   * @category Transactions
+   */
+  public readonly fee_payer_address: AccountAddress;
+
+  constructor(
+    raw_txn: RawTransaction,
+    secondary_signer_addresses: Array<AccountAddress>,
+    fee_payer_address: AccountAddress,
+  ) {
+    super();
+    this.raw_txn = raw_txn;
+    this.secondary_signer_addresses = secondary_signer_addresses;
+    this.fee_payer_address = fee_payer_address;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TransactionVariants.FeePayerTransaction);
+    this.raw_txn.serialize(serializer);
+    serializer.serializeVector(this.secondary_signer_addresses);
+    this.fee_payer_address.serialize(serializer);
+  }
+
+  static load(deserializer: Deserializer): FeePayerRawTransaction {
+    const rawTxn = RawTransaction.deserialize(deserializer);
+    const secondarySignerAddresses = deserializer.deserializeVector(AccountAddress);
+    const feePayerAddress = AccountAddress.deserialize(deserializer);
+
+    return new FeePayerRawTransaction(rawTxn, secondarySignerAddresses, feePayerAddress);
+  }
+}

package/src/transactions/instances/rotationProofChallenge.ts

@@ -0,0 +1,86 @@
+// Copyright © Move Industries
+// SPDX-License-Identifier: Apache-2.0
+
+import { MoveString, MoveVector, U64, U8 } from "../../bcs";
+import { Serializable, Serializer } from "../../bcs/serializer";
+import { AccountAddress } from "../../core/accountAddress";
+import { PublicKey } from "../../core/crypto";
+import { AnyNumber } from "../../types";
+
+/**
+ * Represents a challenge required for the account owner to sign in order to rotate the authentication key.
+ * @group Implementation
+ * @category Transactions
+ */
+export class RotationProofChallenge extends Serializable {
+  // Resource account address
+  public readonly accountAddress: AccountAddress = AccountAddress.ONE;
+
+  // Module name, i.e: 0x1::account
+  public readonly moduleName: MoveString = new MoveString("account");
+
+  // The rotation proof challenge struct name that live under the module
+  public readonly structName: MoveString = new MoveString("RotationProofChallenge");
+
+  // Signer's address
+  public readonly originator: AccountAddress;
+
+  // Signer's current authentication key
+  public readonly currentAuthKey: AccountAddress;
+
+  // New public key to rotate to
+  public readonly newPublicKey: MoveVector<U8>;
+
+  // 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.
+   * @group Implementation
+   * @category Transactions
+   */
+  constructor(args: {
+    sequenceNumber: AnyNumber;
+    originator: AccountAddress;
+    currentAuthKey: AccountAddress;
+    newPublicKey: PublicKey;
+  }) {
+    super();
+    this.sequenceNumber = new U64(args.sequenceNumber);
+    this.originator = args.originator;
+    this.currentAuthKey = args.currentAuthKey;
+    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.
+   * @group Implementation
+   * @category Transactions
+   */
+  serialize(serializer: Serializer): void {
+    serializer.serialize(this.accountAddress);
+    serializer.serialize(this.moduleName);
+    serializer.serialize(this.structName);
+    serializer.serialize(this.sequenceNumber);
+    serializer.serialize(this.originator);
+    serializer.serialize(this.currentAuthKey);
+    serializer.serialize(this.newPublicKey);
+  }
+}