@aptos-labs/ts-sdk 0.0.3 → 0.0.5

package/src/transactions/instances/moduleId.ts

@@ -37,7 +37,7 @@ export class ModuleId extends Serializable {
     if (parts.length !== 2) {
       throw new Error("Invalid module id.");
     }
-    return new ModuleId(AccountAddress.fromString(parts[0]), new Identifier(parts[1]));
+    return new ModuleId(AccountAddress.fromStringRelaxed(parts[0]), new Identifier(parts[1]));
   }
 
   serialize(serializer: Serializer): void {

package/src/transactions/instances/rotationProofChallenge.ts

@@ -0,0 +1,58 @@
+// Copyright © Aptos Foundation
+// SPDX-License-Identifier: Apache-2.0
+
+import { Serializer, Serializable } from "../../bcs/serializer";
+import { AccountAddress } from "../../core/accountAddress";
+import { AnyNumber } from "../../types";
+import { PublicKey } from "../../core/crypto/asymmetricCrypto";
+import { MoveString, MoveVector, U64, U8 } from "../../bcs";
+
+/**
+ * Representation of the challenge which is needed to sign by owner of the account
+ * to rotate the authentication key.
+ */
+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;
+
+  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());
+  }
+
+  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);
+  }
+}

package/src/transactions/transactionBuilder/helpers.ts

@@ -84,7 +84,11 @@ export function throwTypeMismatch(expectedType: string, position: number) {
  * @param functionAbi
  */
 export function findFirstNonSignerArg(functionAbi: MoveFunction): number {
-  return functionAbi.params.findIndex((param) => param !== "signer" && param !== "&signer");
+  const index = functionAbi.params.findIndex((param) => param !== "signer" && param !== "&signer");
+  if (index < 0) {
+    return functionAbi.params.length;
+  }
+  return index;
 }
 
 export function getFunctionParts(functionArg: MoveStructType) {

package/src/transactions/transactionBuilder/remoteAbi.ts

@@ -74,7 +74,7 @@ export async function fetchEntryFunctionAbi(
 
   // Remove the signer arguments
   const first = findFirstNonSignerArg(functionAbi);
-  const params = [];
+  const params: TypeTag[] = [];
   for (let i = first; i < functionAbi.params.length; i += 1) {
     params.push(parseTypeTag(functionAbi.params[i], { allowGenerics: true }));
   }
@@ -150,7 +150,7 @@ function parseArg(
   // TODO: support uint8array?
   if (param.isAddress()) {
     if (isString(arg)) {
-      return AccountAddress.fromString(arg);
+      return AccountAddress.fromStringRelaxed(arg);
     }
     throwTypeMismatch("string", position);
   }
@@ -227,7 +227,7 @@ function parseArg(
     if (param.isObject()) {
       // The inner type of Object doesn't matter, since it's just syntactic sugar
       if (isString(arg)) {
-        return AccountAddress.fromString(arg);
+        return AccountAddress.fromStringRelaxed(arg);
       }
       throwTypeMismatch("string", position);
     }
@@ -239,7 +239,7 @@ function parseArg(
         return new MoveOption<U8>(null);
       }
 
-      return new MoveOption(parseArg(arg, param.value.type_args[0], position, genericTypeParams));
+      return new MoveOption(parseArg(arg, param.value.typeArgs[0], position, genericTypeParams));
     }
 
     throw new Error(`Unsupported struct input type for argument ${position}, type '${param.toString()}'`);

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -9,7 +9,7 @@
 import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
 import { AptosConfig } from "../../api/aptosConfig";
 import { Deserializer } from "../../bcs/deserializer";
-import { AccountAddress, Hex, PublicKey } from "../../core";
+import { AccountAddress, AccountAddressInput, Hex, PublicKey } from "../../core";
 import { Account } from "../../core/account";
 import { AnyPublicKey } from "../../core/crypto/anyPublicKey";
 import { AnySignature } from "../../core/crypto/anySignature";
@@ -52,31 +52,32 @@ import {
 } from "../instances";
 import { SignedTransaction } from "../instances/signedTransaction";
 import {
-  InputGenerateTransactionOptions,
+  AnyRawTransaction,
   AnyTransactionPayloadInstance,
   AnyRawTransactionInstance,
+  EntryFunctionArgumentTypes,
+  EntryFunctionABI,
   InputGenerateFeePayerRawTransactionArgs,
   InputGenerateMultiAgentRawTransactionArgs,
   InputGenerateRawTransactionArgs,
   InputGenerateSingleSignerRawTransactionArgs,
   InputSingleSignerTransaction,
-  AnyRawTransaction,
+  InputGenerateTransactionOptions,
   InputFeePayerTransaction,
   InputMultiAgentTransaction,
   InputScriptData,
   InputSimulateTransactionData,
-  EntryFunctionArgumentTypes,
-  EntryFunctionABI,
   InputGenerateTransactionPayloadData,
   InputEntryFunctionData,
   InputMultiSigData,
   InputMultiSigDataWithRemoteABI,
   InputEntryFunctionDataWithRemoteABI,
   InputGenerateTransactionPayloadDataWithRemoteABI,
+  InputSubmitTransactionData,
 } from "../types";
 import { convertArgument, fetchEntryFunctionAbi, standardizeTypeTags } from "./remoteAbi";
 import { memoizeAsync } from "../../utils/memoize";
-import { HexInput, SigningScheme } from "../../types";
+import { SigningScheme } from "../../types";
 import { getFunctionParts, isScriptDataInput } from "./helpers";
 
 /**
@@ -135,10 +136,6 @@ export function generateTransactionPayloadWithABI(
   args: InputMultiSigData,
   functionAbi: EntryFunctionABI,
 ): TransactionPayloadMultisig;
-export function generateTransactionPayloadWithABI(
-  args: InputGenerateTransactionPayloadData,
-  functionAbi: EntryFunctionABI,
-): AnyTransactionPayloadInstance;
 export function generateTransactionPayloadWithABI(
   args: InputGenerateTransactionPayloadData,
   functionAbi: EntryFunctionABI,
@@ -184,7 +181,7 @@ export function generateTransactionPayloadWithABI(
   if ("multisigAddress" in args) {
     let multisigAddress: AccountAddress;
     if (typeof args.multisigAddress === "string") {
-      multisigAddress = AccountAddress.fromString(args.multisigAddress);
+      multisigAddress = AccountAddress.from(args.multisigAddress);
     } else {
       multisigAddress = args.multisigAddress;
     }
@@ -214,7 +211,7 @@ function generateTransactionPayloadScript(args: InputScriptData) {
  */
 export async function generateRawTransaction(args: {
   aptosConfig: AptosConfig;
-  sender: HexInput;
+  sender: AccountAddressInput;
   payload: AnyTransactionPayloadInstance;
   options?: InputGenerateTransactionOptions;
 }): Promise<RawTransaction> {
@@ -244,7 +241,7 @@ export async function generateRawTransaction(args: {
   };
 
   return new RawTransaction(
-    AccountAddress.fromHexInput(sender),
+    AccountAddress.fromRelaxed(sender),
     BigInt(sequenceNumber),
     payload,
     BigInt(maxGasAmount),
@@ -283,10 +280,10 @@ export async function buildTransaction(args: InputGenerateRawTransactionArgs): P
  * @param args.secondarySignerAddresses optional. For when want to create a multi signers transaction
  * @param args.feePayerAddress optional. For when want to create a fee payer (aka sponsored) transaction
  *
- * @return An Aptos raw transaction type (note that it holds the raw transaction as a bcs serialized data)
+ * @return An instance of a RawTransaction, plus optional secondary/fee payer addresses
  * ```
  * {
- *  rawTransaction: Uint8Array,
+ *  rawTransaction: RawTransaction,
  *  secondarySignerAddresses? : Array<AccountAddress>,
  *  feePayerAddress?: AccountAddress
  * }
@@ -304,28 +301,26 @@ export async function buildTransaction(args: InputGenerateRawTransactionArgs): P
 
   if (feePayerAddress) {
     const signers: Array<AccountAddress> = secondarySignerAddresses
-      ? secondarySignerAddresses.map((signer) => AccountAddress.fromHexInput(signer))
+      ? secondarySignerAddresses.map((signer) => AccountAddress.fromRelaxed(signer))
       : [];
 
     return {
-      rawTransaction: rawTxn.bcsToBytes(),
+      rawTransaction: rawTxn,
       secondarySignerAddresses: signers,
-      feePayerAddress: AccountAddress.fromHexInput(feePayerAddress),
+      feePayerAddress: AccountAddress.fromRelaxed(feePayerAddress),
     };
   }
 
   if (secondarySignerAddresses) {
-    const signers: Array<AccountAddress> = secondarySignerAddresses.map((signer) =>
-      AccountAddress.fromHexInput(signer),
-    );
+    const signers: Array<AccountAddress> = secondarySignerAddresses.map((signer) => AccountAddress.fromRelaxed(signer));
 
     return {
-      rawTransaction: rawTxn.bcsToBytes(),
+      rawTransaction: rawTxn,
       secondarySignerAddresses: signers,
     };
   }
   // return the raw transaction
-  return { rawTransaction: rawTxn.bcsToBytes() };
+  return { rawTransaction: rawTxn };
 }
 
 /**
@@ -342,7 +337,7 @@ export async function buildTransaction(args: InputGenerateRawTransactionArgs): P
 export function generateSignedTransactionForSimulation(args: InputSimulateTransactionData): Uint8Array {
   const { signerPublicKey, transaction, secondarySignersPublicKeys, feePayerPublicKey } = args;
 
-  const deserializer = new Deserializer(transaction.rawTransaction);
+  const deserializer = new Deserializer(transaction.rawTransaction.bcsToBytes());
   const deserializedTransaction = RawTransaction.deserialize(deserializer);
 
   const accountAuthenticator = getAuthenticatorForSimulation(signerPublicKey);
@@ -474,23 +469,17 @@ export function sign(args: { signer: Account; transaction: AnyRawTransaction }):
  *
  * @returns A SignedTransaction
  */
-export function generateSignedTransaction(args: {
-  transaction: AnyRawTransaction;
-  senderAuthenticator: AccountAuthenticator;
-  secondarySignerAuthenticators?: {
-    feePayerAuthenticator?: AccountAuthenticator;
-    additionalSignersAuthenticators?: Array<AccountAuthenticator>;
-  };
-}): Uint8Array {
-  const { transaction, senderAuthenticator, secondarySignerAuthenticators } = args;
+export function generateSignedTransaction(args: InputSubmitTransactionData): Uint8Array {
+  const { transaction, senderAuthenticator, feePayerAuthenticator, additionalSignersAuthenticators } = args;
 
   const transactionToSubmit = deriveTransactionType(transaction);
 
-  if (secondarySignerAuthenticators) {
+  if (feePayerAuthenticator || additionalSignersAuthenticators) {
     return generateMultiSignersSignedTransaction(
       transactionToSubmit as MultiAgentRawTransaction | FeePayerRawTransaction,
       senderAuthenticator,
-      secondarySignerAuthenticators,
+      feePayerAuthenticator,
+      additionalSignersAuthenticators,
     );
   }
 
@@ -526,21 +515,18 @@ export function generateSignedTransaction(args: {
  * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction
  */
 export function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTransactionInstance {
-  const deserializer = new Deserializer(transaction.rawTransaction);
-  const deserializedTransaction = RawTransaction.deserialize(deserializer);
-
   if (transaction.feePayerAddress) {
     return new FeePayerRawTransaction(
-      deserializedTransaction,
+      transaction.rawTransaction,
       transaction.secondarySignerAddresses ?? [],
       transaction.feePayerAddress,
     );
   }
   if (transaction.secondarySignerAddresses) {
-    return new MultiAgentRawTransaction(deserializedTransaction, transaction.secondarySignerAddresses);
+    return new MultiAgentRawTransaction(transaction.rawTransaction, transaction.secondarySignerAddresses);
   }
 
-  return deserializedTransaction as RawTransaction;
+  return transaction.rawTransaction as RawTransaction;
 }
 
 /**
@@ -555,16 +541,13 @@ export function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTra
 export function generateMultiSignersSignedTransaction(
   transaction: MultiAgentRawTransaction | FeePayerRawTransaction,
   senderAuthenticator: AccountAuthenticator,
-  secondarySignerAuthenticators: {
-    feePayerAuthenticator?: AccountAuthenticator;
-    additionalSignersAuthenticators?: Array<AccountAuthenticator>;
-  },
+  feePayerAuthenticator?: AccountAuthenticator,
+  additionalSignersAuthenticators?: Array<AccountAuthenticator>,
 ) {
   if (transaction instanceof FeePayerRawTransaction) {
-    if (!secondarySignerAuthenticators.feePayerAuthenticator) {
+    if (!feePayerAuthenticator) {
       throw new Error("Must provide a feePayerAuthenticator argument to generate a signed fee payer transaction");
     }
-    const { feePayerAuthenticator, additionalSignersAuthenticators } = secondarySignerAuthenticators;
     const txAuthenticatorFeePayer = new TransactionAuthenticatorFeePayer(
       senderAuthenticator,
       transaction.secondary_signer_addresses,
@@ -577,12 +560,11 @@ export function generateMultiSignersSignedTransaction(
     return new SignedTransaction(transaction.raw_txn, txAuthenticatorFeePayer).bcsToBytes();
   }
   if (transaction instanceof MultiAgentRawTransaction) {
-    if (!secondarySignerAuthenticators.additionalSignersAuthenticators) {
+    if (!additionalSignersAuthenticators) {
       throw new Error(
         "Must provide a additionalSignersAuthenticators argument to generate a signed multi agent transaction",
       );
     }
-    const { additionalSignersAuthenticators } = secondarySignerAuthenticators;
     const multiAgentAuthenticator = new TransactionAuthenticatorMultiAgent(
       senderAuthenticator,
       transaction.secondary_signer_addresses,

package/src/transactions/typeTag/index.ts

@@ -291,11 +291,11 @@ export class TypeTagStruct extends TypeTag {
   toString(): `0x${string}::${string}::${string}` {
     // Collect type args and add it if there are any
     let typePredicate = "";
-    if (this.value.type_args.length > 0) {
-      typePredicate = `<${this.value.type_args.map((typeArg) => typeArg.toString()).join(", ")}>`;
+    if (this.value.typeArgs.length > 0) {
+      typePredicate = `<${this.value.typeArgs.map((typeArg) => typeArg.toString()).join(", ")}>`;
     }
 
-    return `${this.value.address.toString()}::${this.value.module_name.identifier}::${
+    return `${this.value.address.toString()}::${this.value.moduleName.identifier}::${
       this.value.name.identifier
     }${typePredicate}`;
   }
@@ -316,7 +316,7 @@ export class TypeTagStruct extends TypeTag {
 
   isTypeTag(address: AccountAddress, moduleName: string, structName: string): boolean {
     return (
-      this.value.module_name.identifier === moduleName &&
+      this.value.moduleName.identifier === moduleName &&
       this.value.name.identifier === structName &&
       this.value.address.equals(address)
     );
@@ -338,25 +338,25 @@ export class TypeTagStruct extends TypeTag {
 export class StructTag extends Serializable {
   public readonly address: AccountAddress;
 
-  public readonly module_name: Identifier;
+  public readonly moduleName: Identifier;
 
   public readonly name: Identifier;
 
-  public readonly type_args: Array<TypeTag>;
+  public readonly typeArgs: Array<TypeTag>;
 
   constructor(address: AccountAddress, module_name: Identifier, name: Identifier, type_args: Array<TypeTag>) {
     super();
     this.address = address;
-    this.module_name = module_name;
+    this.moduleName = module_name;
     this.name = name;
-    this.type_args = type_args;
+    this.typeArgs = type_args;
   }
 
   serialize(serializer: Serializer): void {
     serializer.serialize(this.address);
-    serializer.serialize(this.module_name);
+    serializer.serialize(this.moduleName);
     serializer.serialize(this.name);
-    serializer.serializeVector(this.type_args);
+    serializer.serializeVector(this.typeArgs);
   }
 
   static deserialize(deserializer: Deserializer): StructTag {

package/src/transactions/typeTag/parser.ts

@@ -288,7 +288,7 @@ function parseTypeTagInner(str: string, types: Array<TypeTag>, allowGenerics: bo
 
       return new TypeTagStruct(
         new StructTag(
-          AccountAddress.fromString(structParts[0]),
+          AccountAddress.fromStringRelaxed(structParts[0]),
           new Identifier(structParts[1]),
           new Identifier(structParts[2]),
           types,

package/src/transactions/types.ts

@@ -5,7 +5,7 @@ import { AptosConfig } from "../api/aptosConfig";
 import { MoveOption, MoveString, MoveVector } from "../bcs/serializable/moveStructs";
 import { Bool, U128, U16, U256, U32, U64, U8 } from "../bcs/serializable/movePrimitives";
 import { FixedBytes } from "../bcs/serializable/fixedBytes";
-import { AccountAddress } from "../core";
+import { AccountAddress, AccountAddressInput } from "../core";
 import { PublicKey } from "../core/crypto/asymmetricCrypto";
 import {
   MultiAgentRawTransaction,
@@ -17,6 +17,7 @@ import {
 } from "./instances";
 import { AnyNumber, HexInput, MoveFunctionGenericTypeParam, MoveStructType } from "../types";
 import { TypeTag } from "./typeTag";
+import { AccountAuthenticator } from "./authenticator/account";
 
 /**
  * Entry function arguments to be used when building a raw transaction using remote ABI
@@ -105,7 +106,7 @@ export type InputGenerateTransactionPayloadDataWithRemoteABI =
  */
 export type InputEntryFunctionData = {
   function: MoveStructType;
-  typeArguments?: Array<TypeTag>;
+  typeArguments?: Array<TypeTag | string>;
   functionArguments: Array<EntryFunctionArgumentTypes | SimpleEntryFunctionArgumentTypes>;
 };
 
@@ -121,7 +122,7 @@ export type InputMultiSigData = {
  * The data needed to generate a Multi Sig payload
  */
 export type InputMultiSigDataWithRemoteABI = {
-  multisigAddress: AccountAddress | string;
+  multisigAddress: AccountAddressInput;
 } & InputEntryFunctionDataWithRemoteABI;
 
 /**
@@ -149,7 +150,7 @@ export type EntryFunctionABI = {
  */
 export interface InputGenerateSingleSignerRawTransactionArgs {
   aptosConfig: AptosConfig;
-  sender: HexInput;
+  sender: AccountAddressInput;
   payload: AnyTransactionPayloadInstance;
   feePayerAddress?: undefined;
   secondarySignerAddresses?: undefined;
@@ -162,10 +163,10 @@ export interface InputGenerateSingleSignerRawTransactionArgs {
  */
 export interface InputGenerateFeePayerRawTransactionArgs {
   aptosConfig: AptosConfig;
-  sender: HexInput;
+  sender: AccountAddressInput;
   payload: AnyTransactionPayloadInstance;
-  feePayerAddress: HexInput;
-  secondarySignerAddresses?: HexInput[];
+  feePayerAddress: AccountAddressInput;
+  secondarySignerAddresses?: AccountAddressInput[];
   options?: InputGenerateTransactionOptions;
 }
 
@@ -175,9 +176,9 @@ export interface InputGenerateFeePayerRawTransactionArgs {
  */
 export interface InputGenerateMultiAgentRawTransactionArgs {
   aptosConfig: AptosConfig;
-  sender: HexInput;
+  sender: AccountAddressInput;
   payload: AnyTransactionPayloadInstance;
-  secondarySignerAddresses: HexInput[];
+  secondarySignerAddresses: AccountAddressInput[];
   feePayerAddress?: undefined;
   options?: InputGenerateTransactionOptions;
 }
@@ -196,7 +197,7 @@ export type InputGenerateRawTransactionArgs =
  * @param rawTransaction a bcs serialized raw transaction
  */
 export interface InputSingleSignerTransaction {
-  rawTransaction: Uint8Array;
+  rawTransaction: RawTransaction;
   feePayerAddress?: undefined;
   secondarySignerAddresses?: undefined;
 }
@@ -209,7 +210,7 @@ export interface InputSingleSignerTransaction {
  * @param feePayerAddress fee payer address for a fee payer transaction (aka Sponsored Transaction)
  */
 export interface InputFeePayerTransaction {
-  rawTransaction: Uint8Array;
+  rawTransaction: RawTransaction;
   feePayerAddress: AccountAddress;
   secondarySignerAddresses?: AccountAddress[];
 }
@@ -221,7 +222,7 @@ export interface InputFeePayerTransaction {
  * @param secondarySignerAddresses secondary signer addresses for multi-agent transaction
  */
 export interface InputMultiAgentTransaction {
-  rawTransaction: Uint8Array;
+  rawTransaction: RawTransaction;
   secondarySignerAddresses: AccountAddress[];
   feePayerAddress?: undefined;
 }
@@ -265,8 +266,8 @@ export type InputSimulateTransactionOptions = {
  * Interface that holds the user data input when generating a single signer transaction
  */
 export interface InputGenerateSingleSignerRawTransactionData {
-  sender: HexInput;
-  feePayerAddress?: undefined;
+  sender: AccountAddressInput;
+  hasFeePayer?: undefined;
   secondarySignerAddresses?: undefined;
   options?: InputGenerateTransactionOptions;
   data: InputGenerateTransactionPayloadData;
@@ -276,9 +277,9 @@ export interface InputGenerateSingleSignerRawTransactionData {
  * Interface that holds the user data input when generating a fee payer transaction
  */
 export interface InputGenerateFeePayerRawTransactionData {
-  sender: HexInput;
-  feePayerAddress: HexInput;
-  secondarySignerAddresses?: HexInput[];
+  sender: AccountAddressInput;
+  hasFeePayer: true;
+  secondarySignerAddresses?: AccountAddressInput[];
   options?: InputGenerateTransactionOptions;
   data: InputGenerateTransactionPayloadData;
 }
@@ -287,9 +288,9 @@ export interface InputGenerateFeePayerRawTransactionData {
  * Interface that holds the user data input when generating a multi-agent transaction
  */
 export interface InputGenerateMultiAgentRawTransactionData {
-  sender: HexInput;
-  secondarySignerAddresses: HexInput[];
-  feePayerAddress?: undefined;
+  sender: AccountAddressInput;
+  secondarySignerAddresses: AccountAddressInput[];
+  hasFeePayer?: undefined;
   options?: InputGenerateTransactionOptions;
   data: InputGenerateTransactionPayloadData;
 }
@@ -301,3 +302,13 @@ export type InputGenerateTransactionData =
   | InputGenerateMultiAgentRawTransactionData
   | InputGenerateFeePayerRawTransactionData
   | InputGenerateSingleSignerRawTransactionData;
+
+/**
+ * Interface that holds the user data input when submitting a transaction
+ */
+export interface InputSubmitTransactionData {
+  transaction: AnyRawTransaction;
+  senderAuthenticator: AccountAuthenticator;
+  feePayerAuthenticator?: AccountAuthenticator;
+  additionalSignersAuthenticators?: Array<AccountAuthenticator>;
+}

package/src/types/generated/operations.ts

@@ -1,5 +1,23 @@
 import * as Types from "./types";
 
+export type TokenActivitiesFieldsFragment = {
+  after_value?: string | null;
+  before_value?: string | null;
+  entry_function_id_str?: string | null;
+  event_account_address: string;
+  event_index: any;
+  from_address?: string | null;
+  is_fungible_v2?: boolean | null;
+  property_version_v1: any;
+  to_address?: string | null;
+  token_amount: any;
+  token_data_id: string;
+  token_standard: string;
+  transaction_timestamp: any;
+  transaction_version: any;
+  type: string;
+};
+
 export type CurrentTokenOwnershipFieldsFragment = {
   token_standard: string;
   token_properties_mutated_v1?: any | null;
@@ -46,24 +64,6 @@ export type CurrentTokenOwnershipFieldsFragment = {
   } | null;
 };
 
-export type TokenActivitiesFieldsFragment = {
-  after_value?: string | null;
-  before_value?: string | null;
-  entry_function_id_str?: string | null;
-  event_account_address: string;
-  event_index: any;
-  from_address?: string | null;
-  is_fungible_v2?: boolean | null;
-  property_version_v1: any;
-  to_address?: string | null;
-  token_amount: any;
-  token_data_id: string;
-  token_standard: string;
-  transaction_timestamp: any;
-  transaction_version: any;
-  type: string;
-};
-
 export type GetAccountCoinsCountQueryVariables = Types.Exact<{
   address?: Types.InputMaybe<Types.Scalars["String"]>;
 }>;
@@ -431,6 +431,7 @@ export type GetEventsQuery = {
     transaction_block_height: any;
     transaction_version: any;
     type: string;
+    indexed_type: string;
   }>;
 };
 

package/src/types/generated/queries.ts

@@ -2,6 +2,25 @@ import * as Types from "./operations";
 
 import { GraphQLClient } from "graphql-request";
 import * as Dom from "graphql-request/dist/types.dom";
+export const TokenActivitiesFieldsFragmentDoc = `
+    fragment TokenActivitiesFields on token_activities_v2 {
+  after_value
+  before_value
+  entry_function_id_str
+  event_account_address
+  event_index
+  from_address
+  is_fungible_v2
+  property_version_v1
+  to_address
+  token_amount
+  token_data_id
+  token_standard
+  transaction_timestamp
+  transaction_version
+  type
+}
+    `;
 export const CurrentTokenOwnershipFieldsFragmentDoc = `
     fragment CurrentTokenOwnershipFields on current_token_ownerships_v2 {
   token_standard
@@ -49,25 +68,6 @@ export const CurrentTokenOwnershipFieldsFragmentDoc = `
   }
 }
     `;
-export const TokenActivitiesFieldsFragmentDoc = `
-    fragment TokenActivitiesFields on token_activities_v2 {
-  after_value
-  before_value
-  entry_function_id_str
-  event_account_address
-  event_index
-  from_address
-  is_fungible_v2
-  property_version_v1
-  to_address
-  token_amount
-  token_data_id
-  token_standard
-  transaction_timestamp
-  transaction_version
-  type
-}
-    `;
 export const GetAccountCoinsCount = `
     query getAccountCoinsCount($address: String) {
   current_fungible_asset_balances_aggregate(
@@ -300,6 +300,7 @@ export const GetEvents = `
     transaction_block_height
     transaction_version
     type
+    indexed_type
   }
 }
     `;