@aptos-labs/ts-sdk 0.0.5 → 0.0.7

package/src/api/transactionSubmission/submit.ts

@@ -0,0 +1,53 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { submitTransaction } from "../../internal/transactionSubmission";
+import { AccountAuthenticator, AnyRawTransaction } from "../../transactions";
+import { PendingTransactionResponse } from "../../types";
+import { AptosConfig } from "../aptosConfig";
+
+/**
+ * A class to handle all `Submit` transaction operations
+ */
+export class Submit {
+  readonly config: AptosConfig;
+
+  constructor(config: AptosConfig) {
+    this.config = config;
+  }
+
+  @ValidateFeePayerData
+  async transaction(args: {
+    transaction: AnyRawTransaction;
+    senderAuthenticator: AccountAuthenticator;
+    feePayerAuthenticator?: AccountAuthenticator;
+  }): Promise<PendingTransactionResponse> {
+    return submitTransaction({ aptosConfig: this.config, ...args });
+  }
+
+  @ValidateFeePayerData
+  async multiAgentTransaction(args: {
+    transaction: AnyRawTransaction;
+    senderAuthenticator: AccountAuthenticator;
+    additionalSignersAuthenticators: Array<AccountAuthenticator>;
+    feePayerAuthenticator?: AccountAuthenticator;
+  }): Promise<PendingTransactionResponse> {
+    return submitTransaction({ aptosConfig: this.config, ...args });
+  }
+}
+
+function ValidateFeePayerData(target: unknown, propertyKey: string, descriptor: PropertyDescriptor) {
+  const originalMethod = descriptor.value;
+  /* eslint-disable-next-line func-names, no-param-reassign */
+  descriptor.value = async function (...args: any[]) {
+    const [methodArgs] = args;
+
+    if (methodArgs.transaction.feePayerAddress && !methodArgs.feePayerAuthenticator) {
+      throw new Error("You are submitting a Fee Payer transaction but missing the feePayerAuthenticator");
+    }
+
+    return originalMethod.apply(this, args);
+  };
+
+  return descriptor;
+}

package/src/api/transactionSubmission.ts

@@ -3,30 +3,9 @@
 
 import { AptosConfig } from "./aptosConfig";
 import { Account, AccountAddressInput, PrivateKey } from "../core";
-import { AccountAuthenticator } from "../transactions/authenticator/account";
-import {
-  AnyRawTransaction,
-  InputFeePayerTransaction,
-  InputGenerateMultiAgentRawTransactionData,
-  InputGenerateTransactionData,
-  InputGenerateFeePayerRawTransactionData,
-  InputGenerateSingleSignerRawTransactionData,
-  InputMultiAgentTransaction,
-  InputSingleSignerTransaction,
-  InputSimulateTransactionData,
-  InputGenerateTransactionOptions,
-  InputSubmitTransactionData,
-} from "../transactions/types";
-import { UserTransactionResponse, PendingTransactionResponse, HexInput, TransactionResponse } from "../types";
-import {
-  generateTransaction,
-  publicPackageTransaction,
-  rotateAuthKey,
-  signAndSubmitTransaction,
-  signTransaction,
-  simulateTransaction,
-  submitTransaction,
-} from "../internal/transactionSubmission";
+import { AnyRawTransaction, SingleSignerTransaction, InputGenerateTransactionOptions } from "../transactions/types";
+import { PendingTransactionResponse, HexInput, TransactionResponse } from "../types";
+import { publicPackageTransaction, rotateAuthKey, signAndSubmitTransaction } from "../internal/transactionSubmission";
 
 export class TransactionSubmission {
   readonly config: AptosConfig;
@@ -35,119 +14,6 @@ export class TransactionSubmission {
     this.config = config;
   }
 
-  /**
-   * We are defining function signatures, each with its specific input and output.
-   * These are the possible function signature for `generateTransaction` function.
-   * When we call `generateTransaction` function with the relevant type properties,
-   * Typescript can infer the return type based on the appropriate function overload.
-   */
-  async generateTransaction(args: InputGenerateSingleSignerRawTransactionData): Promise<InputSingleSignerTransaction>;
-  async generateTransaction(args: InputGenerateFeePayerRawTransactionData): Promise<InputFeePayerTransaction>;
-  async generateTransaction(args: InputGenerateMultiAgentRawTransactionData): Promise<InputMultiAgentTransaction>;
-  async generateTransaction(args: InputGenerateTransactionData): Promise<AnyRawTransaction>;
-
-  /**
-   * Generates any transaction by passing in the required arguments
-   *
-   * @param args.sender The transaction sender's account address as a AccountAddressInput
-   * @param args.data EntryFunctionData | ScriptData | MultiSigData
-   * @param args.feePayerAddress optional. For a fee payer (aka sponsored) transaction
-   * @param args.secondarySignerAddresses optional. For a multi-agent or fee payer (aka sponsored) transactions
-   * @param args.options optional. GenerateTransactionOptions type
-   *
-   * @example
-   * For a single signer entry function
-   * move function name, move function type arguments, move function arguments
-   * `
-   * data: {
-   *  function: "0x1::aptos_account::transfer",
-   *  typeArguments: []
-   *  functionArguments: [receiverAddress,10]
-   * }
-   * `
-   *
-   * @example
-   * For a single signer script function
-   * module bytecode, move function type arguments, move function arguments
-   * ```
-   * data: {
-   *  bytecode: "0x001234567",
-   *  typeArguments: [],
-   *  functionArguments: [receiverAddress,10]
-   * }
-   * ```
-   *
-   * @return An instance of a RawTransaction, plus optional secondary/fee payer addresses
-   * ```
-   * {
-   *  rawTransaction: RawTransaction,
-   *  secondarySignerAddresses? : Array<AccountAddress>,
-   *  feePayerAddress?: AccountAddress
-   * }
-   * ```
-   */
-  async generateTransaction(args: InputGenerateTransactionData): Promise<AnyRawTransaction> {
-    return generateTransaction({ aptosConfig: this.config, ...args });
-  }
-
-  /**
-   * Sign a transaction that can later be submitted to chain
-   *
-   * @param args.signer The signer account to sign the transaction
-   * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses
-   * @param args.asFeePayer optional. If the signer is also the fee payer
-   * ```
-   * {
-   *  rawTransaction: RawTransaction,
-   *  secondarySignerAddresses? : Array<AccountAddress>,
-   *  feePayerAddress?: AccountAddress
-   * }
-   * ```
-   *
-   * @return The signer AccountAuthenticator
-   */
-  /* eslint-disable class-methods-use-this */
-  signTransaction(args: {
-    signer: Account;
-    transaction: AnyRawTransaction;
-    asFeePayer?: boolean;
-  }): AccountAuthenticator {
-    const { signer, transaction, asFeePayer } = args;
-    if (asFeePayer) {
-      transaction.feePayerAddress = signer.accountAddress;
-    }
-    return signTransaction({
-      signer,
-      transaction,
-    });
-  }
-
-  /**
-   * Simulates a transaction before singing it.
-   *
-   * @param args.signerPublicKey The signer public key
-   * @param args.transaction The raw transaction to simulate
-   * @param args.secondarySignersPublicKeys optional. For when the transaction is a multi signers transaction
-   * @param args.feePayerPublicKey optional. For when the transaction is a fee payer (aka sponsored) transaction
-   * @param args.options optional. A config to simulate the transaction with
-   */
-  async simulateTransaction(args: InputSimulateTransactionData): Promise<Array<UserTransactionResponse>> {
-    return simulateTransaction({ aptosConfig: this.config, ...args });
-  }
-
-  /**
-   * Submit transaction to chain
-   *
-   * @param args.transaction A aptos transaction type
-   * @param args.senderAuthenticator The account authenticator of the transaction sender
-   * @param args.secondarySignerAuthenticators optional. For when the transaction is a multi signers transaction
-   *
-   * @return PendingTransactionResponse
-   */
-  async submitTransaction(args: InputSubmitTransactionData): Promise<PendingTransactionResponse> {
-    return submitTransaction({ aptosConfig: this.config, ...args });
-  }
-
   /**
    * Sign and submit a single signer transaction to chain
    *
@@ -193,7 +59,7 @@ export class TransactionSubmission {
     metadataBytes: HexInput;
     moduleBytecode: Array<HexInput>;
     options?: InputGenerateTransactionOptions;
-  }): Promise<InputSingleSignerTransaction> {
+  }): Promise<SingleSignerTransaction> {
     return publicPackageTransaction({ aptosConfig: this.config, ...args });
   }
 

package/src/client/core.ts

@@ -60,7 +60,7 @@ export async function request<Req, Res>(options: ClientRequest<Req>, client: Cli
  * @param aptosConfig The config information for the SDK client instance
  * @returns the response or AptosApiError
  */
-export async function aptosRequest<Req, Res>(
+export async function aptosRequest<Req extends {}, Res extends {}>(
   options: AptosRequest,
   aptosConfig: AptosConfig,
 ): Promise<AptosResponse<Req, Res>> {

package/src/client/get.ts

@@ -47,7 +47,9 @@ export type GetAptosRequestOptions = Omit<GetRequestOptions, "type">;
  * @param options GetRequestOptions
  * @returns
  */
-export async function get<Req, Res>(options: GetRequestOptions): Promise<AptosResponse<Req, Res>> {
+export async function get<Req extends {}, Res extends {}>(
+  options: GetRequestOptions,
+): Promise<AptosResponse<Req, Res>> {
   const { aptosConfig, overrides, params, contentType, acceptType, path, originMethod, type } = options;
   const url = aptosConfig.getRequestUrl(type);
 
@@ -69,7 +71,9 @@ export async function get<Req, Res>(options: GetRequestOptions): Promise<AptosRe
   );
 }
 
-export async function getAptosFullNode<Req, Res>(options: GetAptosRequestOptions): Promise<AptosResponse<Req, Res>> {
+export async function getAptosFullNode<Req extends {}, Res extends {}>(
+  options: GetAptosRequestOptions,
+): Promise<AptosResponse<Req, Res>> {
   return get<Req, Res>({ ...options, type: AptosApiType.FULLNODE });
 }
 

package/src/client/post.ts

@@ -54,7 +54,9 @@ export type PostAptosRequestOptions = Omit<PostRequestOptions, "type">;
  * @param options PostRequestOptions
  * @returns
  */
-export async function post<Req, Res>(options: PostRequestOptions): Promise<AptosResponse<Req, Res>> {
+export async function post<Req extends {}, Res extends {}>(
+  options: PostRequestOptions,
+): Promise<AptosResponse<Req, Res>> {
   const { type, originMethod, path, body, acceptType, contentType, params, aptosConfig, overrides } = options;
   const url = aptosConfig.getRequestUrl(type);
 
@@ -77,14 +79,20 @@ export async function post<Req, Res>(options: PostRequestOptions): Promise<Aptos
   );
 }
 
-export async function postAptosFullNode<Req, Res>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>> {
+export async function postAptosFullNode<Req extends {}, Res extends {}>(
+  options: PostAptosRequestOptions,
+): Promise<AptosResponse<Req, Res>> {
   return post<Req, Res>({ ...options, type: AptosApiType.FULLNODE });
 }
 
-export async function postAptosIndexer<Req, Res>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>> {
+export async function postAptosIndexer<Req extends {}, Res extends {}>(
+  options: PostAptosRequestOptions,
+): Promise<AptosResponse<Req, Res>> {
   return post<Req, Res>({ ...options, type: AptosApiType.INDEXER });
 }
 
-export async function postAptosFaucet<Req, Res>(options: PostAptosRequestOptions): Promise<AptosResponse<Req, Res>> {
+export async function postAptosFaucet<Req extends {}, Res extends {}>(
+  options: PostAptosRequestOptions,
+): Promise<AptosResponse<Req, Res>> {
   return post<Req, Res>({ ...options, type: AptosApiType.FAUCET });
 }

package/src/index.ts

@@ -7,4 +7,4 @@ export * from "./client";
 export * from "./core";
 export * from "./transactions";
 export * from "./types";
-export * from "./utils/apiEndpoints";
+export * from "./utils";

package/src/internal/account.ts

@@ -24,7 +24,7 @@ import {
   LedgerVersion,
   MoveModuleBytecode,
   MoveResource,
-  MoveStructType,
+  MoveStructId,
   OrderBy,
   PaginationArgs,
   SigningScheme,
@@ -165,7 +165,7 @@ export async function getResources(args: {
 export async function getResource<T extends {}>(args: {
   aptosConfig: AptosConfig;
   accountAddress: AccountAddressInput;
-  resourceType: MoveStructType;
+  resourceType: MoveStructId;
   options?: LedgerVersion;
 }): Promise<T> {
   const { aptosConfig, accountAddress, resourceType, options } = args;