@aptos-labs/ts-sdk 0.0.6 → 0.0.8

package/src/transactions/transactionBuilder/remoteAbi.ts

@@ -12,7 +12,6 @@ import {
   findFirstNonSignerArg,
   isBcsAddress,
   isBcsBool,
-  isBcsFixedBytes,
   isBcsString,
   isBcsU128,
   isBcsU16,
@@ -21,6 +20,7 @@ import {
   isBcsU64,
   isBcsU8,
   isBool,
+  isEncodedEntryFunctionArgument,
   isLargeNumber,
   isNull,
   isNumber,
@@ -104,28 +104,25 @@ export function convertArgument(
     throw new Error(`Too many arguments for '${functionName}', expected ${functionAbi.parameters.length}`);
   }
 
+  const param = functionAbi.parameters[position];
+  return checkOrConvertArgument(arg, param, position, genericTypeParams);
+}
+
+export function checkOrConvertArgument(
+  arg: SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes,
+  param: TypeTag,
+  position: number,
+  genericTypeParams: Array<TypeTag>,
+) {
   // If the argument is bcs encoded, we can just use it directly
-  if (
-    isBcsBool(arg) ||
-    isBcsU8(arg) ||
-    isBcsU16(arg) ||
-    isBcsU32(arg) ||
-    isBcsU64(arg) ||
-    isBcsU128(arg) ||
-    isBcsU256(arg) ||
-    isBcsAddress(arg) ||
-    isBcsString(arg) ||
-    isBcsFixedBytes(arg) ||
-    arg instanceof MoveVector ||
-    arg instanceof MoveOption
-  ) {
+  if (isEncodedEntryFunctionArgument(arg)) {
     // Ensure the type matches the ABI
-    checkType(functionAbi, arg, position);
+    checkType(param, arg, position);
     return arg;
   }
 
   // If it is not BCS encoded, we will need to convert it with the ABI
-  return parseArg(arg, functionAbi.parameters[position], position, genericTypeParams);
+  return parseArg(arg, param, position, genericTypeParams);
 }
 
 /**
@@ -150,7 +147,7 @@ function parseArg(
   // TODO: support uint8array?
   if (param.isAddress()) {
     if (isString(arg)) {
-      return AccountAddress.fromStringRelaxed(arg);
+      return AccountAddress.fromString(arg);
     }
     throwTypeMismatch("string", position);
   }
@@ -198,19 +195,30 @@ function parseArg(
       throw new Error(`Generic argument ${param.toString()} is invalid for argument ${position}`);
     }
 
-    parseArg(arg, genericTypeParams[genericIndex], position, genericTypeParams);
+    checkOrConvertArgument(arg, genericTypeParams[genericIndex], position, genericTypeParams);
   }
 
   // We have to special case some vectors for Vector<u8>
   if (param.isVector()) {
     // Check special case for Vector<u8>
-    if (param.value.isU8() && isString(arg)) {
-      // TODO: Improve message when hex is invalid
-      return MoveVector.U8(Hex.fromHexInput(arg).toUint8Array());
+    if (param.value.isU8()) {
+      if (isString(arg)) {
+        try {
+          return MoveVector.U8(Hex.fromHexInput(arg).toUint8Array());
+        } catch (e: any) {
+          // This is a bit of a hack to not reuse code, but also have a better error message
+          throw new Error(`vector<u8> must be passed in as a hex string or a Uint8array, type '${param.toString()}'`);
+        }
+      }
+      if (arg instanceof Uint8Array) {
+        return MoveVector.U8(arg);
+      }
     }
 
+    // TODO: Support Uint16Array, Uint32Array, BigUint64Array?
+
     if (Array.isArray(arg)) {
-      return new MoveVector(arg.map((item) => parseArg(item, param.value, position, genericTypeParams)));
+      return new MoveVector(arg.map((item) => checkOrConvertArgument(item, param.value, position, genericTypeParams)));
     }
 
     throw new Error(`Type mismatch for argument ${position}, type '${param.toString()}'`);
@@ -227,7 +235,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.fromStringRelaxed(arg);
+        return AccountAddress.fromString(arg);
       }
       throwTypeMismatch("string", position);
     }
@@ -239,7 +247,7 @@ function parseArg(
         return new MoveOption<U8>(null);
       }
 
-      return new MoveOption(parseArg(arg, param.value.typeArgs[0], position, genericTypeParams));
+      return new MoveOption(checkOrConvertArgument(arg, param.value.typeArgs[0], position, genericTypeParams));
     }
 
     throw new Error(`Unsupported struct input type for argument ${position}, type '${param.toString()}'`);
@@ -250,12 +258,11 @@ function parseArg(
 
 /**
  * Checks that the type of an already BCS encoded argument matches the ABI
- * @param functionAbi
+ * @param param
  * @param arg
  * @param position
  */
-function checkType(functionAbi: EntryFunctionABI, arg: EntryFunctionArgumentTypes, position: number) {
-  const param = functionAbi.parameters[position];
+function checkType(param: TypeTag, arg: EntryFunctionArgumentTypes, position: number) {
   if (param.isBool()) {
     if (isBcsBool(arg)) {
       return;

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -8,7 +8,6 @@
  */
 import { sha3_256 as sha3Hash } from "@noble/hashes/sha3";
 import { AptosConfig } from "../../api/aptosConfig";
-import { Deserializer } from "../../bcs/deserializer";
 import { AccountAddress, AccountAddressInput, Hex, PublicKey } from "../../core";
 import { Account } from "../../core/account";
 import { AnyPublicKey } from "../../core/crypto/anyPublicKey";
@@ -57,14 +56,12 @@ import {
   AnyRawTransactionInstance,
   EntryFunctionArgumentTypes,
   EntryFunctionABI,
-  InputGenerateFeePayerRawTransactionArgs,
   InputGenerateMultiAgentRawTransactionArgs,
   InputGenerateRawTransactionArgs,
   InputGenerateSingleSignerRawTransactionArgs,
-  InputSingleSignerTransaction,
+  SingleSignerTransaction,
   InputGenerateTransactionOptions,
-  InputFeePayerTransaction,
-  InputMultiAgentTransaction,
+  MultiAgentTransaction,
   InputScriptData,
   InputSimulateTransactionData,
   InputGenerateTransactionPayloadData,
@@ -93,9 +90,6 @@ export async function generateTransactionPayload(
 export async function generateTransactionPayload(
   args: InputMultiSigDataWithRemoteABI,
 ): Promise<TransactionPayloadMultisig>;
-export async function generateTransactionPayload(
-  args: InputGenerateTransactionPayloadDataWithRemoteABI,
-): Promise<AnyTransactionPayloadInstance>;
 
 /**
  * Builds a transaction payload based on the data argument and returns
@@ -177,12 +171,7 @@ export function generateTransactionPayloadWithABI(
 
   // Send it as multi sig if it's a multisig payload
   if ("multisigAddress" in args) {
-    let multisigAddress: AccountAddress;
-    if (typeof args.multisigAddress === "string") {
-      multisigAddress = AccountAddress.from(args.multisigAddress);
-    } else {
-      multisigAddress = args.multisigAddress;
-    }
+    const multisigAddress = AccountAddress.from(args.multisigAddress);
     return new TransactionPayloadMultisig(
       new MultiSig(multisigAddress, new MultisigTransactionPayload(entryFunctionPayload)),
     );
@@ -215,9 +204,10 @@ export async function generateRawTransaction(args: {
 }): Promise<RawTransaction> {
   const { aptosConfig, sender, payload, options } = args;
 
-  const getSequenceNumber = options?.accountSequenceNumber
-    ? Promise.resolve({ sequence_number: options.accountSequenceNumber })
-    : getInfo({ aptosConfig, accountAddress: sender });
+  const getSequenceNumber =
+    options?.accountSequenceNumber !== undefined
+      ? Promise.resolve({ sequence_number: options.accountSequenceNumber })
+      : getInfo({ aptosConfig, accountAddress: sender });
 
   const getChainId = NetworkToChainId[aptosConfig.network]
     ? Promise.resolve({ chain_id: NetworkToChainId[aptosConfig.network] })
@@ -239,7 +229,7 @@ export async function generateRawTransaction(args: {
   };
 
   return new RawTransaction(
-    AccountAddress.fromRelaxed(sender),
+    AccountAddress.from(sender),
     BigInt(sequenceNumber),
     payload,
     BigInt(maxGasAmount),
@@ -257,14 +247,9 @@ export async function generateRawTransaction(args: {
  */
 export async function buildTransaction(
   args: InputGenerateSingleSignerRawTransactionArgs,
-): Promise<InputSingleSignerTransaction>;
-export async function buildTransaction(
-  args: InputGenerateFeePayerRawTransactionArgs,
-): Promise<InputFeePayerTransaction>;
-export async function buildTransaction(
-  args: InputGenerateMultiAgentRawTransactionArgs,
-): Promise<InputMultiAgentTransaction>;
-export async function buildTransaction(args: InputGenerateRawTransactionArgs): Promise<AnyRawTransaction>;
+): Promise<SingleSignerTransaction>;
+export async function buildTransaction(args: InputGenerateMultiAgentRawTransactionArgs): Promise<MultiAgentTransaction>;
+
 /**
  * Generates a transaction based on the provided arguments
  *
@@ -297,29 +282,22 @@ export async function buildTransaction(args: InputGenerateRawTransactionArgs): P
     options,
   });
 
-  if ("feePayerAddress" in args) {
-    const signers: Array<AccountAddress> =
-      args.secondarySignerAddresses?.map((signer) => AccountAddress.fromRelaxed(signer)) ?? [];
-
-    return {
-      rawTransaction: rawTxn,
-      secondarySignerAddresses: signers,
-      feePayerAddress:
-        args?.feePayerAddress !== undefined ? AccountAddress.fromRelaxed(args.feePayerAddress) : undefined,
-    };
-  }
-
+  // if multi agent transaction
   if ("secondarySignerAddresses" in args) {
     const signers: Array<AccountAddress> =
-      args.secondarySignerAddresses?.map((signer) => AccountAddress.fromRelaxed(signer)) ?? [];
+      args.secondarySignerAddresses?.map((signer) => AccountAddress.from(signer)) ?? [];
 
     return {
       rawTransaction: rawTxn,
       secondarySignerAddresses: signers,
+      feePayerAddress: args.feePayerAddress ? AccountAddress.from(args.feePayerAddress) : undefined,
     };
   }
   // return the raw transaction
-  return { rawTransaction: rawTxn };
+  return {
+    rawTransaction: rawTxn,
+    feePayerAddress: args.feePayerAddress ? AccountAddress.from(args.feePayerAddress) : undefined,
+  };
 }
 
 /**
@@ -336,25 +314,21 @@ 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.bcsToBytes());
-  const deserializedTransaction = RawTransaction.deserialize(deserializer);
-
   const accountAuthenticator = getAuthenticatorForSimulation(signerPublicKey);
+
   // fee payer transaction
-  if ("feePayerAddress" in transaction) {
+  if (transaction.feePayerAddress) {
     const transactionToSign = new FeePayerRawTransaction(
-      deserializedTransaction,
+      transaction.rawTransaction,
       transaction.secondarySignerAddresses ?? [],
       transaction.feePayerAddress,
     );
-
     let secondaryAccountAuthenticators: Array<AccountAuthenticator> = [];
     if (secondarySignersPublicKeys) {
       secondaryAccountAuthenticators = secondarySignersPublicKeys.map((publicKey) =>
         getAuthenticatorForSimulation(publicKey),
       );
     }
-
     const feePayerAuthenticator = getAuthenticatorForSimulation(feePayerPublicKey!);
 
     const transactionAuthenticator = new TransactionAuthenticatorFeePayer(
@@ -370,9 +344,9 @@ export function generateSignedTransactionForSimulation(args: InputSimulateTransa
   }
 
   // multi agent transaction
-  if ("secondarySignerAddresses" in transaction) {
+  if (transaction.secondarySignerAddresses) {
     const transactionToSign = new MultiAgentRawTransaction(
-      deserializedTransaction,
+      transaction.rawTransaction,
       transaction.secondarySignerAddresses,
     );
 
@@ -391,7 +365,7 @@ export function generateSignedTransactionForSimulation(args: InputSimulateTransa
     return new SignedTransaction(transactionToSign.raw_txn, transactionAuthenticator).bcsToBytes();
   }
 
-  // raw transaction
+  // single signer raw transaction
   let transactionAuthenticator;
   if (accountAuthenticator instanceof AccountAuthenticatorEd25519) {
     transactionAuthenticator = new TransactionAuthenticatorEd25519(
@@ -403,7 +377,7 @@ export function generateSignedTransactionForSimulation(args: InputSimulateTransa
   } else {
     throw new Error("Invalid public key");
   }
-  return new SignedTransaction(deserializedTransaction, transactionAuthenticator).bcsToBytes();
+  return new SignedTransaction(transaction.rawTransaction, transactionAuthenticator).bcsToBytes();
 }
 
 export function getAuthenticatorForSimulation(publicKey: PublicKey) {
@@ -418,7 +392,6 @@ export function getAuthenticatorForSimulation(publicKey: PublicKey) {
   }
 
   // legacy code
-  // TODO add support to legacy multied25519
   return new AccountAuthenticatorEd25519(
     new Ed25519PublicKey(publicKey.toUint8Array()),
     new Ed25519Signature(new Uint8Array(64)),
@@ -436,10 +409,8 @@ export function getAuthenticatorForSimulation(publicKey: PublicKey) {
 export function sign(args: { signer: Account; transaction: AnyRawTransaction }): AccountAuthenticator {
   const { signer, transaction } = args;
 
-  const transactionToSign = deriveTransactionType(transaction);
-
   // get the signing message
-  const message = getSigningMessage(transactionToSign);
+  const message = generateSigningMessage(transaction);
 
   // account.signMessage
   const signerSignature = signer.sign(message);
@@ -452,7 +423,10 @@ export function sign(args: { signer: Account; transaction: AnyRawTransaction }):
         new Ed25519Signature(signerSignature.toUint8Array()),
       );
     case SigningScheme.SingleKey:
-      return new AccountAuthenticatorSingleKey(signer.publicKey as AnyPublicKey, new AnySignature(signerSignature));
+      if (!AnyPublicKey.isPublicKey(signer.publicKey)) {
+        throw new Error(`Cannot sign transaction, public key does not match ${signer.signingScheme}`);
+      }
+      return new AccountAuthenticatorSingleKey(signer.publicKey, new AnySignature(signerSignature));
     // TODO support MultiEd25519
     default:
       throw new Error(`Cannot sign transaction, signing scheme ${signer.signingScheme} not supported`);
@@ -473,9 +447,12 @@ export function generateSignedTransaction(args: InputSubmitTransactionData): Uin
 
   const transactionToSubmit = deriveTransactionType(transaction);
 
-  if (feePayerAuthenticator || additionalSignersAuthenticators) {
+  if (
+    (feePayerAuthenticator || additionalSignersAuthenticators) &&
+    (transactionToSubmit instanceof MultiAgentRawTransaction || transactionToSubmit instanceof FeePayerRawTransaction)
+  ) {
     return generateMultiSignersSignedTransaction(
-      transactionToSubmit as MultiAgentRawTransaction | FeePayerRawTransaction,
+      transactionToSubmit,
       senderAuthenticator,
       feePayerAuthenticator,
       additionalSignersAuthenticators,
@@ -485,20 +462,21 @@ export function generateSignedTransaction(args: InputSubmitTransactionData): Uin
   // submit single signer transaction
 
   // check what instance is accountAuthenticator
-  if (senderAuthenticator instanceof AccountAuthenticatorEd25519) {
+  if (senderAuthenticator instanceof AccountAuthenticatorEd25519 && transactionToSubmit instanceof RawTransaction) {
     const transactionAuthenticator = new TransactionAuthenticatorEd25519(
       senderAuthenticator.public_key,
       senderAuthenticator.signature,
     );
-    return new SignedTransaction(transactionToSubmit as RawTransaction, transactionAuthenticator).bcsToBytes();
+    return new SignedTransaction(transactionToSubmit, transactionAuthenticator).bcsToBytes();
   }
 
   if (
-    senderAuthenticator instanceof AccountAuthenticatorSingleKey ||
-    senderAuthenticator instanceof AccountAuthenticatorMultiKey
+    (senderAuthenticator instanceof AccountAuthenticatorSingleKey ||
+      senderAuthenticator instanceof AccountAuthenticatorMultiKey) &&
+    transactionToSubmit instanceof RawTransaction
   ) {
     const transactionAuthenticator = new TransactionAuthenticatorSingleSender(senderAuthenticator);
-    return new SignedTransaction(transactionToSubmit as RawTransaction, transactionAuthenticator).bcsToBytes();
+    return new SignedTransaction(transactionToSubmit, transactionAuthenticator).bcsToBytes();
   }
 
   throw new Error(
@@ -514,18 +492,18 @@ export function generateSignedTransaction(args: InputSubmitTransactionData): Uin
  * @returns FeePayerRawTransaction | MultiAgentRawTransaction | RawTransaction
  */
 export function deriveTransactionType(transaction: AnyRawTransaction): AnyRawTransactionInstance {
-  if ("feePayerAddress" in transaction) {
+  if (transaction.feePayerAddress) {
     return new FeePayerRawTransaction(
       transaction.rawTransaction,
       transaction.secondarySignerAddresses ?? [],
       transaction.feePayerAddress,
     );
   }
-  if ("secondarySignerAddresses" in transaction) {
+  if (transaction.secondarySignerAddresses) {
     return new MultiAgentRawTransaction(transaction.rawTransaction, transaction.secondarySignerAddresses);
   }
 
-  return transaction.rawTransaction as RawTransaction;
+  return transaction.rawTransaction;
 }
 
 /**
@@ -577,7 +555,8 @@ export function generateMultiSignersSignedTransaction(
   );
 }
 
-export function getSigningMessage(rawTxn: AnyRawTransactionInstance): Uint8Array {
+export function generateSigningMessage(transaction: AnyRawTransaction): Uint8Array {
+  const rawTxn = deriveTransactionType(transaction);
   const hash = sha3Hash.create();
 
   if (rawTxn instanceof RawTransaction) {

package/src/transactions/typeTag/parser.ts

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

package/src/transactions/types.ts

@@ -30,7 +30,7 @@ export type SimpleEntryFunctionArgumentTypes =
   | null // To support optional empty
   | undefined // To support optional empty
   | Uint8Array
-  | Array<SimpleEntryFunctionArgumentTypes>;
+  | Array<SimpleEntryFunctionArgumentTypes | EntryFunctionArgumentTypes>;
 
 /**
  * Entry function arguments to be used when building a raw transaction using BCS serialized arguments
@@ -115,7 +115,7 @@ export type InputEntryFunctionDataWithRemoteABI = InputEntryFunctionData & { apt
  * The data needed to generate a Multi Sig payload
  */
 export type InputMultiSigData = {
-  multisigAddress: AccountAddress;
+  multisigAddress: AccountAddressInput;
 } & InputEntryFunctionData;
 
 /**
@@ -153,19 +153,7 @@ export interface InputGenerateSingleSignerRawTransactionArgs {
   sender: AccountAddressInput;
   payload: AnyTransactionPayloadInstance;
   options?: InputGenerateTransactionOptions;
-}
-
-/**
- * Interface of the arguments to generate a fee payer transaction.
- * Used to provide to `generateTransaction()` method in the transaction builder flow
- */
-export interface InputGenerateFeePayerRawTransactionArgs {
-  aptosConfig: AptosConfig;
-  sender: AccountAddressInput;
-  payload: AnyTransactionPayloadInstance;
-  feePayerAddress: AccountAddressInput;
-  secondarySignerAddresses?: AccountAddressInput[];
-  options?: InputGenerateTransactionOptions;
+  feePayerAddress?: AccountAddressInput;
 }
 
 /**
@@ -178,6 +166,7 @@ export interface InputGenerateMultiAgentRawTransactionArgs {
   payload: AnyTransactionPayloadInstance;
   secondarySignerAddresses: AccountAddressInput[];
   options?: InputGenerateTransactionOptions;
+  feePayerAddress?: AccountAddressInput;
 }
 
 /**
@@ -185,7 +174,6 @@ export interface InputGenerateMultiAgentRawTransactionArgs {
  */
 export type InputGenerateRawTransactionArgs =
   | InputGenerateSingleSignerRawTransactionArgs
-  | InputGenerateFeePayerRawTransactionArgs
   | InputGenerateMultiAgentRawTransactionArgs;
 
 /**
@@ -193,21 +181,10 @@ export type InputGenerateRawTransactionArgs =
  *
  * @param rawTransaction a bcs serialized raw transaction
  */
-export interface InputSingleSignerTransaction {
-  rawTransaction: RawTransaction;
-}
-
-/**
- * Interface that holds the return data when generating a fee payer transaction
- *
- * @param rawTransaction a bcs serialized raw transaction
- * @param secondarySignerAddresses optional. secondary signer addresses for multi-agent transaction
- * @param feePayerAddress fee payer address for a fee payer transaction (aka Sponsored Transaction)
- */
-export interface InputFeePayerTransaction {
+export interface SingleSignerTransaction {
   rawTransaction: RawTransaction;
-  feePayerAddress: AccountAddress;
-  secondarySignerAddresses?: AccountAddress[];
+  feePayerAddress?: AccountAddress;
+  secondarySignerAddresses?: undefined;
 }
 
 /**
@@ -216,15 +193,16 @@ export interface InputFeePayerTransaction {
  * @param rawTransaction a bcs serialized raw transaction
  * @param secondarySignerAddresses secondary signer addresses for multi-agent transaction
  */
-export interface InputMultiAgentTransaction {
+export interface MultiAgentTransaction {
   rawTransaction: RawTransaction;
   secondarySignerAddresses: AccountAddress[];
+  feePayerAddress?: AccountAddress;
 }
 
 /**
  * Unified type that holds all the return interfaces when generating different transaction types
  */
-export type AnyRawTransaction = InputSingleSignerTransaction | InputFeePayerTransaction | InputMultiAgentTransaction;
+export type AnyRawTransaction = SingleSignerTransaction | MultiAgentTransaction;
 
 // TRANSACTION SIMULATION TYPES //
 
@@ -261,19 +239,10 @@ export type InputSimulateTransactionOptions = {
  */
 export interface InputGenerateSingleSignerRawTransactionData {
   sender: AccountAddressInput;
-  options?: InputGenerateTransactionOptions;
   data: InputGenerateTransactionPayloadData;
-}
-
-/**
- * Interface that holds the user data input when generating a fee payer transaction
- */
-export interface InputGenerateFeePayerRawTransactionData {
-  sender: AccountAddressInput;
-  hasFeePayer: true;
-  secondarySignerAddresses?: AccountAddressInput[];
   options?: InputGenerateTransactionOptions;
-  data: InputGenerateTransactionPayloadData;
+  withFeePayer?: boolean;
+  secondarySignerAddresses?: undefined;
 }
 
 /**
@@ -281,18 +250,18 @@ export interface InputGenerateFeePayerRawTransactionData {
  */
 export interface InputGenerateMultiAgentRawTransactionData {
   sender: AccountAddressInput;
+  data: InputGenerateTransactionPayloadData;
   secondarySignerAddresses: AccountAddressInput[];
   options?: InputGenerateTransactionOptions;
-  data: InputGenerateTransactionPayloadData;
+  withFeePayer?: boolean;
 }
 
 /**
  * Unified type that holds all the user data input interfaces when generating different transaction types
  */
 export type InputGenerateTransactionData =
-  | InputGenerateMultiAgentRawTransactionData
-  | InputGenerateFeePayerRawTransactionData
-  | InputGenerateSingleSignerRawTransactionData;
+  | InputGenerateSingleSignerRawTransactionData
+  | InputGenerateMultiAgentRawTransactionData;
 
 /**
  * Interface that holds the user data input when submitting a transaction

package/src/types/generated/operations.ts

@@ -18,6 +18,16 @@ export type TokenActivitiesFieldsFragment = {
   type: string;
 };
 
+export type AnsTokenFragmentFragment = {
+  domain?: string | null;
+  expiration_timestamp?: any | null;
+  registered_address?: string | null;
+  subdomain?: string | null;
+  token_standard?: string | null;
+  is_primary?: boolean | null;
+  owner_address?: string | null;
+};
+
 export type CurrentTokenOwnershipFieldsFragment = {
   token_standard: string;
   token_properties_mutated_v1?: any | null;
@@ -485,8 +495,27 @@ export type GetFungibleAssetMetadataQuery = {
   }>;
 };
 
+export type GetNamesQueryVariables = Types.Exact<{
+  offset?: Types.InputMaybe<Types.Scalars["Int"]["input"]>;
+  limit?: Types.InputMaybe<Types.Scalars["Int"]["input"]>;
+  where_condition?: Types.InputMaybe<Types.CurrentAptosNamesBoolExp>;
+  order_by?: Types.InputMaybe<Array<Types.CurrentAptosNamesOrderBy> | Types.CurrentAptosNamesOrderBy>;
+}>;
+
+export type GetNamesQuery = {
+  current_aptos_names: Array<{
+    domain?: string | null;
+    expiration_timestamp?: any | null;
+    registered_address?: string | null;
+    subdomain?: string | null;
+    token_standard?: string | null;
+    is_primary?: boolean | null;
+    owner_address?: string | null;
+  }>;
+};
+
 export type GetNumberOfDelegatorsQueryVariables = Types.Exact<{
-  where_condition: Types.NumActiveDelegatorPerPoolBoolExp;
+  where_condition?: Types.InputMaybe<Types.NumActiveDelegatorPerPoolBoolExp>;
   order_by?: Types.InputMaybe<Array<Types.NumActiveDelegatorPerPoolOrderBy> | Types.NumActiveDelegatorPerPoolOrderBy>;
 }>;
 
@@ -494,7 +523,9 @@ export type GetNumberOfDelegatorsQuery = {
   num_active_delegator_per_pool: Array<{ num_active_delegator?: any | null; pool_address?: string | null }>;
 };
 
-export type GetProcessorStatusQueryVariables = Types.Exact<{ [key: string]: never }>;
+export type GetProcessorStatusQueryVariables = Types.Exact<{
+  where_condition?: Types.InputMaybe<Types.ProcessorStatusBoolExp>;
+}>;
 
 export type GetProcessorStatusQuery = {
   processor_status: Array<{ last_success_version: any; processor: string; last_updated: any }>;