@aptos-labs/ts-sdk 2.0.1 → 3.1.0

package/src/internal/keyless.ts

@@ -178,6 +178,16 @@ export async function deriveKeylessAccount(args: {
   proofFetchCallback?: ProofFetchCallback;
 }): Promise<FederatedKeylessAccount>;
 
+export async function deriveKeylessAccount(args: {
+  aptosConfig: AptosConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  jwkAddress?: AccountAddressInput;
+  uidKey?: string;
+  pepper?: HexInput;
+  proofFetchCallback?: ProofFetchCallback;
+}): Promise<KeylessAccount | FederatedKeylessAccount>;
+
 export async function deriveKeylessAccount(args: {
   aptosConfig: AptosConfig;
   jwt: string;

package/src/internal/queries/getAccountAddressesForAuthKey.graphql

@@ -0,0 +1,8 @@
+query getAccountAddressesForAuthKey($where_condition: auth_key_account_addresses_bool_exp, $order_by: [auth_key_account_addresses_order_by!]) {
+  auth_key_account_addresses(where: $where_condition, order_by: $order_by) {
+    auth_key
+    account_address
+    last_transaction_version
+    is_auth_key_used
+  }
+}

package/src/internal/queries/getAuthKeysForPublicKey.graphql

@@ -0,0 +1,11 @@
+query getAuthKeysForPublicKey($where_condition: public_key_auth_keys_bool_exp, $order_by: [public_key_auth_keys_order_by!]) {
+  public_key_auth_keys(where: $where_condition, order_by: $order_by) {
+    public_key
+    public_key_type
+    auth_key
+    account_public_key
+    last_transaction_version
+    is_public_key_used
+    signature_type
+  }
+}

package/src/internal/transactionSubmission.ts

@@ -30,6 +30,7 @@ import {
   InputGenerateSingleSignerRawTransactionData,
   AnyTransactionPayloadInstance,
   EntryFunctionABI,
+  InputTransactionPluginData,
 } from "../transactions/types";
 import { UserTransactionResponse, PendingTransactionResponse, MimeType, HexInput } from "../types";
 import { SignedTransaction, TypeTagVector, generateSigningMessageForTransaction } from "../transactions";
@@ -319,7 +320,12 @@ export async function submitTransaction(
     aptosConfig: AptosConfig;
   } & InputSubmitTransactionData,
 ): Promise<PendingTransactionResponse> {
-  const { aptosConfig } = args;
+  const { aptosConfig, transactionSubmitter } = args;
+  const maybeTransactionSubmitter =
+    transactionSubmitter === undefined ? aptosConfig.getTransactionSubmitter() : transactionSubmitter;
+  if (maybeTransactionSubmitter) {
+    return maybeTransactionSubmitter.submitTransaction(args);
+  }
   const signedTransaction = generateSignedTransaction({ ...args });
   try {
     const { data } = await postAptosFullNode<Uint8Array, PendingTransactionResponse>({
@@ -358,9 +364,9 @@ export async function signAndSubmitTransaction(
     aptosConfig: AptosConfig;
     signer: Account;
     transaction: AnyRawTransaction;
-  },
+  } & InputTransactionPluginData,
 ): Promise<PendingTransactionResponse> {
-  const { aptosConfig, signer, feePayer, transaction } = args;
+  const { aptosConfig, signer, feePayer, transaction, ...rest } = args;
   // If the signer contains a KeylessAccount, await proof fetching in case the proof
   // was fetched asynchronously.
   if (isKeylessSigner(signer)) {
@@ -378,16 +384,19 @@ export async function signAndSubmitTransaction(
     transaction,
     senderAuthenticator,
     feePayerAuthenticator,
+    ...rest,
   });
 }
 
-export async function signAndSubmitAsFeePayer(args: {
-  aptosConfig: AptosConfig;
-  feePayer: Account;
-  senderAuthenticator: AccountAuthenticator;
-  transaction: AnyRawTransaction;
-}): Promise<PendingTransactionResponse> {
-  const { aptosConfig, senderAuthenticator, feePayer, transaction } = args;
+export async function signAndSubmitAsFeePayer(
+  args: {
+    aptosConfig: AptosConfig;
+    feePayer: Account;
+    senderAuthenticator: AccountAuthenticator;
+    transaction: AnyRawTransaction;
+  } & InputTransactionPluginData,
+): Promise<PendingTransactionResponse> {
+  const { aptosConfig, senderAuthenticator, feePayer, transaction, ...rest } = args;
 
   if (isKeylessSigner(feePayer)) {
     await feePayer.checkKeylessAccountValidity(aptosConfig);
@@ -400,6 +409,7 @@ export async function signAndSubmitAsFeePayer(args: {
     transaction,
     senderAuthenticator,
     feePayerAuthenticator,
+    ...rest,
   });
 }
 

package/src/transactions/instances/transactionPayload.ts

@@ -8,11 +8,19 @@ import { Serializable, Serializer } from "../../bcs/serializer";
 import { EntryFunctionBytes } from "../../bcs/serializable/entryFunctionBytes";
 import { Bool, U128, U16, U256, U32, U64, U8 } from "../../bcs/serializable/movePrimitives";
 import { MoveVector, Serialized } from "../../bcs/serializable/moveStructs";
-import { AccountAddress } from "../../core";
+import { AccountAddress, Hex } from "../../core";
 import { Identifier } from "./identifier";
 import { ModuleId } from "./moduleId";
 import type { EntryFunctionArgument, ScriptFunctionArgument, TransactionArgument } from "./transactionArgument";
-import { MoveModuleId, ScriptTransactionArgumentVariants, TransactionPayloadVariants } from "../../types";
+import {
+  AnyNumber,
+  MoveModuleId,
+  ScriptTransactionArgumentVariants,
+  TransactionExecutableVariants,
+  TransactionExtraConfigVariants,
+  TransactionInnerPayloadVariants,
+  TransactionPayloadVariants,
+} from "../../types";
 import { TypeTag } from "../typeTag";
 
 /**
@@ -95,6 +103,8 @@ export abstract class TransactionPayload extends Serializable {
         return TransactionPayloadEntryFunction.load(deserializer);
       case TransactionPayloadVariants.Multisig:
         return TransactionPayloadMultiSig.load(deserializer);
+      case TransactionPayloadVariants.Payload:
+        return TransactionInnerPayload.deserialize(deserializer);
       default:
         throw new Error(`Unknown variant index for TransactionPayload: ${index}`);
     }
@@ -511,3 +521,156 @@ export class MultiSigTransactionPayload extends Serializable {
     return new MultiSigTransactionPayload(EntryFunction.deserialize(deserializer));
   }
 }
+
+/**
+ * Represents any transaction payload that can be submitted to the Aptos chain for execution.
+ *
+ * This is specifically required for orderless transactions, but can be used for any transaction payload.
+ */
+export abstract class TransactionInnerPayload extends TransactionPayload {
+  abstract serialize(serializer: Serializer): void;
+
+  static deserialize(deserializer: Deserializer): TransactionInnerPayload {
+    // index enum variant
+    const index = deserializer.deserializeUleb128AsU32();
+    switch (index) {
+      case TransactionInnerPayloadVariants.V1:
+        return TransactionInnerPayloadV1.load(deserializer);
+      default:
+        throw new Error(`Unknown variant index for TransactionInnerPayload: ${index}`);
+    }
+  }
+}
+
+export class TransactionInnerPayloadV1 extends TransactionInnerPayload {
+  executable: TransactionExecutable;
+  extra_config: TransactionExtraConfig;
+
+  constructor(executable: TransactionExecutable, extra_config: TransactionExtraConfig) {
+    super();
+    this.executable = executable;
+    this.extra_config = extra_config;
+  }
+
+  serialize(serializer: Serializer): void {
+    // This payload must be serialized as a top level TransactionPayload, so we add that here
+    serializer.serializeU32AsUleb128(TransactionPayloadVariants.Payload);
+    // V1 is serialized as 0
+    serializer.serializeU32AsUleb128(TransactionInnerPayloadVariants.V1);
+    this.executable.serialize(serializer);
+    this.extra_config.serialize(serializer);
+  }
+
+  static load(deserializer: Deserializer): TransactionInnerPayloadV1 {
+    let executable = TransactionExecutable.deserialize(deserializer);
+    let extra_config = TransactionExtraConfig.deserialize(deserializer);
+    return new TransactionInnerPayloadV1(executable, extra_config);
+  }
+}
+
+export abstract class TransactionExecutable {
+  abstract serialize(serializer: Serializer): void;
+
+  static deserialize(deserializer: Deserializer): TransactionExecutable {
+    // index enum variant
+    const index = deserializer.deserializeUleb128AsU32();
+    switch (index) {
+      case TransactionExecutableVariants.Script:
+        return TransactionExecutableScript.load(deserializer);
+      case TransactionExecutableVariants.EntryFunction:
+        return TransactionExecutableEntryFunction.load(deserializer);
+      case TransactionExecutableVariants.Empty:
+        return TransactionExecutableEmpty.load(deserializer);
+      default:
+        throw new Error(`Unknown variant index for TransactionExecutable: ${index}`);
+    }
+  }
+}
+
+export class TransactionExecutableScript extends TransactionExecutable {
+  script: Script;
+
+  constructor(script: Script) {
+    super();
+    this.script = script;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TransactionExecutableVariants.Script);
+    this.script.serialize(serializer);
+  }
+
+  static load(deserializer: Deserializer): TransactionExecutableScript {
+    let script = Script.deserialize(deserializer);
+    return new TransactionExecutableScript(script);
+  }
+}
+
+export class TransactionExecutableEntryFunction extends TransactionExecutable {
+  entryFunction: EntryFunction;
+
+  constructor(entryFunction: EntryFunction) {
+    super();
+    this.entryFunction = entryFunction;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TransactionExecutableVariants.EntryFunction);
+    this.entryFunction.serialize(serializer);
+  }
+
+  static load(deserializer: Deserializer): TransactionExecutableEntryFunction {
+    let entryFunction = EntryFunction.deserialize(deserializer);
+    return new TransactionExecutableEntryFunction(entryFunction);
+  }
+}
+
+export class TransactionExecutableEmpty extends TransactionExecutable {
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TransactionExecutableVariants.Empty);
+  }
+
+  static load(_: Deserializer): TransactionExecutableEmpty {
+    return new TransactionExecutableEmpty();
+  }
+}
+
+export abstract class TransactionExtraConfig {
+  abstract serialize(serializer: Serializer): void;
+
+  static deserialize(deserializer: Deserializer): TransactionExtraConfig {
+    // index enum variant
+    const index = deserializer.deserializeUleb128AsU32();
+    switch (index) {
+      case TransactionExtraConfigVariants.V1:
+        return TransactionExtraConfigV1.load(deserializer);
+      default:
+        throw new Error(`Unknown variant index for TransactionExtraConfig: ${index}`);
+    }
+  }
+}
+
+export class TransactionExtraConfigV1 extends TransactionExtraConfig {
+  multisigAddress?: AccountAddress;
+  replayProtectionNonce?: bigint;
+
+  constructor(multisigAddress?: AccountAddress, replayProtectionNonce?: AnyNumber) {
+    super();
+    this.multisigAddress = multisigAddress;
+    this.replayProtectionNonce = replayProtectionNonce !== undefined ? BigInt(replayProtectionNonce) : undefined;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(TransactionExtraConfigVariants.V1);
+    serializer.serializeOption<AccountAddress>(this.multisigAddress);
+    serializer.serializeOption<U64>(
+      this.replayProtectionNonce !== undefined ? new U64(this.replayProtectionNonce) : undefined,
+    );
+  }
+
+  static load(deserializer: Deserializer): TransactionExtraConfigV1 {
+    const multisigAddress = deserializer.deserializeOption(AccountAddress);
+    const replayProtectionNonce = deserializer.deserializeOption(U64);
+    return new TransactionExtraConfigV1(multisigAddress, replayProtectionNonce?.value);
+  }
+}

package/src/transactions/management/transactionWorker.ts

@@ -340,7 +340,7 @@ export class TransactionWorker extends EventEmitter<TransactionWorkerEvents> {
       aptosConfig: this.aptosConfig,
       sender: account.accountAddress,
       data: transactionData,
-      options: { ...options, accountSequenceNumber: sequenceNumber },
+      options: { ...options, accountSequenceNumber: sequenceNumber, replayProtectionNonce: undefined },
     });
   }
 

package/src/transactions/transactionBuilder/transactionBuilder.ts

@@ -24,7 +24,6 @@ import { getInfo } from "../../internal/utils";
 import { getLedgerInfo } from "../../internal/general";
 import { getGasPriceEstimation } from "../../internal/transaction";
 import { NetworkToChainId } from "../../utils/apiEndpoints";
-import { DEFAULT_MAX_GAS_AMOUNT, DEFAULT_TXN_EXP_SEC_FROM_NOW } from "../../utils/const";
 import { normalizeBundle } from "../../utils/normalizeBundle";
 import {
   AccountAuthenticator,
@@ -51,6 +50,7 @@ import {
   MultiSigTransactionPayload,
   RawTransaction,
   Script,
+  TransactionInnerPayload,
   TransactionPayloadEntryFunction,
   TransactionPayloadMultiSig,
   TransactionPayloadScript,
@@ -83,6 +83,14 @@ import { isScriptDataInput } from "./helpers";
 import { SimpleTransaction } from "../instances/simpleTransaction";
 import { MultiAgentTransaction } from "../instances/multiAgentTransaction";
 import { getFunctionParts } from "../../utils/helpers";
+import {
+  TransactionExecutable,
+  TransactionExecutableEmpty,
+  TransactionExecutableEntryFunction,
+  TransactionExecutableScript,
+  TransactionExtraConfigV1,
+  TransactionInnerPayloadV1,
+} from "../instances/transactionPayload";
 
 /**
  * Builds a transaction payload based on the provided arguments and returns a transaction payload.
@@ -360,6 +368,10 @@ export async function generateRawTransaction(args: {
 }): Promise<RawTransaction> {
   const { aptosConfig, sender, payload, options, feePayerAddress } = args;
 
+  if (options?.replayProtectionNonce !== undefined && options?.accountSequenceNumber !== undefined) {
+    throw new Error("Cannot specify both replayProtectionNonce and accountSequenceNumber in options.");
+  }
+
   const getChainId = async () => {
     if (NetworkToChainId[aptosConfig.network]) {
       return { chainId: NetworkToChainId[aptosConfig.network] };
@@ -380,6 +392,10 @@ export async function generateRawTransaction(args: {
     const getSequenceNumber = async () => {
       if (options?.accountSequenceNumber !== undefined) {
         return options.accountSequenceNumber;
+      } else if (options?.replayProtectionNonce !== undefined) {
+        // If replay nonce is provided, use it as the sequence number
+        // This is an unused value, so it's specifically to show that the sequence number is not used
+        return 0xdeadbeefn;
       }
 
       return (await getInfo({ aptosConfig, accountAddress: sender })).sequence_number;
@@ -410,16 +426,24 @@ export async function generateRawTransaction(args: {
     getSequenceNumberForAny(),
   ]);
 
-  const { maxGasAmount, gasUnitPrice, expireTimestamp } = {
-    maxGasAmount: options?.maxGasAmount ? BigInt(options.maxGasAmount) : BigInt(DEFAULT_MAX_GAS_AMOUNT),
+  const { maxGasAmount, gasUnitPrice, expireTimestamp, replayProtectionNonce } = {
+    maxGasAmount: options?.maxGasAmount ? BigInt(options.maxGasAmount) : BigInt(aptosConfig.getDefaultMaxGasAmount()),
     gasUnitPrice: options?.gasUnitPrice ?? BigInt(gasEstimate),
-    expireTimestamp: options?.expireTimestamp ?? BigInt(Math.floor(Date.now() / 1000) + DEFAULT_TXN_EXP_SEC_FROM_NOW),
+    expireTimestamp:
+      options?.expireTimestamp ?? BigInt(Math.floor(Date.now() / 1000) + aptosConfig.getDefaultTxnExpirySecFromNow()),
+    replayProtectionNonce: options?.replayProtectionNonce ? BigInt(options.replayProtectionNonce) : undefined,
   };
 
+  // If we're using replay nonce, we must convert the original payload
+  let txnPayload = payload;
+  if (replayProtectionNonce !== undefined) {
+    txnPayload = convertPayloadToInnerPayload(payload, replayProtectionNonce);
+  }
+
   return new RawTransaction(
     AccountAddress.from(sender),
     BigInt(sequenceNumber),
-    payload,
+    txnPayload,
     BigInt(maxGasAmount),
     BigInt(gasUnitPrice),
     BigInt(expireTimestamp),
@@ -427,6 +451,41 @@ export async function generateRawTransaction(args: {
   );
 }
 
+export function convertPayloadToInnerPayload(
+  payload: AnyTransactionPayloadInstance,
+  replayProtectionNonce?: bigint,
+): TransactionInnerPayload {
+  if (payload instanceof TransactionPayloadScript) {
+    return new TransactionInnerPayloadV1(
+      new TransactionExecutableScript(payload.script),
+      new TransactionExtraConfigV1(undefined, replayProtectionNonce),
+    );
+  } else if (payload instanceof TransactionPayloadEntryFunction) {
+    return new TransactionInnerPayloadV1(
+      new TransactionExecutableEntryFunction(payload.entryFunction),
+      new TransactionExtraConfigV1(undefined, replayProtectionNonce),
+    );
+  } else if (payload instanceof TransactionPayloadMultiSig) {
+    const innerPayload = payload.multiSig.transaction_payload;
+    let executable: TransactionExecutable;
+    if (innerPayload === undefined || innerPayload?.transaction_payload === undefined) {
+      executable = new TransactionExecutableEmpty();
+    } else if (innerPayload.transaction_payload instanceof EntryFunction) {
+      executable = new TransactionExecutableEntryFunction(innerPayload.transaction_payload);
+    } else {
+      // TODO For now, scripts are not supported in multi-sig transactions, so it's always entry function
+      throw new Error("Scripts are not supported in multi-sig transactions.");
+    }
+
+    return new TransactionInnerPayloadV1(
+      executable,
+      new TransactionExtraConfigV1(payload.multiSig.multisig_address, replayProtectionNonce),
+    );
+  } else {
+    throw new Error(`Unsupported payload type: ${payload}`);
+  }
+}
+
 /**
  * Generates a transaction based on the provided arguments.
  * This function can create both simple and multi-agent transactions, allowing for flexible transaction handling.

package/src/transactions/types.ts

@@ -14,8 +14,17 @@ import {
   TransactionPayloadEntryFunction,
   TransactionPayloadMultiSig,
   TransactionPayloadScript,
+  TransactionInnerPayload,
 } from "./instances";
-import { AnyNumber, HexInput, MoveFunctionGenericTypeParam, MoveFunctionId, MoveStructId, MoveValue } from "../types";
+import {
+  AnyNumber,
+  HexInput,
+  MoveFunctionGenericTypeParam,
+  MoveFunctionId,
+  MoveStructId,
+  MoveValue,
+  TransactionSubmitter,
+} from "../types";
 import { TypeTag } from "./typeTag";
 import { AccountAuthenticator } from "./authenticator/account";
 import { SimpleTransaction } from "./instances/simpleTransaction";
@@ -113,11 +122,30 @@ export type AnyRawTransactionInstance = RawTransaction | MultiAgentRawTransactio
  * @group Implementation
  * @category Transactions
  */
-export type InputGenerateTransactionOptions = {
+export type InputGenerateTransactionOptions =
+  | InputGenerateSequenceNumberTransactionOptions
+  | InputGenerateOrderlessTransactionOptions;
+
+/**
+ * Input options for generating a transaction that requires an account sequence number, which is the default method.
+ */
+export type InputGenerateSequenceNumberTransactionOptions = {
   maxGasAmount?: number;
   gasUnitPrice?: number;
   expireTimestamp?: number;
   accountSequenceNumber?: AnyNumber;
+  replayProtectionNonce?: undefined;
+};
+
+/**
+ * Input options for generating a transaction using the orderless method, which does not require an account sequence number.
+ */
+export type InputGenerateOrderlessTransactionOptions = {
+  maxGasAmount?: number;
+  gasUnitPrice?: number;
+  expireTimestamp?: number;
+  accountSequenceNumber?: undefined;
+  replayProtectionNonce: AnyNumber;
 };
 
 /**
@@ -129,7 +157,8 @@ export type InputGenerateTransactionOptions = {
 export type AnyTransactionPayloadInstance =
   | TransactionPayloadEntryFunction
   | TransactionPayloadScript
-  | TransactionPayloadMultiSig;
+  | TransactionPayloadMultiSig
+  | TransactionInnerPayload;
 
 /**
  * The data needed to generate a transaction payload for Entry Function, Script, or Multi Sig types.
@@ -449,19 +478,41 @@ export type InputGenerateTransactionData =
   | InputGenerateSingleSignerRawTransactionData
   | InputGenerateMultiAgentRawTransactionData;
 
+interface InputSubmitTransactionDataInner {
+  transaction: AnyRawTransaction;
+  senderAuthenticator: AccountAuthenticator;
+  feePayerAuthenticator?: AccountAuthenticator;
+  additionalSignersAuthenticators?: Array<AccountAuthenticator>;
+}
+
+export interface InputTransactionPluginData {
+  /**
+   * Additional parameters that will be passed to the transaction submitter plugin if
+   * configured.
+   */
+  pluginParams?: Record<string, any>;
+
+  /**
+   * You can set this to override the configured transaction submitter (if any).
+   * Conversely you can set this to null to ignore any configured transaction submitter.
+   */
+  transactionSubmitter?: TransactionSubmitter | null;
+}
+
 /**
  * Holds user data input for submitting a transaction.
  *
  * @param transaction - The raw transaction data.
  * @param senderAuthenticator - The authenticator for the sender's account.
  * @param feePayerAuthenticator - Optional authenticator for the fee payer's account.
- * @param additionalSignersAuthenticators - Optional array of authenticators for additional signers.
+ * @param additionalSignersAuthenticators - Optional array of authenticators for
+ * additional signers.
+ * @param pluginParams - Additional parameters that will be passed to the transaction
+ * submitter plugin if configured.
+ * @param transactionSubmitter - You can set this to override the configured transaction
+ * submitter (if any). Conversely you can set this to null to ignore any configured
+ * transaction submitter.
  * @group Implementation
  * @category Transactions
  */
-export interface InputSubmitTransactionData {
-  transaction: AnyRawTransaction;
-  senderAuthenticator: AccountAuthenticator;
-  feePayerAuthenticator?: AccountAuthenticator;
-  additionalSignersAuthenticators?: Array<AccountAuthenticator>;
-}
+export type InputSubmitTransactionData = InputSubmitTransactionDataInner & InputTransactionPluginData;

package/src/types/codegen.yaml

@@ -1,6 +1,6 @@
 overwrite: true
 documents: src/internal/queries/**/*.graphql
-schema: https://api.mainnet.aptoslabs.com/v1/graphql
+schema: https://api.devnet.aptoslabs.com/v1/graphql
 generates:
   src/types/generated/types.ts:
     plugins:

package/src/types/generated/operations.ts

@@ -77,6 +77,20 @@ export type CurrentTokenOwnershipFieldsFragment = {
   } | null;
 };
 
+export type GetAccountAddressesForAuthKeyQueryVariables = Types.Exact<{
+  where_condition?: Types.InputMaybe<Types.AuthKeyAccountAddressesBoolExp>;
+  order_by?: Types.InputMaybe<Array<Types.AuthKeyAccountAddressesOrderBy> | Types.AuthKeyAccountAddressesOrderBy>;
+}>;
+
+export type GetAccountAddressesForAuthKeyQuery = {
+  auth_key_account_addresses: Array<{
+    auth_key: string;
+    account_address: string;
+    last_transaction_version: any;
+    is_auth_key_used: boolean;
+  }>;
+};
+
 export type GetAccountCoinsCountQueryVariables = Types.Exact<{
   address?: Types.InputMaybe<Types.Scalars["String"]["input"]>;
 }>;
@@ -96,15 +110,15 @@ export type GetAccountCoinsDataQueryVariables = Types.Exact<{
 
 export type GetAccountCoinsDataQuery = {
   current_fungible_asset_balances: Array<{
-    amount?: any | null;
-    asset_type?: string | null;
+    amount: any;
+    asset_type: string;
     is_frozen: boolean;
-    is_primary?: boolean | null;
+    is_primary: boolean;
     last_transaction_timestamp?: any | null;
     last_transaction_version?: any | null;
     owner_address: string;
     storage_id: string;
-    token_standard?: string | null;
+    token_standard: string;
     metadata?: {
       token_standard: string;
       symbol: string;
@@ -346,6 +360,23 @@ export type GetAccountTransactionsCountQuery = {
   account_transactions_aggregate: { aggregate?: { count: number } | null };
 };
 
+export type GetAuthKeysForPublicKeyQueryVariables = Types.Exact<{
+  where_condition?: Types.InputMaybe<Types.PublicKeyAuthKeysBoolExp>;
+  order_by?: Types.InputMaybe<Array<Types.PublicKeyAuthKeysOrderBy> | Types.PublicKeyAuthKeysOrderBy>;
+}>;
+
+export type GetAuthKeysForPublicKeyQuery = {
+  public_key_auth_keys: Array<{
+    public_key: string;
+    public_key_type: string;
+    auth_key: string;
+    account_public_key?: string | null;
+    last_transaction_version: any;
+    is_public_key_used: boolean;
+    signature_type: string;
+  }>;
+};
+
 export type GetChainTopUserTransactionsQueryVariables = Types.Exact<{
   limit?: Types.InputMaybe<Types.Scalars["Int"]["input"]>;
 }>;
@@ -394,15 +425,15 @@ export type GetCurrentFungibleAssetBalancesQueryVariables = Types.Exact<{
 
 export type GetCurrentFungibleAssetBalancesQuery = {
   current_fungible_asset_balances: Array<{
-    amount?: any | null;
-    asset_type?: string | null;
+    amount: any;
+    asset_type: string;
     is_frozen: boolean;
-    is_primary?: boolean | null;
+    is_primary: boolean;
     last_transaction_timestamp?: any | null;
     last_transaction_version?: any | null;
     owner_address: string;
     storage_id: string;
-    token_standard?: string | null;
+    token_standard: string;
   }>;
 };