@aptos-labs/ts-sdk 0.0.1 → 0.0.3

package/src/bcs/serializable/fixedBytes.ts

@@ -24,7 +24,7 @@ import { TransactionArgument } from "../../transactions/instances/transactionArg
  *  @example
  *  const yourCustomSerializedBytes = new Uint8Array([1, 2, 3, 4, 5, 6, 7, 8]);
  *  const fixedBytes = new FixedBytes(yourCustomSerializedBytes);
- *  const payload = generateTransactionPayload({
+ *  const payload = await generateTransactionPayload({
  *    function: "0xbeefcafe::your_module::your_function_that_requires_custom_serialization",
  *    functionArguments: [yourCustomBytes],
  *  });

package/src/bcs/serializable/moveStructs.ts

@@ -6,7 +6,6 @@ import { Serializable, Serializer } from "../serializer";
 import { Deserializable, Deserializer } from "../deserializer";
 import { AnyNumber, HexInput, ScriptTransactionArgumentVariants } from "../../types";
 import { Hex } from "../../core/hex";
-import { AccountAddress } from "../../core/accountAddress";
 import { EntryFunctionArgument, TransactionArgument } from "../../transactions/instances/transactionArgument";
 
 /**
@@ -52,7 +51,10 @@ import { EntryFunctionArgument, TransactionArgument } from "../../transactions/i
  * values: an Array<T> of values where T is a class that implements Serializable
  * @returns a `MoveVector<T>` with the values `values`
  */
-export class MoveVector<T extends Serializable> extends Serializable implements TransactionArgument {
+export class MoveVector<T extends Serializable & EntryFunctionArgument>
+  extends Serializable
+  implements TransactionArgument
+{
   public values: Array<T>;
 
   constructor(values: Array<T>) {
@@ -209,7 +211,10 @@ export class MoveVector<T extends Serializable> extends Serializable implements
    * @returns a MoveVector of the corresponding class T
    * *
    */
-  static deserialize<T extends Serializable>(deserializer: Deserializer, cls: Deserializable<T>): MoveVector<T> {
+  static deserialize<T extends Serializable & EntryFunctionArgument>(
+    deserializer: Deserializer,
+    cls: Deserializable<T>,
+  ): MoveVector<T> {
     const length = deserializer.deserializeUleb128AsU32();
     const values = new Array<T>();
     for (let i = 0; i < length; i += 1) {
@@ -247,7 +252,10 @@ export class MoveString extends Serializable implements TransactionArgument {
   }
 }
 
-export class MoveOption<T extends Serializable> extends Serializable implements EntryFunctionArgument {
+export class MoveOption<T extends Serializable & EntryFunctionArgument>
+  extends Serializable
+  implements EntryFunctionArgument
+{
   private vec: MoveVector<T>;
 
   public readonly value?: T;
@@ -424,39 +432,11 @@ export class MoveOption<T extends Serializable> extends Serializable implements
     return new MoveOption<MoveString>(value !== null && value !== undefined ? new MoveString(value) : undefined);
   }
 
-  static deserialize<U extends Serializable>(deserializer: Deserializer, cls: Deserializable<U>): MoveOption<U> {
+  static deserialize<U extends Serializable & EntryFunctionArgument>(
+    deserializer: Deserializer,
+    cls: Deserializable<U>,
+  ): MoveOption<U> {
     const vector = MoveVector.deserialize(deserializer, cls);
     return new MoveOption(vector.values[0]);
   }
 }
-
-export class MoveObject extends Serializable implements TransactionArgument {
-  public value: AccountAddress;
-
-  constructor(value: HexInput | AccountAddress) {
-    super();
-
-    if (value instanceof AccountAddress) {
-      this.value = value;
-    } else {
-      this.value = AccountAddress.fromHexInputRelaxed(value);
-    }
-  }
-
-  serialize(serializer: Serializer): void {
-    serializer.serialize(this.value);
-  }
-
-  serializeForEntryFunction(serializer: Serializer): void {
-    this.value.serializeForEntryFunction(serializer);
-  }
-
-  serializeForScriptFunction(serializer: Serializer): void {
-    this.value.serializeForScriptFunction(serializer);
-  }
-
-  static deserialize(deserializer: Deserializer): MoveObject {
-    const address = deserializer.deserialize(AccountAddress);
-    return new MoveObject(address);
-  }
-}

package/src/core/account.ts

@@ -62,8 +62,8 @@ export class Account {
    *
    * @param args.privateKey PrivateKey - private key of the account
    * @param args.address AccountAddress - address of the account
-   * @param args.legacy optional. If set to true, the keypair generated is a Legacy keypair. Defaults
-   * to generating a Unified keypair
+   * @param args.legacy optional. If set to true, the keypair authentication keys will be derived with a Legacy scheme.
+   * Defaults to deriving an authentication key with a Unified scheme
    *
    * This method is private because it should only be called by the factory static methods.
    * @returns Account
@@ -129,7 +129,6 @@ export class Account {
       case SigningSchemeInput.Secp256k1Ecdsa:
         privateKey = Secp256k1PrivateKey.generate();
         break;
-      // TODO: Add support for MultiEd25519 as AnyMultiKey
       default:
         privateKey = Ed25519PrivateKey.generate();
     }
@@ -141,23 +140,28 @@ export class Account {
 
     const address = new AccountAddress({
       data: Account.authKey({
-        publicKey, // TODO support AnyMultiKey
+        publicKey,
       }).toUint8Array(),
     });
     return new Account({ privateKey, address, legacy: args?.legacy });
   }
 
   /**
-   * Derives an account with provided private key
+   * Instantiates an account given a private key and a specified account address.
+   * This is primarily used to instantiate an `Account` that has had its authentication key rotated.
    *
    * @param privateKey PrivateKey - private key of the account
    * @param address The account address
-   * @param args.legacy optional. If set to true, the keypair generated is a Legacy keypair. Defaults
-   * to generating a Unified keypair
+   * @param args.legacy optional. If set to true, the keypair authentication keys will be derived with a Legacy scheme.
+   * Defaults to deriving an authentication key with a Unified scheme
    *
    * @returns Account
    */
-  static fromPrivateKey(args: { privateKey: PrivateKey; address: AccountAddress; legacy?: boolean }): Account {
+  static fromPrivateKeyAndAddress(args: {
+    privateKey: PrivateKey;
+    address: AccountAddress;
+    legacy?: boolean;
+  }): Account {
     const { privateKey, address, legacy } = args;
     return new Account({ privateKey, address, legacy });
   }

package/src/core/accountAddress.ts

@@ -53,6 +53,8 @@ export class AccountAddress extends Serializable implements TransactionArgument
    */
   static readonly LONG_STRING_LENGTH: number = 64;
 
+  static ZERO: AccountAddress = AccountAddress.fromString("0x0");
+
   static ONE: AccountAddress = AccountAddress.fromString("0x1");
 
   static TWO: AccountAddress = AccountAddress.fromString("0x2");
@@ -107,7 +109,7 @@ export class AccountAddress extends Serializable implements TransactionArgument
    *
    * @returns AccountAddress as a string conforming to AIP-40.
    */
-  toString(): string {
+  toString(): `0x${string}` {
     return `0x${this.toStringWithoutPrefix()}`;
   }
 
@@ -139,7 +141,7 @@ export class AccountAddress extends Serializable implements TransactionArgument
    *
    * @returns AccountAddress as a string in LONG form.
    */
-  toStringLong(): string {
+  toStringLong(): `0x${string}` {
     return `0x${this.toStringLongWithoutPrefix()}`;
   }
 

package/src/core/authenticationKey.ts

@@ -9,6 +9,9 @@ import { MultiEd25519PublicKey } from "./crypto/multiEd25519";
 import { Hex } from "./hex";
 import { AuthenticationKeyScheme, HexInput, SigningScheme } from "../types";
 import { AnyPublicKey } from "./crypto/anyPublicKey";
+import { MultiKey } from "./crypto/multiKey";
+import { Serializable, Serializer } from "../bcs/serializer";
+import { Deserializer } from "../bcs/deserializer";
 
 /**
  * Each account stores an authentication key. Authentication key enables account owners to rotate
@@ -19,7 +22,7 @@ import { AnyPublicKey } from "./crypto/anyPublicKey";
  *
  * Account addresses can be derived from AuthenticationKey
  */
-export class AuthenticationKey {
+export class AuthenticationKey extends Serializable {
   /**
    * An authentication key is always a SHA3-256 hash of data, and is always 32 bytes.
    */
@@ -31,6 +34,7 @@ export class AuthenticationKey {
   public readonly data: Hex;
 
   constructor(args: { data: HexInput }) {
+    super();
     const { data } = args;
     const hex = Hex.fromHexInput(data);
     if (hex.toUint8Array().length !== AuthenticationKey.LENGTH) {
@@ -39,6 +43,20 @@ export class AuthenticationKey {
     this.data = hex;
   }
 
+  serialize(serializer: Serializer): void {
+    serializer.serializeFixedBytes(this.data.toUint8Array());
+  }
+
+  /**
+   * Deserialize an AuthenticationKey from the byte buffer in a Deserializer instance.
+   * @param deserializer The deserializer to deserialize the AuthenticationKey from.
+   * @returns An instance of AuthenticationKey.
+   */
+  static deserialize(deserializer: Deserializer): AuthenticationKey {
+    const bytes = deserializer.deserializeFixedBytes(AuthenticationKey.LENGTH);
+    return new AuthenticationKey({ data: bytes });
+  }
+
   toString(): string {
     return this.data.toString();
   }
@@ -57,13 +75,14 @@ export class AuthenticationKey {
     const { publicKey, scheme } = args;
     let authKeyBytes: Uint8Array;
 
-    // TODO - support multied25519 key and MultiKey
     switch (scheme) {
+      case SigningScheme.MultiKey:
       case SigningScheme.SingleKey: {
         const singleKeyBytes = publicKey.bcsToBytes();
         authKeyBytes = new Uint8Array([...singleKeyBytes, scheme]);
         break;
       }
+
       case SigningScheme.Ed25519:
       case SigningScheme.MultiEd25519: {
         const ed25519PublicKeyBytes = publicKey.toUint8Array();
@@ -71,6 +90,7 @@ export class AuthenticationKey {
         authKeyBytes = new Uint8Array([...inputBytes, scheme]);
         break;
       }
+
       default:
         throw new Error(`Scheme ${scheme} is not supported`);
     }
@@ -99,6 +119,8 @@ export class AuthenticationKey {
       scheme = SigningScheme.MultiEd25519.valueOf();
     } else if (publicKey instanceof AnyPublicKey) {
       scheme = SigningScheme.SingleKey.valueOf();
+    } else if (publicKey instanceof MultiKey) {
+      scheme = SigningScheme.MultiKey.valueOf();
     } else {
       throw new Error("No supported authentication scheme for public key");
     }

package/src/core/crypto/anyPublicKey.ts

@@ -2,10 +2,21 @@ import { Serializer, Deserializer } from "../../bcs";
 import { AnyPublicKeyVariant, HexInput } from "../../types";
 import { AnySignature } from "./anySignature";
 import { PublicKey } from "./asymmetricCrypto";
-import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
-import { Secp256k1PublicKey, Secp256k1Signature } from "./secp256k1";
+import { Ed25519PublicKey } from "./ed25519";
+import { Secp256k1PublicKey } from "./secp256k1";
 
+/**
+ * Represents any public key supported by Aptos.
+ *
+ * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports
+ * `Legacy` and `Unified` authentication keys.
+ *
+ * Any unified authentication key is represented in the SDK as `AnyPublicKey`.
+ */
 export class AnyPublicKey extends PublicKey {
+  /**
+   * Reference to the inner public key
+   */
   public readonly publicKey: PublicKey;
 
   constructor(publicKey: PublicKey) {
@@ -40,22 +51,7 @@ export class AnyPublicKey extends PublicKey {
    */
   verifySignature(args: { message: HexInput; signature: AnySignature }): boolean {
     const { message, signature } = args;
-    if (this.isED25519Signature(signature)) {
-      return this.publicKey.verifySignature({ message, signature: signature.signature });
-      // eslint-disable-next-line no-else-return
-    } else if (this.isSecp256k1Signature(signature)) {
-      return this.publicKey.verifySignature({ message, signature: signature.signature });
-    } else {
-      throw new Error("Unknown public key type");
-    }
-  }
-
-  isED25519Signature(signature: AnySignature): boolean {
-    return this.publicKey instanceof Ed25519PublicKey && signature.signature instanceof Ed25519Signature;
-  }
-
-  isSecp256k1Signature(signature: AnySignature): boolean {
-    return this.publicKey instanceof Secp256k1PublicKey && signature.signature instanceof Secp256k1Signature;
+    return this.publicKey.verifySignature({ message, signature });
   }
 
   serialize(serializer: Serializer): void {

package/src/core/crypto/ed25519.ts

@@ -10,6 +10,12 @@ import { HexInput } from "../../types";
 
 /**
  * Represents the public key of an Ed25519 key pair.
+ *
+ * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports
+ * `Legacy` and `Unified` authentication keys.
+ *
+ * Ed25519 scheme is represented in the SDK as `Legacy authentication key` and also
+ * as `AnyPublicKey` that represents any `Unified authentication key`
  */
 export class Ed25519PublicKey extends PublicKey {
   /**

package/src/core/crypto/index.ts

@@ -5,3 +5,4 @@ export * from "./asymmetricCrypto";
 export * from "./ed25519";
 export * from "./multiEd25519";
 export * from "./secp256k1";
+export * from "./multiKey";

package/src/core/crypto/multiKey.ts

@@ -0,0 +1,122 @@
+import { Hex } from "../hex";
+import { HexInput } from "../../types";
+import { Deserializer } from "../../bcs/deserializer";
+import { Serializer } from "../../bcs/serializer";
+import { AnyPublicKey } from "./anyPublicKey";
+import { AnySignature } from "./anySignature";
+import { PublicKey } from "./asymmetricCrypto";
+
+export class MultiKey extends PublicKey {
+  /**
+   * List of any public keys
+   */
+  public readonly publicKeys: AnyPublicKey[];
+
+  /**
+   * The minimum number of valid signatures required, for the number of public keys specified
+   */
+  public readonly signaturesRequired: number;
+
+  constructor(args: { publicKeys: PublicKey[]; signaturesRequired: number }) {
+    super();
+    const { publicKeys, signaturesRequired } = args;
+
+    // Validate number of public keys is greater than signature required
+    if (signaturesRequired < 1) {
+      throw new Error("The number of required signatures needs to be greater then 0");
+    }
+
+    // Validate number of public keys is greater than signature required
+    if (publicKeys.length < signaturesRequired) {
+      throw new Error(
+        `Provided ${publicKeys.length} public keys is smaller than the ${signaturesRequired} required signatures`,
+      );
+    }
+
+    const keys: AnyPublicKey[] = [];
+    publicKeys.forEach((publicKey) => {
+      if (publicKey instanceof AnyPublicKey) {
+        keys.push(publicKey);
+      } else {
+        // if public key is instance of a legacy authentication key, i.e
+        // Legacy Ed25519, convert it into AnyPublicKey
+        keys.push(new AnyPublicKey(publicKey));
+      }
+    });
+
+    this.publicKeys = keys;
+    this.signaturesRequired = signaturesRequired;
+  }
+
+  toUint8Array(): Uint8Array {
+    return this.bcsToBytes();
+  }
+
+  /**
+   * Create a bitmap that holds the mapping from the original public keys
+   * to the signatures passed in
+   *
+   * @param args.bits array of the index mapping to the matching public keys
+   * @returns Uint8array bit map
+   */
+  createBitmap(args: { bits: number[] }): Uint8Array {
+    const { bits } = args;
+    // Bits are read from left to right. e.g. 0b10000000 represents the first bit is set in one byte.
+    // The decimal value of 0b10000000 is 128.
+    const firstBitInByte = 128;
+    const bitmap = new Uint8Array([0, 0, 0, 0]);
+
+    // Check if duplicates exist in bits
+    const dupCheckSet = new Set();
+
+    bits.forEach((bit: number, idx: number) => {
+      if (idx + 1 > this.publicKeys.length) {
+        throw new Error(`Signature index ${idx + 1} is out of public keys range, ${this.publicKeys.length}.`);
+      }
+
+      if (dupCheckSet.has(bit)) {
+        throw new Error(`Duplicate bit ${bit} detected.`);
+      }
+
+      dupCheckSet.add(bit);
+
+      const byteOffset = Math.floor(bit / 8);
+
+      let byte = bitmap[byteOffset];
+
+      // eslint-disable-next-line no-bitwise
+      byte |= firstBitInByte >> bit % 8;
+
+      bitmap[byteOffset] = byte;
+    });
+
+    return bitmap;
+  }
+
+  /**
+   * Hex string representation the multi key bytes
+   *
+   * @returns string
+   */
+  toString(): string {
+    return Hex.fromHexInput(this.toUint8Array()).toString();
+  }
+
+  // TODO
+  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
+  verifySignature(args: { message: HexInput; signature: AnySignature }): boolean {
+    throw new Error("not implemented");
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeVector(this.publicKeys);
+    serializer.serializeU8(this.signaturesRequired);
+  }
+
+  static deserialize(deserializer: Deserializer): MultiKey {
+    const keys = deserializer.deserializeVector(AnyPublicKey);
+    const signaturesRequired = deserializer.deserializeU8();
+
+    return new MultiKey({ publicKeys: keys, signaturesRequired });
+  }
+}

package/src/core/crypto/secp256k1.ts

@@ -10,6 +10,8 @@ import { HexInput } from "../../types";
 
 /**
  * Represents the Secp256k1 ecdsa public key
+ *
+ * Secp256k1 authentication key is represented in the SDK as `AnyPublicKey`.
  */
 export class Secp256k1PublicKey extends PublicKey {
   // Secp256k1 ecdsa public keys contain a prefix indicating compression and two 32-byte coordinates.

package/src/index.ts

@@ -5,8 +5,7 @@ export * from "./api";
 export * from "./bcs";
 export * from "./client";
 export * from "./core";
-export * from "./transactions/types";
-export * from "./transactions/typeTag/typeTag";
+export * from "./transactions";
 export * from "./types";
 export * from "./utils/apiEndpoints";
 export * from "./utils/hdKey";

package/src/internal/account.ts

@@ -26,7 +26,7 @@ import {
   LedgerVersion,
   MoveModuleBytecode,
   MoveResource,
-  MoveResourceType,
+  MoveStructType,
   OrderBy,
   PaginationArgs,
   SigningScheme,
@@ -164,7 +164,7 @@ export async function getResources(args: {
 export async function getResource<T extends {}>(args: {
   aptosConfig: AptosConfig;
   accountAddress: HexInput;
-  resourceType: MoveResourceType;
+  resourceType: MoveStructType;
   options?: LedgerVersion;
 }): Promise<T> {
   const { aptosConfig, accountAddress, resourceType, options } = args;
@@ -503,7 +503,7 @@ export async function deriveAccountFromPrivateKey(args: {
     // private key is secp256k1, therefore we know it for sure uses a single signer key
     const authKey = AuthenticationKey.fromPublicKeyAndScheme({ publicKey, scheme: SigningScheme.SingleKey });
     const address = new AccountAddress({ data: authKey.toUint8Array() });
-    return Account.fromPrivateKey({ privateKey, address });
+    return Account.fromPrivateKeyAndAddress({ privateKey, address });
   }
 
   if (privateKey instanceof Ed25519PrivateKey) {
@@ -518,14 +518,14 @@ export async function deriveAccountFromPrivateKey(args: {
     });
     if (isSingleSenderTransactionAuthenticator) {
       const address = new AccountAddress({ data: SingleSenderTransactionAuthenticatorAuthKey.toUint8Array() });
-      return Account.fromPrivateKey({ privateKey, address });
+      return Account.fromPrivateKeyAndAddress({ privateKey, address });
     }
     // lookup legacy ed25519
     const legacyAuthKey = AuthenticationKey.fromPublicKeyAndScheme({ publicKey, scheme: SigningScheme.Ed25519 });
     const isLegacyEd25519 = await isAccountExist({ authKey: legacyAuthKey, aptosConfig });
     if (isLegacyEd25519) {
       const address = new AccountAddress({ data: legacyAuthKey.toUint8Array() });
-      return Account.fromPrivateKey({ privateKey, address, legacy: true });
+      return Account.fromPrivateKeyAndAddress({ privateKey, address, legacy: true });
     }
   }
   // if we are here, it means we couldn't find an address with an

package/src/internal/coin.ts

@@ -1,20 +1,20 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { U64 } from "../bcs/serializable/movePrimitives";
 import { Account, AccountAddress } from "../core";
-import { GenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
-import { StructTag, TypeTagStruct } from "../transactions/typeTag/typeTag";
-import { HexInput, AnyNumber, MoveResourceType } from "../types";
+import { InputGenerateTransactionOptions, InputSingleSignerTransaction } from "../transactions/types";
+import { HexInput, AnyNumber, MoveStructType } from "../types";
 import { APTOS_COIN } from "../utils/const";
 import { generateTransaction } from "./transactionSubmission";
+import { parseTypeTag } from "../transactions/typeTag/parser";
 
 export async function transferCoinTransaction(args: {
   aptosConfig: AptosConfig;
   sender: Account;
   recipient: HexInput;
   amount: AnyNumber;
-  coinType?: MoveResourceType;
-  options?: GenerateTransactionOptions;
-}): Promise<SingleSignerTransaction> {
+  coinType?: MoveStructType;
+  options?: InputGenerateTransactionOptions;
+}): Promise<InputSingleSignerTransaction> {
   const { aptosConfig, sender, recipient, amount, coinType, options } = args;
   const coinStructType = coinType ?? APTOS_COIN;
   const transaction = await generateTransaction({
@@ -22,11 +22,11 @@ export async function transferCoinTransaction(args: {
     sender: sender.accountAddress.toString(),
     data: {
       function: "0x1::aptos_account::transfer_coins",
-      typeArguments: [new TypeTagStruct(StructTag.fromString(coinStructType))],
+      typeArguments: [parseTypeTag(coinStructType)],
       functionArguments: [AccountAddress.fromHexInput(recipient), new U64(amount)],
     },
     options,
   });
 
-  return transaction as SingleSignerTransaction;
+  return transaction as InputSingleSignerTransaction;
 }

package/src/internal/digitalAsset.ts

@@ -11,7 +11,7 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { MoveString, MoveVector, Bool, U64, U8 } from "../bcs";
 import { Account, Hex } from "../core";
-import { GenerateTransactionOptions, SingleSignerTransaction } from "../transactions/types";
+import { InputGenerateTransactionOptions, InputSingleSignerTransaction } from "../transactions/types";
 import {
   AnyNumber,
   GetCollectionDataResponse,
@@ -55,8 +55,8 @@ export async function mintTokenTransaction(args: {
   description: string;
   name: string;
   uri: string;
-  options?: GenerateTransactionOptions;
-}): Promise<SingleSignerTransaction> {
+  options?: InputGenerateTransactionOptions;
+}): Promise<InputSingleSignerTransaction> {
   const { aptosConfig, options, creator } = args;
   const transaction = await generateTransaction({
     aptosConfig,
@@ -75,7 +75,7 @@ export async function mintTokenTransaction(args: {
     },
     options,
   });
-  return transaction as SingleSignerTransaction;
+  return transaction as InputSingleSignerTransaction;
 }
 
 export async function getTokenData(args: {
@@ -218,9 +218,9 @@ export async function createCollectionTransaction(
     description: string;
     name: string;
     uri: string;
-    options?: GenerateTransactionOptions;
+    options?: InputGenerateTransactionOptions;
   } & CreateCollectionOptions,
-): Promise<SingleSignerTransaction> {
+): Promise<InputSingleSignerTransaction> {
   const { aptosConfig, options, creator } = args;
   const transaction = await generateTransaction({
     aptosConfig,
@@ -248,7 +248,7 @@ export async function createCollectionTransaction(
     },
     options,
   });
-  return transaction as SingleSignerTransaction;
+  return transaction as InputSingleSignerTransaction;
 }
 
 export async function getCollectionData(args: {

package/src/internal/event.ts

@@ -10,7 +10,7 @@
 
 import { AptosConfig } from "../api/aptosConfig";
 import { AccountAddress } from "../core";
-import { AnyNumber, GetEventsResponse, HexInput, PaginationArgs, MoveResourceType, OrderBy } from "../types";
+import { AnyNumber, GetEventsResponse, HexInput, PaginationArgs, MoveStructType, OrderBy } from "../types";
 import { GetEventsQuery } from "../types/generated/operations";
 import { GetEvents } from "../types/generated/queries";
 import { EventsBoolExp } from "../types/generated/types";
@@ -35,7 +35,7 @@ export async function getAccountEventsByCreationNumber(args: {
 export async function getAccountEventsByEventType(args: {
   aptosConfig: AptosConfig;
   accountAddress: HexInput;
-  eventType: MoveResourceType;
+  eventType: MoveStructType;
   options?: {
     pagination?: PaginationArgs;
     orderBy?: OrderBy<GetEventsResponse[0]>;

package/src/internal/faucet.ts

@@ -11,7 +11,7 @@
 import { AptosConfig } from "../api/aptosConfig";
 import { postAptosFaucet } from "../client";
 import { AccountAddress } from "../core";
-import { HexInput } from "../types";
+import { HexInput, WaitForTransactionOptions } from "../types";
 import { DEFAULT_TXN_TIMEOUT_SEC } from "../utils/const";
 import { waitForTransaction } from "./transaction";
 
@@ -19,10 +19,10 @@ export async function fundAccount(args: {
   aptosConfig: AptosConfig;
   accountAddress: HexInput;
   amount: number;
-  timeoutSecs?: number;
+  options?: WaitForTransactionOptions;
 }): Promise<string> {
-  const { aptosConfig, accountAddress, amount } = args;
-  const timeoutSecs = args.timeoutSecs ?? DEFAULT_TXN_TIMEOUT_SEC;
+  const { aptosConfig, accountAddress, amount, options } = args;
+  const timeout = options?.timeoutSecs || DEFAULT_TXN_TIMEOUT_SEC;
   const { data } = await postAptosFaucet<any, { txn_hashes: Array<string> }>({
     aptosConfig,
     path: "fund",
@@ -38,7 +38,11 @@ export async function fundAccount(args: {
   await waitForTransaction({
     aptosConfig,
     transactionHash: txnHash,
-    options: { timeoutSecs },
+    options: {
+      timeoutSecs: timeout,
+      checkSuccess: options?.checkSuccess,
+      indexerVersionCheck: options?.indexerVersionCheck,
+    },
   });
 
   return txnHash;