@moveindustries/ts-sdk 5.1.4

package/src/internal/keyless.ts

@@ -0,0 +1,297 @@
+// Copyright © Move Industries
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * This file contains the underlying implementations for exposed API surface in
+ * the {@link api/keyless}. By moving the methods out into a separate file,
+ * other namespaces and processes can access these methods without depending on the entire
+ * keyless namespace and without having a dependency cycle error.
+ * @group Implementation
+ */
+import { jwtDecode, JwtPayload } from "jwt-decode";
+import { Account, EphemeralKeyPair, KeylessAccount, ProofFetchCallback } from "../account";
+import { FederatedKeylessAccount } from "../account/FederatedKeylessAccount";
+import { MovementConfig } from "../api/movementConfig";
+import { MoveVector } from "../bcs";
+import { postAptosPepperService, postAptosProvingService } from "../client";
+import {
+  AccountAddressInput,
+  EphemeralSignature,
+  getKeylessConfig,
+  Groth16Zkp,
+  Hex,
+  KeylessPublicKey,
+  MoveJWK,
+  ZeroKnowledgeSig,
+  ZkProof,
+} from "../core";
+import { FederatedKeylessPublicKey } from "../core/crypto/federatedKeyless";
+import { KeylessError, KeylessErrorType } from "../errors";
+import { InputGenerateTransactionOptions, SimpleTransaction } from "../transactions";
+import { HexInput, ZkpVariant } from "../types";
+import { PepperFetchRequest, PepperFetchResponse, ProverRequest, ProverResponse } from "../types/keyless";
+import { FIREBASE_AUTH_ISS_PATTERN } from "../utils/const";
+import { lookupOriginalAccountAddress } from "./account";
+import { generateTransaction } from "./transactionSubmission";
+
+/**
+ * Retrieves a pepper value based on the provided configuration and authentication details.
+ *
+ * @param args - The arguments required to fetch the pepper.
+ * @param args.movementConfig - The configuration object for Movement.
+ * @param args.jwt - The JSON Web Token used for authentication.
+ * @param args.ephemeralKeyPair - The ephemeral key pair used for the operation.
+ * @param args.uidKey - An optional unique identifier key (defaults to "sub").
+ * @param args.derivationPath - An optional derivation path for the key.
+ * @returns A Uint8Array containing the fetched pepper value.
+ * @group Implementation
+ */
+export async function getPepper(args: {
+  movementConfig: MovementConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  uidKey?: string;
+  derivationPath?: string;
+}): Promise<Uint8Array> {
+  const { movementConfig, jwt, ephemeralKeyPair, uidKey = "sub", derivationPath } = args;
+
+  const body = {
+    jwt_b64: jwt,
+    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
+    exp_date_secs: ephemeralKeyPair.expiryDateSecs,
+    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
+    uid_key: uidKey,
+    derivation_path: derivationPath,
+  };
+  const { data } = await postAptosPepperService<PepperFetchRequest, PepperFetchResponse>({
+    movementConfig,
+    path: "fetch",
+    body,
+    originMethod: "getPepper",
+    overrides: { WITH_CREDENTIALS: false },
+  });
+  return Hex.fromHexInput(data.pepper).toUint8Array();
+}
+
+/**
+ * Generates a zero-knowledge proof based on the provided parameters.
+ * This function is essential for creating a signed proof that can be used in various cryptographic operations.
+ *
+ * @param args - The parameters required to generate the proof.
+ * @param args.movementConfig - The configuration settings for Movement.
+ * @param args.jwt - The JSON Web Token used for authentication.
+ * @param args.ephemeralKeyPair - The ephemeral key pair used for generating the proof.
+ * @param args.pepper - An optional hex input used to enhance security (default is generated if not provided).
+ * @param args.uidKey - An optional string that specifies the unique identifier key (defaults to "sub").
+ * @throws Error if the pepper length is not valid or if the ephemeral key pair's lifespan exceeds the maximum allowed.
+ * @group Implementation
+ */
+export async function getProof(args: {
+  movementConfig: MovementConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  pepper?: HexInput;
+  uidKey?: string;
+  maxExpHorizonSecs?: number;
+}): Promise<ZeroKnowledgeSig> {
+  const {
+    movementConfig,
+    jwt,
+    ephemeralKeyPair,
+    pepper = await getPepper(args),
+    uidKey = "sub",
+    maxExpHorizonSecs = (await getKeylessConfig({ movementConfig })).maxExpHorizonSecs,
+  } = args;
+  if (Hex.fromHexInput(pepper).toUint8Array().length !== KeylessAccount.PEPPER_LENGTH) {
+    throw new Error(`Pepper needs to be ${KeylessAccount.PEPPER_LENGTH} bytes`);
+  }
+  const decodedJwt = jwtDecode<JwtPayload>(jwt);
+  if (typeof decodedJwt.iat !== "number") {
+    throw new Error("iat was not found");
+  }
+  if (maxExpHorizonSecs < ephemeralKeyPair.expiryDateSecs - decodedJwt.iat) {
+    throw Error(`The EphemeralKeyPair is too long lived.  It's lifespan must be less than ${maxExpHorizonSecs}`);
+  }
+  const json = {
+    jwt_b64: jwt,
+    epk: ephemeralKeyPair.getPublicKey().bcsToHex().toStringWithoutPrefix(),
+    epk_blinder: Hex.fromHexInput(ephemeralKeyPair.blinder).toStringWithoutPrefix(),
+    exp_date_secs: ephemeralKeyPair.expiryDateSecs,
+    exp_horizon_secs: maxExpHorizonSecs,
+    pepper: Hex.fromHexInput(pepper).toStringWithoutPrefix(),
+    uid_key: uidKey,
+  };
+
+  const { data } = await postAptosProvingService<ProverRequest, ProverResponse>({
+    movementConfig,
+    path: "prove",
+    body: json,
+    originMethod: "getProof",
+    overrides: { WITH_CREDENTIALS: false },
+  });
+
+  const proofPoints = data.proof;
+  const groth16Zkp = new Groth16Zkp({
+    a: proofPoints.a,
+    b: proofPoints.b,
+    c: proofPoints.c,
+  });
+
+  const signedProof = new ZeroKnowledgeSig({
+    proof: new ZkProof(groth16Zkp, ZkpVariant.Groth16),
+    trainingWheelsSignature: EphemeralSignature.fromHex(data.training_wheels_signature),
+    expHorizonSecs: maxExpHorizonSecs,
+  });
+  return signedProof;
+}
+
+/**
+ * Derives a keyless account by fetching the necessary proof and looking up the original account address.
+ * This function helps in creating a keyless account that can be used without managing private keys directly.
+ *
+ * @param args - The arguments required to derive the keyless account.
+ * @param args.movementConfig - The configuration settings for Movement.
+ * @param args.jwt - The JSON Web Token used for authentication.
+ * @param args.ephemeralKeyPair - The ephemeral key pair used for cryptographic operations.
+ * @param args.uidKey - An optional unique identifier key for the user.
+ * @param args.pepper - An optional hexadecimal input used for additional security.
+ * @param args.proofFetchCallback - An optional callback function to handle the proof fetch outcome.
+ * @returns A keyless account object.
+ * @group Implementation
+ */
+export async function deriveKeylessAccount(args: {
+  movementConfig: MovementConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  uidKey?: string;
+  pepper?: HexInput;
+  proofFetchCallback?: ProofFetchCallback;
+}): Promise<KeylessAccount>;
+
+export async function deriveKeylessAccount(args: {
+  movementConfig: MovementConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  jwkAddress: AccountAddressInput;
+  uidKey?: string;
+  pepper?: HexInput;
+  proofFetchCallback?: ProofFetchCallback;
+}): Promise<FederatedKeylessAccount>;
+
+export async function deriveKeylessAccount(args: {
+  movementConfig: MovementConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  jwkAddress?: AccountAddressInput;
+  uidKey?: string;
+  pepper?: HexInput;
+  proofFetchCallback?: ProofFetchCallback;
+}): Promise<KeylessAccount | FederatedKeylessAccount>;
+
+export async function deriveKeylessAccount(args: {
+  movementConfig: MovementConfig;
+  jwt: string;
+  ephemeralKeyPair: EphemeralKeyPair;
+  jwkAddress?: AccountAddressInput;
+  uidKey?: string;
+  pepper?: HexInput;
+  proofFetchCallback?: ProofFetchCallback;
+}): Promise<KeylessAccount | FederatedKeylessAccount> {
+  const { movementConfig, jwt, jwkAddress, uidKey, proofFetchCallback, pepper = await getPepper(args) } = args;
+  const { verificationKey, maxExpHorizonSecs } = await getKeylessConfig({ movementConfig });
+
+  const proofPromise = getProof({ ...args, pepper, maxExpHorizonSecs });
+  // If a callback is provided, pass in the proof as a promise to KeylessAccount.create.  This will make the proof be fetched in the
+  // background and the callback will handle the outcome of the fetch.  This allows the developer to not have to block on the proof fetch
+  // allowing for faster rendering of UX.
+  //
+  // If no callback is provided, the just await the proof fetch and continue synchronously.
+  const proof = proofFetchCallback ? proofPromise : await proofPromise;
+
+  // Look up the original address to handle key rotations and then instantiate the account.
+  if (jwkAddress !== undefined) {
+    const publicKey = FederatedKeylessPublicKey.fromJwtAndPepper({ jwt, pepper, jwkAddress, uidKey });
+    const address = await lookupOriginalAccountAddress({
+      movementConfig,
+      authenticationKey: publicKey.authKey().derivedAddress(),
+    });
+
+    return FederatedKeylessAccount.create({
+      ...args,
+      address,
+      proof,
+      pepper,
+      proofFetchCallback,
+      jwkAddress,
+      verificationKey,
+    });
+  }
+
+  const publicKey = KeylessPublicKey.fromJwtAndPepper({ jwt, pepper, uidKey });
+  const address = await lookupOriginalAccountAddress({
+    movementConfig,
+    authenticationKey: publicKey.authKey().derivedAddress(),
+  });
+  return KeylessAccount.create({ ...args, address, proof, pepper, proofFetchCallback, verificationKey });
+}
+
+export interface JWKS {
+  keys: MoveJWK[];
+}
+
+export async function updateFederatedKeylessJwkSetTransaction(args: {
+  movementConfig: MovementConfig;
+  sender: Account;
+  iss: string;
+  jwksUrl?: string;
+  options?: InputGenerateTransactionOptions;
+}): Promise<SimpleTransaction> {
+  const { movementConfig, sender, iss, options } = args;
+
+  let { jwksUrl } = args;
+
+  if (jwksUrl === undefined) {
+    if (FIREBASE_AUTH_ISS_PATTERN.test(iss)) {
+      jwksUrl = "https://www.googleapis.com/service_accounts/v1/jwk/securetoken@system.gserviceaccount.com";
+    } else {
+      jwksUrl = iss.endsWith("/") ? `${iss}.well-known/jwks.json` : `${iss}/.well-known/jwks.json`;
+    }
+  }
+
+  let response: Response;
+
+  try {
+    response = await fetch(jwksUrl);
+    if (!response.ok) {
+      throw new Error(`${response.status} ${response.statusText}`);
+    }
+  } catch (error) {
+    let errorMessage: string;
+    if (error instanceof Error) {
+      errorMessage = `${error.message}`;
+    } else {
+      errorMessage = `error unknown - ${error}`;
+    }
+    throw KeylessError.fromErrorType({
+      type: KeylessErrorType.JWK_FETCH_FAILED_FEDERATED,
+      details: `Failed to fetch JWKS at ${jwksUrl}: ${errorMessage}`,
+    });
+  }
+
+  const jwks: JWKS = await response.json();
+  return generateTransaction({
+    movementConfig,
+    sender: sender.accountAddress,
+    data: {
+      function: "0x1::jwks::update_federated_jwk_set",
+      functionArguments: [
+        iss,
+        MoveVector.MoveString(jwks.keys.map((key) => key.kid)),
+        MoveVector.MoveString(jwks.keys.map((key) => key.alg)),
+        MoveVector.MoveString(jwks.keys.map((key) => key.e)),
+        MoveVector.MoveString(jwks.keys.map((key) => key.n)),
+      ],
+    },
+    options,
+  });
+}

package/src/internal/object.ts

@@ -0,0 +1,68 @@
+import { MovementConfig } from "../api/movementConfig";
+import { AccountAddress, AccountAddressInput } from "../core";
+import { GetObjectDataQueryResponse, OrderByArg, PaginationArgs, WhereArg } from "../types";
+import { GetObjectDataQuery } from "../types/generated/operations";
+import { GetObjectData } from "../types/generated/queries";
+import { CurrentObjectsBoolExp } from "../types/generated/types";
+import { queryIndexer } from "./general";
+
+/**
+ * Retrieves the current objects based on specified filtering and pagination options.
+ *
+ * @param args - The arguments for retrieving object data.
+ * @param args.movementConfig - The configuration settings for Movement.
+ * @param [args.options] - Optional parameters for pagination and filtering.
+ * @param [args.options.offset] - The number of items to skip before starting to collect the result set.
+ * @param [args.options.limit] - The maximum number of items to return.
+ * @param [args.options.orderBy] - The criteria for ordering the results.
+ * @param [args.options.where] - The conditions to filter the results.
+ * @returns The current objects that match the specified criteria.
+ * @group Implementation
+ */
+export async function getObjectData(args: {
+  movementConfig: MovementConfig;
+  options?: PaginationArgs & OrderByArg<GetObjectDataQueryResponse[0]> & WhereArg<CurrentObjectsBoolExp>;
+}): Promise<GetObjectDataQueryResponse> {
+  const { movementConfig, options } = args;
+
+  const graphqlQuery = {
+    query: GetObjectData,
+    variables: {
+      where_condition: options?.where,
+      offset: options?.offset,
+      limit: options?.limit,
+      order_by: options?.orderBy,
+    },
+  };
+  const data = await queryIndexer<GetObjectDataQuery>({
+    movementConfig,
+    query: graphqlQuery,
+    originMethod: "getObjectData",
+  });
+
+  return data.current_objects;
+}
+
+/**
+ * Retrieves the object data associated with a specific object address.
+ * This function allows you to access detailed information about an object in the Movement blockchain.
+ *
+ * @param args - The arguments for retrieving object data.
+ * @param args.movementConfig - The configuration for connecting to the Movement blockchain.
+ * @param args.objectAddress - The address of the object whose data is being retrieved.
+ * @param args.options - Optional parameters for pagination and ordering of the results.
+ * @group Implementation
+ */
+export async function getObjectDataByObjectAddress(args: {
+  movementConfig: MovementConfig;
+  objectAddress: AccountAddressInput;
+  options?: PaginationArgs & OrderByArg<GetObjectDataQueryResponse[0]>;
+}): Promise<GetObjectDataQueryResponse[0]> {
+  const { movementConfig, objectAddress, options } = args;
+  const address = AccountAddress.from(objectAddress).toStringLong();
+
+  const whereCondition: { object_address: { _eq: string } } = {
+    object_address: { _eq: address },
+  };
+  return (await getObjectData({ movementConfig, options: { ...options, where: whereCondition } }))[0];
+}

package/src/internal/queries/TokenActivitiesFieldsFragment.graphql

@@ -0,0 +1,17 @@
+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
+}

package/src/internal/queries/ansTokenFragment.graphql

@@ -0,0 +1,11 @@
+fragment AnsTokenFragment on current_aptos_names {
+  domain
+  expiration_timestamp
+  registered_address
+  subdomain
+  token_standard
+  is_primary
+  owner_address
+  subdomain_expiration_policy
+  domain_expiration_timestamp
+}

package/src/internal/queries/currentTokenOwnershipFieldsFragment.graphql

@@ -0,0 +1,46 @@
+fragment CurrentTokenOwnershipFields on current_token_ownerships_v2 {
+  token_standard
+  token_properties_mutated_v1
+  token_data_id
+  table_type_v1
+  storage_id
+  property_version_v1
+  owner_address
+  last_transaction_version
+  last_transaction_timestamp
+  is_soulbound_v2
+  is_fungible_v2
+  amount
+  current_token_data {
+    collection_id
+    description
+    is_fungible_v2
+    largest_property_version_v1
+    last_transaction_timestamp
+    last_transaction_version
+    maximum
+    supply
+    token_data_id
+    token_name
+    token_properties
+    token_standard
+    token_uri
+    decimals
+    current_collection {
+      collection_id
+      collection_name
+      creator_address
+      current_supply
+      description
+      last_transaction_timestamp
+      last_transaction_version
+      max_supply
+      mutable_description
+      mutable_uri
+      table_handle_v1
+      token_standard
+      total_minted_v2
+      uri
+    }
+  }
+}

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/getAccountCoinCount.graphql

@@ -0,0 +1,7 @@
+query getAccountCoinsCount($address: String) {
+  current_fungible_asset_balances_aggregate(where: { owner_address: { _eq: $address } }) {
+    aggregate {
+      count
+    }
+  }
+}

package/src/internal/queries/getAccountCoinsData.graphql

@@ -0,0 +1,32 @@
+query getAccountCoinsData(
+  $where_condition: current_fungible_asset_balances_bool_exp!
+  $offset: Int
+  $limit: Int
+  $order_by: [current_fungible_asset_balances_order_by!]
+) {
+  current_fungible_asset_balances(where: $where_condition, offset: $offset, limit: $limit, order_by: $order_by) {
+    amount
+    asset_type
+    is_frozen
+    is_primary
+    last_transaction_timestamp
+    last_transaction_version
+    owner_address
+    storage_id
+    token_standard
+    metadata {
+      token_standard
+      symbol
+      supply_aggregator_table_key_v1
+      supply_aggregator_table_handle_v1
+      project_uri
+      name
+      last_transaction_version
+      last_transaction_timestamp
+      icon_uri
+      decimals
+      creator_address
+      asset_type
+    }
+  }
+}

package/src/internal/queries/getAccountCollectionsWithOwnedTokens.graphql

@@ -0,0 +1,33 @@
+query getAccountCollectionsWithOwnedTokens(
+  $where_condition: current_collection_ownership_v2_view_bool_exp!
+  $offset: Int
+  $limit: Int
+  $order_by: [current_collection_ownership_v2_view_order_by!]
+) {
+  current_collection_ownership_v2_view(where: $where_condition, offset: $offset, limit: $limit, order_by: $order_by) {
+    current_collection {
+      collection_id
+      collection_name
+      creator_address
+      current_supply
+      description
+      last_transaction_timestamp
+      last_transaction_version
+      mutable_description
+      max_supply
+      mutable_uri
+      table_handle_v1
+      token_standard
+      total_minted_v2
+      uri
+    }
+    collection_id
+    collection_name
+    collection_uri
+    creator_address
+    distinct_tokens
+    last_transaction_version
+    owner_address
+    single_token_uri
+  }
+}

package/src/internal/queries/getAccountOwnedTokens.graphql

@@ -0,0 +1,11 @@
+#import "./CurrentTokenOwnershipFieldsFragment";
+query getAccountOwnedTokens(
+  $where_condition: current_token_ownerships_v2_bool_exp!
+  $offset: Int
+  $limit: Int
+  $order_by: [current_token_ownerships_v2_order_by!]
+) {
+  current_token_ownerships_v2(where: $where_condition, offset: $offset, limit: $limit, order_by: $order_by) {
+    ...CurrentTokenOwnershipFields
+  }
+}

package/src/internal/queries/getAccountOwnedTokensByTokenData.graphql

@@ -0,0 +1,11 @@
+#import "./CurrentTokenOwnershipFieldsFragment";
+query getAccountOwnedTokensByTokenData(
+  $where_condition: current_token_ownerships_v2_bool_exp!
+  $offset: Int
+  $limit: Int
+  $order_by: [current_token_ownerships_v2_order_by!]
+) {
+  current_token_ownerships_v2(where: $where_condition, offset: $offset, limit: $limit, order_by: $order_by) {
+    ...CurrentTokenOwnershipFields
+  }
+}

package/src/internal/queries/getAccountOwnedTokensFromCollectionAddress.graphql

@@ -0,0 +1,11 @@
+#import "./CurrentTokenOwnershipFieldsFragment";
+query getAccountOwnedTokensFromCollection(
+  $where_condition: current_token_ownerships_v2_bool_exp!
+  $offset: Int
+  $limit: Int
+  $order_by: [current_token_ownerships_v2_order_by!]
+) {
+  current_token_ownerships_v2(where: $where_condition, offset: $offset, limit: $limit, order_by: $order_by) {
+    ...CurrentTokenOwnershipFields
+  }
+}

package/src/internal/queries/getAccountTokensCount.graphql

@@ -0,0 +1,7 @@
+query getAccountTokensCount($where_condition: current_token_ownerships_v2_bool_exp, $offset: Int, $limit: Int) {
+  current_token_ownerships_v2_aggregate(where: $where_condition, offset: $offset, limit: $limit) {
+    aggregate {
+      count
+    }
+  }
+}

package/src/internal/queries/getAccountTransactionsCount.graphql

@@ -0,0 +1,7 @@
+query getAccountTransactionsCount($address: String) {
+  account_transactions_aggregate(where: { account_address: { _eq: $address } }) {
+    aggregate {
+      count
+    }
+  }
+}

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/queries/getChainTopUserTransactions.graphql

@@ -0,0 +1,5 @@
+query getChainTopUserTransactions($limit: Int) {
+  user_transactions(limit: $limit, order_by: { version: desc }) {
+    version
+  }
+}

package/src/internal/queries/getCollectionData.graphql

@@ -0,0 +1,29 @@
+query getCollectionData($where_condition: current_collections_v2_bool_exp!) {
+  current_collections_v2(where: $where_condition) {
+    uri
+    total_minted_v2
+    token_standard
+    table_handle_v1
+    mutable_uri
+    mutable_description
+    max_supply
+    collection_id
+    collection_name
+    creator_address
+    current_supply
+    description
+    last_transaction_timestamp
+    last_transaction_version
+    cdn_asset_uris {
+      cdn_image_uri
+      asset_uri
+      animation_optimizer_retry_count
+      cdn_animation_uri
+      cdn_json_uri
+      image_optimizer_retry_count
+      json_parser_retry_count
+      raw_animation_uri
+      raw_image_uri
+    }
+  }
+}

package/src/internal/queries/getCurrentFungibleAssetBalances.graphql

@@ -0,0 +1,17 @@
+query getCurrentFungibleAssetBalances(
+  $where_condition: current_fungible_asset_balances_bool_exp
+  $offset: Int
+  $limit: Int
+) {
+  current_fungible_asset_balances(where: $where_condition, offset: $offset, limit: $limit) {
+    amount
+    asset_type
+    is_frozen
+    is_primary
+    last_transaction_timestamp
+    last_transaction_version
+    owner_address
+    storage_id
+    token_standard
+  }
+}

package/src/internal/queries/getDelegatedStakingActivities.graphql

@@ -0,0 +1,12 @@
+query getDelegatedStakingActivities($delegatorAddress: String, $poolAddress: String) {
+  delegated_staking_activities(
+    where: { delegator_address: { _eq: $delegatorAddress }, pool_address: { _eq: $poolAddress } }
+  ) {
+    amount
+    delegator_address
+    event_index
+    event_type
+    pool_address
+    transaction_version
+  }
+}

package/src/internal/queries/getEvents.graphql

@@ -0,0 +1,13 @@
+query getEvents($where_condition: events_bool_exp, $offset: Int, $limit: Int, $order_by: [events_order_by!]) {
+  events(where: $where_condition, offset: $offset, limit: $limit, order_by: $order_by) {
+    account_address
+    creation_number
+    data
+    event_index
+    sequence_number
+    transaction_block_height
+    transaction_version
+    type
+    indexed_type
+  }
+}