@aptos-labs/ts-sdk 0.0.0

package/src/transactions/authenticator/transaction.ts

@@ -0,0 +1,222 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import { AccountAuthenticator } from "./account";
+import { Deserializer, Serializer } from "../../bcs";
+import { AccountAddress } from "../../core";
+import { Ed25519PublicKey, Ed25519Signature } from "../../core/crypto/ed25519";
+import { MultiEd25519PublicKey, MultiEd25519Signature } from "../../core/crypto/multiEd25519";
+import { Secp256k1PublicKey, Secp256k1Signature } from "../../core/crypto/secp256k1";
+import { TransactionAuthenticatorVariant } from "../../types";
+
+export abstract class TransactionAuthenticator {
+  abstract serialize(serializer: Serializer): void;
+
+  static deserialize(deserializer: Deserializer): TransactionAuthenticator {
+    const index = deserializer.deserializeUleb128AsU32();
+    switch (index) {
+      case TransactionAuthenticatorVariant.Ed25519:
+        return TransactionAuthenticatorEd25519.load(deserializer);
+      case TransactionAuthenticatorVariant.MultiEd25519:
+        return TransactionAuthenticatorMultiEd25519.load(deserializer);
+      case TransactionAuthenticatorVariant.MultiAgent:
+        return TransactionAuthenticatorMultiAgent.load(deserializer);
+      case TransactionAuthenticatorVariant.FeePayer:
+        return TransactionAuthenticatorFeePayer.load(deserializer);
+      case TransactionAuthenticatorVariant.Secp256k1Ecdsa:
+        return TransactionAuthenticatorSecp256k1.load(deserializer);
+      default:
+        throw new Error(`Unknown variant index for TransactionAuthenticator: ${index}`);
+    }
+  }
+}
+
+/**
+ * Transaction authenticator Ed25519 for a single signer transaction
+ *
+ * @param public_key Client's public key.
+ * @param signature Ed25519 signature of a raw transaction.
+ * @see {@link https://aptos.dev/integration/creating-a-signed-transaction | Creating a Signed Transaction}
+ * for details about generating a signature.
+ */
+export class TransactionAuthenticatorEd25519 extends TransactionAuthenticator {
+  public readonly public_key: Ed25519PublicKey;
+
+  public readonly signature: Ed25519Signature;
+
+  constructor(public_key: Ed25519PublicKey, signature: Ed25519Signature) {
+    super();
+    this.public_key = public_key;
+    this.signature = signature;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TransactionAuthenticatorVariant.Ed25519);
+    this.public_key.serialize(serializer);
+    this.signature.serialize(serializer);
+  }
+
+  static load(deserializer: Deserializer): TransactionAuthenticatorEd25519 {
+    const public_key = Ed25519PublicKey.deserialize(deserializer);
+    const signature = Ed25519Signature.deserialize(deserializer);
+    return new TransactionAuthenticatorEd25519(public_key, signature);
+  }
+}
+
+/**
+ * Transaction authenticator Ed25519 for a multi signers transaction
+ *
+ * @param public_key Client's public key.
+ * @param signature Multi Ed25519 signature of a raw transaction.
+ *
+ */
+export class TransactionAuthenticatorMultiEd25519 extends TransactionAuthenticator {
+  public readonly public_key: MultiEd25519PublicKey;
+
+  public readonly signature: MultiEd25519Signature;
+
+  constructor(public_key: MultiEd25519PublicKey, signature: MultiEd25519Signature) {
+    super();
+    this.public_key = public_key;
+    this.signature = signature;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TransactionAuthenticatorVariant.MultiEd25519);
+    this.public_key.serialize(serializer);
+    this.signature.serialize(serializer);
+  }
+
+  static load(deserializer: Deserializer): TransactionAuthenticatorMultiEd25519 {
+    const public_key = MultiEd25519PublicKey.deserialize(deserializer);
+    const signature = MultiEd25519Signature.deserialize(deserializer);
+    return new TransactionAuthenticatorMultiEd25519(public_key, signature);
+  }
+}
+
+/**
+ * Transaction authenticator for a multi-agent transaction
+ *
+ * @param sender Sender account authenticator
+ * @param secondary_signer_addresses Secondary signers address
+ * @param secondary_signers Secondary signers account authenticators
+ *
+ */
+export class TransactionAuthenticatorMultiAgent extends TransactionAuthenticator {
+  public readonly sender: AccountAuthenticator;
+
+  public readonly secondary_signer_addresses: Array<AccountAddress>;
+
+  public readonly secondary_signers: Array<AccountAuthenticator>;
+
+  constructor(
+    sender: AccountAuthenticator,
+    secondary_signer_addresses: Array<AccountAddress>,
+    secondary_signers: Array<AccountAuthenticator>,
+  ) {
+    super();
+    this.sender = sender;
+    this.secondary_signer_addresses = secondary_signer_addresses;
+    this.secondary_signers = secondary_signers;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TransactionAuthenticatorVariant.MultiAgent);
+    this.sender.serialize(serializer);
+    serializer.serializeVector<AccountAddress>(this.secondary_signer_addresses);
+    serializer.serializeVector<AccountAuthenticator>(this.secondary_signers);
+  }
+
+  static load(deserializer: Deserializer): TransactionAuthenticatorMultiAgent {
+    const sender = AccountAuthenticator.deserialize(deserializer);
+    const secondary_signer_addresses = deserializer.deserializeVector(AccountAddress);
+    const secondary_signers = deserializer.deserializeVector(AccountAuthenticator);
+    return new TransactionAuthenticatorMultiAgent(sender, secondary_signer_addresses, secondary_signers);
+  }
+}
+
+/**
+ * Transaction authenticator for a fee payer transaction
+ *
+ * @param sender Sender account authenticator
+ * @param secondary_signer_addresses Secondary signers address
+ * @param secondary_signers Secondary signers account authenticators
+ * @param fee_payer Object of the fee payer account address and the fee payer authentication
+ *
+ */
+export class TransactionAuthenticatorFeePayer extends TransactionAuthenticator {
+  public readonly sender: AccountAuthenticator;
+
+  public readonly secondary_signer_addresses: Array<AccountAddress>;
+
+  public readonly secondary_signers: Array<AccountAuthenticator>;
+
+  public readonly fee_payer: {
+    address: AccountAddress;
+    authenticator: AccountAuthenticator;
+  };
+
+  constructor(
+    sender: AccountAuthenticator,
+    secondary_signer_addresses: Array<AccountAddress>,
+    secondary_signers: Array<AccountAuthenticator>,
+    fee_payer: { address: AccountAddress; authenticator: AccountAuthenticator },
+  ) {
+    super();
+    this.sender = sender;
+    this.secondary_signer_addresses = secondary_signer_addresses;
+    this.secondary_signers = secondary_signers;
+    this.fee_payer = fee_payer;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TransactionAuthenticatorVariant.FeePayer);
+    this.sender.serialize(serializer);
+    serializer.serializeVector<AccountAddress>(this.secondary_signer_addresses);
+    serializer.serializeVector<AccountAuthenticator>(this.secondary_signers);
+    this.fee_payer.address.serialize(serializer);
+    this.fee_payer.authenticator.serialize(serializer);
+  }
+
+  static load(deserializer: Deserializer): TransactionAuthenticatorMultiAgent {
+    const sender = AccountAuthenticator.deserialize(deserializer);
+    const secondary_signer_addresses = deserializer.deserializeVector(AccountAddress);
+    const secondary_signers = deserializer.deserializeVector(AccountAuthenticator);
+    const address = AccountAddress.deserialize(deserializer);
+    const authenticator = AccountAuthenticator.deserialize(deserializer);
+    const fee_payer = { address, authenticator };
+    return new TransactionAuthenticatorFeePayer(sender, secondary_signer_addresses, secondary_signers, fee_payer);
+  }
+}
+
+/**
+ * Transaction authenticator Secp256k1 for a single signer transaction
+ *
+ * @param public_key Client's public key
+ * @param signature Secp256k1 signature of a `RawTransaction`
+ */
+export class TransactionAuthenticatorSecp256k1 extends TransactionAuthenticator {
+  public readonly public_key: Secp256k1PublicKey;
+
+  public readonly signature: Secp256k1Signature;
+
+  constructor(public_key: Secp256k1PublicKey, signature: Secp256k1Signature) {
+    super();
+    this.public_key = public_key;
+    this.signature = signature;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TransactionAuthenticatorVariant.Secp256k1Ecdsa);
+    this.public_key.serialize(serializer);
+    this.signature.serialize(serializer);
+  }
+
+  static load(deserializer: Deserializer): TransactionAuthenticatorSecp256k1 {
+    const public_key = Secp256k1PublicKey.deserialize(deserializer);
+    const signature = Secp256k1Signature.deserialize(deserializer);
+    return new TransactionAuthenticatorSecp256k1(public_key, signature);
+  }
+}

package/src/transactions/instances/chainId.ts

@@ -0,0 +1,26 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { Serializer, Serializable } from "../../bcs/serializer";
+import { Deserializer } from "../../bcs/deserializer";
+
+/**
+ * Representation of a ChainId that can serialized and deserialized
+ */
+export class ChainId extends Serializable {
+  public readonly chainId: number;
+
+  constructor(chainId: number) {
+    super();
+    this.chainId = chainId;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU8(this.chainId);
+  }
+
+  static deserialize(deserializer: Deserializer): ChainId {
+    const chainId = deserializer.deserializeU8();
+    return new ChainId(chainId);
+  }
+}

package/src/transactions/instances/identifier.ts

@@ -0,0 +1,28 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { Deserializer } from "../../bcs/deserializer";
+import { Serializable, Serializer } from "../../bcs/serializer";
+
+/**
+ * Representation of an Identifier that can serialized and deserialized.
+ * We use Identifier to represent the module "name" in "ModuleId" and
+ * the "function name" in "EntryFunction"
+ */
+export class Identifier extends Serializable {
+  public identifier: string;
+
+  constructor(identifier: string) {
+    super();
+    this.identifier = identifier;
+  }
+
+  public serialize(serializer: Serializer): void {
+    serializer.serializeStr(this.identifier);
+  }
+
+  static deserialize(deserializer: Deserializer): Identifier {
+    const identifier = deserializer.deserializeStr();
+    return new Identifier(identifier);
+  }
+}

package/src/transactions/instances/index.ts

@@ -0,0 +1,9 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+export * from "./chainId";
+export * from "./identifier";
+export * from "./moduleId";
+export * from "./rawTransaction";
+export * from "./transactionArgument";
+export * from "./transactionPayload";

package/src/transactions/instances/moduleId.ts

@@ -0,0 +1,53 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { Serializable, Serializer } from "../../bcs/serializer";
+import { Deserializer } from "../../bcs/deserializer";
+import { AccountAddress } from "../../core";
+import { Identifier } from "./identifier";
+import { MoveModuleId } from "../../types";
+
+/**
+ * Representation of a ModuleId that can serialized and deserialized
+ * ModuleId means the module address (e.g "0x1") and the module name (e.g "coin")
+ */
+export class ModuleId extends Serializable {
+  public readonly address: AccountAddress;
+
+  public readonly name: Identifier;
+
+  /**
+   * Full name of a module.
+   * @param address The account address. e.g "0x1"
+   * @param name The module name under the "address". e.g "coin"
+   */
+  constructor(address: AccountAddress, name: Identifier) {
+    super();
+    this.address = address;
+    this.name = name;
+  }
+
+  /**
+   * Converts a string literal to a ModuleId
+   * @param moduleId String literal in format "account_address::module_name", e.g. "0x1::coin"
+   * @returns ModuleId
+   */
+  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]));
+  }
+
+  serialize(serializer: Serializer): void {
+    this.address.serialize(serializer);
+    this.name.serialize(serializer);
+  }
+
+  static deserialize(deserializer: Deserializer): ModuleId {
+    const address = AccountAddress.deserialize(deserializer);
+    const name = Identifier.deserialize(deserializer);
+    return new ModuleId(address, name);
+  }
+}

package/src/transactions/instances/rawTransaction.ts

@@ -0,0 +1,199 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import { Deserializer } from "../../bcs/deserializer";
+import { Serializable, Serializer } from "../../bcs/serializer";
+import { ChainId } from "./chainId";
+import { AccountAddress } from "../../core";
+import { TransactionPayload } from "./transactionPayload";
+import { TransactionVariants } from "../../types";
+
+/**
+ * Representation of a Raw Transaction that can serialized and deserialized
+ */
+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 Aptos chain for execution.
+   * RawTransactions must be signed before Aptos 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 Aptos 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.
+   */
+  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;
+  }
+
+  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);
+  }
+
+  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,
+    );
+  }
+}
+
+/**
+ * Representation of a Raw Transaction With Data that can serialized and deserialized
+ */
+export abstract class RawTransactionWithData extends Serializable {
+  /**
+   * Serialize a Raw Transaction With Data
+   */
+  abstract serialize(serializer: Serializer): void;
+
+  /**
+   * Deserialize a Raw Transaction With Data
+   */
+  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}`);
+    }
+  }
+}
+
+/**
+ * Representation of a Multi Agent Transaction that can serialized and deserialized
+ */
+export class MultiAgentRawTransaction extends RawTransactionWithData {
+  /**
+   * The raw transaction
+   */
+  public readonly raw_txn: RawTransaction;
+
+  /**
+   * The secondary signers on this transaction
+   */
+  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);
+  }
+
+  static load(deserializer: Deserializer): MultiAgentRawTransaction {
+    const rawTxn = RawTransaction.deserialize(deserializer);
+    const secondarySignerAddresses = deserializer.deserializeVector(AccountAddress);
+
+    return new MultiAgentRawTransaction(rawTxn, secondarySignerAddresses);
+  }
+}
+
+/**
+ * Representation of a Fee Payer Transaction that can serialized and deserialized
+ */
+export class FeePayerRawTransaction extends RawTransactionWithData {
+  /**
+   * The raw transaction
+   */
+  public readonly raw_txn: RawTransaction;
+
+  /**
+   * The secondary signers on this transaction - optional and can be empty
+   */
+  public readonly secondary_signer_addresses: Array<AccountAddress>;
+
+  /**
+   * The fee payer account address
+   */
+  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/signedTransaction.ts

@@ -0,0 +1,43 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+/* eslint-disable @typescript-eslint/naming-convention */
+
+import { TransactionAuthenticator } from "../authenticator/transaction";
+import { Deserializer } from "../../bcs/deserializer";
+import { Serializable, Serializer } from "../../bcs/serializer";
+import { RawTransaction } from "./rawTransaction";
+
+export class SignedTransaction extends Serializable {
+  public readonly raw_txn: RawTransaction;
+
+  public readonly authenticator: TransactionAuthenticator;
+
+  /**
+   * A SignedTransaction consists of a raw transaction and an authenticator. The authenticator
+   * contains a client's public key and the signature of the raw transaction.
+   *
+   * @see {@link https://aptos.dev/integration/creating-a-signed-transaction | Creating a Signed Transaction}
+   *
+   * @param raw_txn
+   * @param authenticator Contains a client's public key and the signature of the raw transaction.
+   * Authenticator has 3 flavors: single signature, multi-signature and multi-agent.
+   * @see {@link https://github.com/aptos-labs/aptos-core/blob/main/types/src/transaction/authenticator.rs} for details.
+   */
+  constructor(raw_txn: RawTransaction, authenticator: TransactionAuthenticator) {
+    super();
+    this.raw_txn = raw_txn;
+    this.authenticator = authenticator;
+  }
+
+  serialize(serializer: Serializer): void {
+    this.raw_txn.serialize(serializer);
+    this.authenticator.serialize(serializer);
+  }
+
+  static deserialize(deserializer: Deserializer): SignedTransaction {
+    const raw_txn = RawTransaction.deserialize(deserializer);
+    const authenticator = TransactionAuthenticator.deserialize(deserializer);
+    return new SignedTransaction(raw_txn, authenticator);
+  }
+}

package/src/transactions/instances/transactionArgument.ts

@@ -0,0 +1,37 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { Serializer } from "../../bcs/serializer";
+import { Hex } from "../../core/hex";
+
+export interface TransactionArgument extends EntryFunctionArgument, ScriptFunctionArgument {}
+
+export interface EntryFunctionArgument {
+  /**
+   * Serialize an argument to BCS-serialized bytes.
+   */
+  serialize(serializer: Serializer): void;
+  /**
+   * Serialize an argument as a type-agnostic, fixed byte sequence. The byte sequence contains
+   * the number of the following bytes followed by the BCS-serialized bytes for a typed argument.
+   */
+  serializeForEntryFunction(serializer: Serializer): void;
+
+  bcsToBytes(): Uint8Array;
+  bcsToHex(): Hex;
+}
+export interface ScriptFunctionArgument {
+  /**
+   * Serialize an argument to BCS-serialized bytes.
+   */
+  serialize(serializer: Serializer): void;
+  /**
+   * Serialize an argument to BCS-serialized bytes as a type aware byte sequence.
+   * The byte sequence contains an enum variant index followed by the BCS-serialized
+   * bytes for a typed argument.
+   */
+  serializeForScriptFunction(serializer: Serializer): void;
+
+  bcsToBytes(): Uint8Array;
+  bcsToHex(): Hex;
+}