@iota/graphql-transport 0.0.0-dev-20251015065834

package/dist/esm/methods.js

@@ -0,0 +1,1406 @@
+import { fromBase64 } from "@iota/bcs";
+import { Transaction } from "@iota/iota-sdk/transactions";
+import { normalizeStructTag, normalizeIotaAddress, parseStructTag } from "@iota/iota-sdk/utils";
+import {
+  DevInspectTransactionBlockDocument,
+  DryRunTransactionBlockDocument,
+  ExecuteTransactionBlockDocument,
+  GetAllBalancesDocument,
+  GetBalanceDocument,
+  GetChainIdentifierDocument,
+  GetCheckpointDocument,
+  GetCheckpointsDocument,
+  GetCoinMetadataDocument,
+  GetCoinsDocument,
+  GetCommitteeInfoDocument,
+  GetCurrentEpochDocument,
+  GetDynamicFieldObjectDocument,
+  GetDynamicFieldsDocument,
+  GetLatestCheckpointSequenceNumberDocument,
+  GetLatestIotaSystemStateDocument,
+  GetMoveFunctionArgTypesDocument,
+  GetNormalizedMoveFunctionDocument,
+  GetNormalizedMoveModuleDocument,
+  GetNormalizedMoveModulesByPackageDocument,
+  GetNormalizedMoveStructDocument,
+  GetObjectDocument,
+  GetOwnedObjectsDocument,
+  GetProtocolConfigDocument,
+  GetReferenceGasPriceDocument,
+  GetStakesByIdsDocument,
+  GetStakesDocument,
+  GetTotalSupplyDocument,
+  GetTotalTransactionBlocksDocument,
+  GetTransactionBlockDocument,
+  GetTypeLayoutDocument,
+  GetValidatorsApyDocument,
+  IsTransactionIndexedOnNodeDocument,
+  MultiGetObjectsDocument,
+  MultiGetTransactionBlocksDocument,
+  PaginateCheckpointTransactionBlocksDocument,
+  PaginateEpochValidatorsDocument,
+  PaginateMoveModuleListsDocument,
+  PaginateTransactionBlockListsDocument,
+  QueryEventsDocument,
+  QueryTransactionBlocksDocument,
+  TransactionBlockKindInput,
+  TryGetPastObjectDocument
+} from "./generated/queries.js";
+import { mapJsonToBcs } from "./mappers/bcs.js";
+import { mapGraphQLCheckpointToRpcCheckpoint } from "./mappers/checkpoint.js";
+import {
+  mapNormalizedMoveFunction,
+  mapNormalizedMoveModule,
+  mapNormalizedMoveStruct,
+  moveDataToRpcContent
+} from "./mappers/move.js";
+import { mapGraphQLMoveObjectToRpcObject, mapGraphQLObjectToRpcObject } from "./mappers/object.js";
+import { mapGraphQLStakeToRpcStake } from "./mappers/stakes.js";
+import { mapGraphQLTransactionBlockToRpcTransactionBlock } from "./mappers/transaction-block.js";
+import { isNumericString, toShortTypeString } from "./mappers/util.js";
+import { mapGraphQlValidatorToRpcValidator } from "./mappers/validator.js";
+const RPC_METHODS = {
+  async getRpcApiVersion(transport) {
+    const res = await transport.graphqlRequest({
+      query: "query { __typename }",
+      variables: {}
+    });
+    if (!res.ok) {
+      throw new Error("Failed to fetch");
+    }
+    return {
+      info: {
+        version: res.headers.get("x-iota-rpc-version") ?? void 0
+      }
+    };
+  },
+  async getCoins(transport, [owner, coinType, cursor, limit]) {
+    const { nodes: coins, pageInfo } = await transport.graphqlQuery(
+      {
+        query: GetCoinsDocument,
+        variables: {
+          owner,
+          type: coinType,
+          cursor,
+          first: limit
+        }
+      },
+      (data) => data.address?.coins
+    );
+    return {
+      data: coins.map((coin) => ({
+        balance: coin.coinBalance,
+        coinObjectId: coin.address,
+        coinType: toShortTypeString(
+          normalizeStructTag(parseStructTag(coin.contents?.type.repr).typeParams[0])
+        ),
+        digest: coin.digest,
+        previousTransaction: coin.previousTransactionBlock?.digest,
+        version: String(coin.version)
+      })),
+      nextCursor: pageInfo.endCursor,
+      hasNextPage: pageInfo.hasNextPage
+    };
+  },
+  async getAllCoins(transport, inputs) {
+    const { nodes: coins, pageInfo } = await transport.graphqlQuery(
+      {
+        query: GetCoinsDocument,
+        variables: {
+          owner: inputs[0],
+          cursor: inputs[1],
+          first: inputs[2]
+        }
+      },
+      (data) => data.address?.coins
+    );
+    return {
+      data: coins.map((coin) => ({
+        balance: coin.coinBalance,
+        coinObjectId: coin.address,
+        coinType: toShortTypeString(
+          normalizeStructTag(parseStructTag(coin.contents?.type.repr).typeParams[0])
+        ),
+        digest: coin.digest,
+        previousTransaction: coin.previousTransactionBlock?.digest,
+        version: String(coin.version)
+      })),
+      nextCursor: pageInfo.endCursor,
+      hasNextPage: pageInfo.hasNextPage
+    };
+  },
+  async getBalance(transport, inputs) {
+    const balance = await transport.graphqlQuery(
+      {
+        query: GetBalanceDocument,
+        variables: {
+          owner: inputs[0],
+          type: inputs[1]
+        }
+      },
+      (data) => data.address?.balance
+    );
+    return {
+      coinType: toShortTypeString(balance.coinType?.repr),
+      coinObjectCount: balance.coinObjectCount,
+      totalBalance: balance.totalBalance
+    };
+  },
+  async getAllBalances(transport, inputs) {
+    const balances = await transport.graphqlQuery(
+      {
+        query: GetAllBalancesDocument,
+        variables: {
+          owner: inputs[0]
+        }
+      },
+      (data) => data.address?.balances?.nodes
+    );
+    return balances.map((balance) => ({
+      coinType: toShortTypeString(balance.coinType?.repr),
+      coinObjectCount: balance.coinObjectCount,
+      totalBalance: balance.totalBalance
+    }));
+  },
+  async getCoinMetadata(transport, inputs) {
+    const metadata = await transport.graphqlQuery(
+      {
+        query: GetCoinMetadataDocument,
+        variables: {
+          coinType: inputs[0]
+        }
+      },
+      (data) => data.coinMetadata
+    );
+    return {
+      decimals: metadata.decimals,
+      name: metadata.name,
+      symbol: metadata.symbol,
+      description: metadata.description,
+      iconUrl: metadata.iconUrl,
+      id: metadata.address
+    };
+  },
+  async getTotalSupply(transport, inputs) {
+    const metadata = await transport.graphqlQuery(
+      {
+        query: GetTotalSupplyDocument,
+        variables: {
+          coinType: inputs[0]
+        }
+      },
+      (data) => data.coinMetadata
+    );
+    return {
+      value: BigInt(metadata.supply).toString()
+    };
+  },
+  async getMoveFunctionArgTypes(transport, [pkg, module, fn]) {
+    const moveModule = await transport.graphqlQuery(
+      {
+        query: GetMoveFunctionArgTypesDocument,
+        variables: {
+          module,
+          packageId: pkg,
+          function: fn
+        }
+      },
+      (data) => data.object?.asMovePackage?.module?.function?.parameters
+    );
+    return moveModule.map((parameter) => {
+      if (!parameter.signature.body.datatype) {
+        return "Pure";
+      }
+      return {
+        Object: parameter.signature.ref === "&" ? "ByImmutableReference" : parameter.signature.ref === "&mut" ? "ByMutableReference" : "ByValue"
+      };
+    });
+  },
+  async getNormalizedMoveFunction(transport, [pkg, module, fn]) {
+    const moveFunction = await transport.graphqlQuery(
+      {
+        query: GetNormalizedMoveFunctionDocument,
+        variables: {
+          module,
+          packageId: pkg,
+          function: fn
+        }
+      },
+      (data) => data.object?.asMovePackage?.module?.function
+    );
+    return mapNormalizedMoveFunction(moveFunction);
+  },
+  async getNormalizedMoveModulesByPackage(transport, [pkg]) {
+    const movePackage = await transport.graphqlQuery(
+      {
+        query: GetNormalizedMoveModulesByPackageDocument,
+        variables: {
+          packageId: pkg
+        }
+      },
+      (data) => data.object?.asMovePackage
+    );
+    let hasNextPage = movePackage.modules?.pageInfo.hasNextPage ?? false;
+    let cursor = movePackage.modules?.pageInfo.endCursor;
+    while (hasNextPage) {
+      const page = await transport.graphqlQuery(
+        {
+          query: GetNormalizedMoveModulesByPackageDocument,
+          variables: {
+            packageId: pkg,
+            cursor
+          }
+        },
+        (data) => data.object?.asMovePackage
+      );
+      movePackage.modules?.nodes.push(...page.modules?.nodes ?? []);
+      hasNextPage = page.modules?.pageInfo.hasNextPage ?? false;
+      cursor = page.modules?.pageInfo.endCursor;
+    }
+    const address = toShortTypeString(movePackage.address);
+    const modules = {};
+    for (const moveModule of movePackage.modules?.nodes ?? []) {
+      let hasMoreFriends = moveModule.friends?.pageInfo.hasNextPage ?? false;
+      let hasMoreFunctions = moveModule.functions?.pageInfo.hasNextPage ?? false;
+      let hasMoreStructs = moveModule.structs?.pageInfo.hasNextPage ?? false;
+      let afterFriends = moveModule.friends?.pageInfo.endCursor;
+      let afterFunctions = moveModule.functions?.pageInfo.endCursor;
+      let afterStructs = moveModule.structs?.pageInfo.endCursor;
+      while (hasMoreFriends || hasMoreStructs || hasMoreFunctions) {
+        const page = await transport.graphqlQuery(
+          {
+            query: PaginateMoveModuleListsDocument,
+            variables: {
+              module: moveModule.name,
+              packageId: pkg,
+              hasMoreFriends,
+              hasMoreFunctions,
+              hasMoreStructs,
+              afterFriends,
+              afterFunctions,
+              afterStructs
+            }
+          },
+          (data) => data.object?.asMovePackage?.module
+        );
+        moveModule.friends.nodes.push(...page.friends?.nodes ?? []);
+        moveModule.functions?.nodes.push(...page.functions?.nodes ?? []);
+        moveModule.structs?.nodes.push(...page.structs?.nodes ?? []);
+        hasMoreFriends = page.friends?.pageInfo.hasNextPage ?? false;
+        hasMoreFunctions = page.functions?.pageInfo.hasNextPage ?? false;
+        hasMoreStructs = page.structs?.pageInfo.hasNextPage ?? false;
+        afterFriends = page.friends?.pageInfo.endCursor;
+        afterFunctions = page.functions?.pageInfo.endCursor;
+        afterStructs = page.structs?.pageInfo.endCursor;
+      }
+    }
+    movePackage.modules?.nodes.forEach((module) => {
+      modules[module.name] = mapNormalizedMoveModule(module, address);
+    });
+    return modules;
+  },
+  async getNormalizedMoveModule(transport, [pkg, module]) {
+    const moveModule = await transport.graphqlQuery(
+      {
+        query: GetNormalizedMoveModuleDocument,
+        variables: {
+          module,
+          packageId: pkg
+        }
+      },
+      (data) => data.object?.asMovePackage?.module
+    );
+    let hasMoreFriends = moveModule.friends?.pageInfo.hasNextPage ?? false;
+    let hasMoreFunctions = moveModule.functions?.pageInfo.hasNextPage ?? false;
+    let hasMoreStructs = moveModule.structs?.pageInfo.hasNextPage ?? false;
+    let afterFriends = moveModule.friends?.pageInfo.endCursor;
+    let afterFunctions = moveModule.functions?.pageInfo.endCursor;
+    let afterStructs = moveModule.structs?.pageInfo.endCursor;
+    while (hasMoreFriends || hasMoreStructs || hasMoreFunctions) {
+      const page = await transport.graphqlQuery(
+        {
+          query: PaginateMoveModuleListsDocument,
+          variables: {
+            module,
+            packageId: pkg,
+            hasMoreFriends,
+            hasMoreFunctions,
+            hasMoreStructs,
+            afterFriends,
+            afterFunctions,
+            afterStructs
+          }
+        },
+        (data) => data.object?.asMovePackage?.module
+      );
+      moveModule.friends.nodes.push(...page.friends?.nodes ?? []);
+      moveModule.functions?.nodes.push(...page.functions?.nodes ?? []);
+      moveModule.structs?.nodes.push(...page.structs?.nodes ?? []);
+      hasMoreFriends = page.friends?.pageInfo.hasNextPage ?? false;
+      hasMoreFunctions = page.functions?.pageInfo.hasNextPage ?? false;
+      hasMoreStructs = page.structs?.pageInfo.hasNextPage ?? false;
+      afterFriends = page.friends?.pageInfo.endCursor;
+      afterFunctions = page.functions?.pageInfo.endCursor;
+      afterStructs = page.structs?.pageInfo.endCursor;
+    }
+    return mapNormalizedMoveModule(moveModule, normalizeIotaAddress(pkg));
+  },
+  async getNormalizedMoveStruct(transport, [pkg, module, struct]) {
+    const moveStruct = await transport.graphqlQuery(
+      {
+        query: GetNormalizedMoveStructDocument,
+        variables: {
+          packageId: pkg,
+          module,
+          struct
+        }
+      },
+      (data) => data.object?.asMovePackage?.module?.struct
+    );
+    return mapNormalizedMoveStruct(moveStruct);
+  },
+  async getOwnedObjects(transport, [owner, { filter: inputFilter, options }, cursor, limit]) {
+    let filter;
+    let typeFilter;
+    if (inputFilter) {
+      if ("Package" in inputFilter) {
+        typeFilter = inputFilter.Package;
+      } else if ("MoveModule" in inputFilter) {
+        typeFilter = `${inputFilter.MoveModule.package}::${inputFilter.MoveModule.module}`;
+      } else if ("StructType" in inputFilter) {
+        typeFilter = inputFilter.StructType;
+      }
+      filter = {
+        objectIds: "ObjectIds" in inputFilter ? inputFilter.ObjectIds : "ObjectId" in inputFilter ? [inputFilter.ObjectId] : void 0,
+        type: typeFilter,
+        owner: "ObjectOwner" in inputFilter ? inputFilter.ObjectOwner : "AddressOwner" in inputFilter ? inputFilter.AddressOwner : void 0
+      };
+      const unsupportedFilters = [];
+      for (const unsupportedFilter of unsupportedFilters) {
+        if (unsupportedFilter in inputFilter) {
+          throw new UnsupportedParamError("getOwnedObjects", unsupportedFilter);
+        }
+      }
+    }
+    const { nodes: objects, pageInfo } = await transport.graphqlQuery(
+      {
+        query: GetOwnedObjectsDocument,
+        variables: {
+          owner,
+          limit,
+          cursor,
+          showBcs: options?.showBcs,
+          showContent: options?.showContent,
+          showDisplay: options?.showDisplay,
+          showOwner: options?.showOwner,
+          showPreviousTransaction: options?.showPreviousTransaction,
+          showStorageRebate: options?.showStorageRebate,
+          showType: options?.showType,
+          filter
+        }
+      },
+      (data) => data.address?.objects
+    );
+    return {
+      hasNextPage: pageInfo.hasNextPage,
+      nextCursor: pageInfo.endCursor,
+      data: objects.map((object) => ({
+        data: mapGraphQLMoveObjectToRpcObject(object, options ?? {})
+      }))
+    };
+  },
+  async getObject(transport, [id, options]) {
+    const object = await transport.graphqlQuery(
+      {
+        query: GetObjectDocument,
+        variables: {
+          id,
+          showBcs: options?.showBcs,
+          showContent: options?.showContent,
+          showDisplay: options?.showDisplay,
+          showOwner: options?.showOwner,
+          showPreviousTransaction: options?.showPreviousTransaction,
+          showStorageRebate: options?.showStorageRebate,
+          showType: options?.showType
+        }
+      },
+      (data) => data.object
+    );
+    return {
+      data: mapGraphQLObjectToRpcObject(object, options ?? {})
+    };
+  },
+  async tryGetPastObject(transport, [id, version, options]) {
+    const data = await transport.graphqlQuery({
+      query: TryGetPastObjectDocument,
+      variables: {
+        id,
+        version,
+        showBcs: options?.showBcs,
+        showContent: options?.showContent,
+        showDisplay: options?.showDisplay,
+        showOwner: options?.showOwner,
+        showPreviousTransaction: options?.showPreviousTransaction,
+        showStorageRebate: options?.showStorageRebate,
+        showType: options?.showType
+      }
+    });
+    if (!data.current) {
+      return {
+        details: "Could not find the referenced object",
+        status: "ObjectNotExists"
+      };
+    }
+    if (!data.object) {
+      return data.current.version < Number(version) ? {
+        status: "VersionTooHigh",
+        details: {
+          asked_version: String(version),
+          latest_version: String(data.current.version),
+          object_id: data.current.address
+        }
+      } : {
+        status: "VersionNotFound",
+        details: [data.current.address, String(version)]
+      };
+    }
+    return {
+      status: "VersionFound",
+      details: mapGraphQLObjectToRpcObject(data.object, options ?? {})
+    };
+  },
+  async multiGetObjects(transport, [ids, options]) {
+    const objects = await transport.graphqlQuery(
+      {
+        query: MultiGetObjectsDocument,
+        variables: {
+          ids,
+          showBcs: options?.showBcs,
+          showContent: options?.showContent,
+          showDisplay: options?.showDisplay,
+          showOwner: options?.showOwner,
+          showPreviousTransaction: options?.showPreviousTransaction,
+          showStorageRebate: options?.showStorageRebate,
+          showType: options?.showType,
+          limit: ids.length
+        }
+      },
+      (data) => data.objects?.nodes
+    );
+    return objects.map((object) => ({
+      data: mapGraphQLObjectToRpcObject(object, options ?? {})
+    }));
+  },
+  async queryTransactionBlocks(transport, [{ filter, options }, cursor, limit = 20, descending]) {
+    const pagination = descending ? {
+      last: limit,
+      before: cursor
+    } : {
+      first: limit,
+      after: cursor
+    };
+    const unsupportedFilters = ["FromOrToAddress", "FromAndToAddress", "TransactionKindIn"];
+    if (filter) {
+      for (const unsupportedFilter of unsupportedFilters) {
+        if (unsupportedFilter in filter) {
+          throw new UnsupportedParamError("queryTransactionBlocks", unsupportedFilter);
+        }
+      }
+    }
+    let graphqlTransactionKindFilter;
+    if ("TransactionKind" in filter) {
+      switch (filter.TransactionKind) {
+        case "ProgrammableTransaction":
+          graphqlTransactionKindFilter = TransactionBlockKindInput.ProgrammableTx;
+          break;
+        case "Genesis":
+          graphqlTransactionKindFilter = TransactionBlockKindInput.Genesis;
+          break;
+        case "ConsensusCommitPrologueV1":
+          graphqlTransactionKindFilter = TransactionBlockKindInput.ConsensusCommitPrologueV1;
+          break;
+        case "AuthenticatorStateUpdateV1":
+          graphqlTransactionKindFilter = TransactionBlockKindInput.AuthenticatorStateUpdateV1;
+          break;
+        case "RandomnessStateUpdate":
+          graphqlTransactionKindFilter = TransactionBlockKindInput.RandomnessStateUpdate;
+          break;
+        case "EndOfEpochTransaction":
+          graphqlTransactionKindFilter = TransactionBlockKindInput.EndOfEpochTx;
+          break;
+        case "SystemTransaction":
+          graphqlTransactionKindFilter = TransactionBlockKindInput.SystemTx;
+          break;
+      }
+    }
+    const { nodes: transactionBlocks, pageInfo } = await transport.graphqlQuery(
+      {
+        query: QueryTransactionBlocksDocument,
+        variables: {
+          ...pagination,
+          showBalanceChanges: options?.showBalanceChanges,
+          showEffects: options?.showEffects,
+          showEvents: options?.showEvents,
+          showInput: options?.showInput,
+          showObjectChanges: options?.showObjectChanges,
+          showRawEffects: options?.showRawEffects,
+          showRawInput: options?.showRawInput,
+          filter: filter ? {
+            atCheckpoint: "Checkpoint" in filter ? Number.parseInt(filter.Checkpoint) : void 0,
+            function: "MoveFunction" in filter ? `${filter.MoveFunction.package}::${filter.MoveFunction.module}::${filter.MoveFunction.function}` : void 0,
+            inputObject: "InputObject" in filter ? filter.InputObject : void 0,
+            changedObject: "ChangedObject" in filter ? filter.ChangedObject : void 0,
+            signAddress: "FromAddress" in filter ? filter.FromAddress : void 0,
+            recvAddress: "ToAddress" in filter ? filter.ToAddress : void 0,
+            kind: graphqlTransactionKindFilter
+          } : {}
+        }
+      },
+      (data) => data.transactionBlocks
+    );
+    for (const transactionBlock of transactionBlocks) {
+      await paginateTransactionBlockLists(transport, transactionBlock);
+    }
+    if (pagination.last) {
+      transactionBlocks.reverse();
+    }
+    return {
+      hasNextPage: pagination.last ? pageInfo.hasPreviousPage : pageInfo.hasNextPage,
+      nextCursor: pagination.last ? pageInfo.startCursor : pageInfo.endCursor,
+      data: transactionBlocks.map(
+        (transactionBlock) => mapGraphQLTransactionBlockToRpcTransactionBlock(transactionBlock, options ?? {})
+      )
+    };
+  },
+  async getTransactionBlock(transport, [digest, options]) {
+    const transactionBlock = await transport.graphqlQuery(
+      {
+        query: GetTransactionBlockDocument,
+        variables: {
+          digest,
+          showBalanceChanges: options?.showBalanceChanges,
+          showEffects: options?.showEffects,
+          showEvents: options?.showEvents,
+          showInput: options?.showInput,
+          showObjectChanges: options?.showObjectChanges,
+          showRawEffects: options?.showRawEffects,
+          showRawInput: options?.showRawInput
+        }
+      },
+      (data) => data.transactionBlock
+    );
+    await paginateTransactionBlockLists(transport, transactionBlock);
+    return mapGraphQLTransactionBlockToRpcTransactionBlock(transactionBlock, options);
+  },
+  async multiGetTransactionBlocks(transport, [digests, options]) {
+    const transactionBlocks = await transport.graphqlQuery(
+      {
+        query: MultiGetTransactionBlocksDocument,
+        variables: {
+          digests,
+          showBalanceChanges: options?.showBalanceChanges,
+          showEffects: options?.showEffects,
+          showEvents: options?.showEvents,
+          showInput: options?.showInput,
+          showObjectChanges: options?.showObjectChanges,
+          showRawEffects: options?.showEffects,
+          showRawInput: options?.showRawInput,
+          limit: digests.length
+        }
+      },
+      (data) => data.transactionBlocks?.nodes
+    );
+    for (const transactionBlock of transactionBlocks) {
+      await paginateTransactionBlockLists(transport, transactionBlock);
+    }
+    return transactionBlocks.map(
+      (transactionBlock) => mapGraphQLTransactionBlockToRpcTransactionBlock(transactionBlock, options)
+    );
+  },
+  async getTotalTransactionBlocks(transport) {
+    return transport.graphqlQuery(
+      {
+        query: GetTotalTransactionBlocksDocument
+      },
+      (data) => BigInt(data.checkpoint?.networkTotalTransactions)
+    );
+  },
+  async getReferenceGasPrice(transport) {
+    const epoch = await transport.graphqlQuery(
+      {
+        query: GetReferenceGasPriceDocument,
+        variables: {}
+      },
+      (data) => data.epoch
+    );
+    return BigInt(epoch.referenceGasPrice);
+  },
+  async getStakes(transport, [owner]) {
+    const stakes = await transport.graphqlQuery(
+      {
+        query: GetStakesDocument,
+        variables: {
+          owner
+        }
+      },
+      (data) => data.address?.stakedIotas?.nodes
+    );
+    return mapGraphQLStakeToRpcStake(stakes);
+  },
+  async getStakesByIds(transport, [stakedIotaIds]) {
+    const stakes = await transport.graphqlQuery(
+      {
+        query: GetStakesByIdsDocument,
+        variables: {
+          ids: stakedIotaIds
+        }
+      },
+      (data) => data.objects?.nodes.map((node) => node?.asMoveObject?.asStakedIota).filter(Boolean)
+    );
+    return mapGraphQLStakeToRpcStake(stakes);
+  },
+  async getLatestIotaSystemStateV2(transport) {
+    const systemState = await transport.graphqlQuery(
+      {
+        query: GetLatestIotaSystemStateDocument
+      },
+      (data) => data.epoch
+    );
+    let hasMoreActiveValidators = systemState.validatorSet?.activeValidators?.pageInfo.hasNextPage ?? false;
+    let afterActiveValidators = systemState.validatorSet?.activeValidators?.pageInfo.endCursor;
+    while (hasMoreActiveValidators) {
+      const page = await transport.graphqlQuery(
+        {
+          query: PaginateEpochValidatorsDocument,
+          variables: {
+            id: systemState.epochId,
+            after: afterActiveValidators
+          }
+        },
+        (data) => data.epoch
+      );
+      systemState.validatorSet?.activeValidators?.nodes.push(
+        ...page.validatorSet?.activeValidators?.nodes ?? []
+      );
+      hasMoreActiveValidators = page.validatorSet?.activeValidators?.pageInfo.hasNextPage ?? false;
+      afterActiveValidators = page.validatorSet?.activeValidators?.pageInfo.endCursor;
+    }
+    let hasMoreCommitteeMembers = systemState.validatorSet?.committeeMembers?.pageInfo.hasNextPage ?? false;
+    let afterCommitteeMembers = systemState.validatorSet?.committeeMembers?.pageInfo.endCursor;
+    while (hasMoreCommitteeMembers) {
+      const page = await transport.graphqlQuery(
+        {
+          query: PaginateEpochValidatorsDocument,
+          variables: {
+            id: systemState.epochId,
+            after: afterCommitteeMembers
+          }
+        },
+        (data) => data.epoch
+      );
+      systemState.validatorSet?.committeeMembers?.nodes.push(
+        ...page.validatorSet?.committeeMembers?.nodes ?? []
+      );
+      hasMoreCommitteeMembers = page.validatorSet?.committeeMembers?.pageInfo.hasNextPage ?? false;
+      afterCommitteeMembers = page.validatorSet?.committeeMembers?.pageInfo.endCursor;
+    }
+    return {
+      V2: {
+        activeValidators: systemState.validatorSet?.activeValidators?.nodes.map(
+          mapGraphQlValidatorToRpcValidator
+        ),
+        committeeMembers: systemState.validatorSet?.committeeMembers?.nodes?.map(
+          (_, index) => index.toString()
+        ),
+        atRiskValidators: systemState.validatorSet?.activeValidators.nodes?.filter((validator) => validator.atRisk).map((validator) => [
+          validator.address.address,
+          validator.atRisk.toString()
+        ]),
+        epoch: String(systemState.epochId),
+        epochDurationMs: String(
+          new Date(systemState.endTimestamp).getTime() - new Date(systemState.startTimestamp).getTime()
+        ),
+        epochStartTimestampMs: String(new Date(systemState.startTimestamp).getTime()),
+        inactivePoolsSize: String(systemState.validatorSet?.inactivePoolsSize),
+        iotaTotalSupply: String(systemState.iotaTotalSupply),
+        iotaTreasuryCapId: String(systemState.iotaTreasuryCapId),
+        maxValidatorCount: String(systemState.systemParameters?.maxValidatorCount),
+        minValidatorCount: String(systemState.systemParameters?.minValidatorCount),
+        minValidatorJoiningStake: String(
+          systemState.systemParameters?.minValidatorJoiningStake
+        ),
+        pendingActiveValidatorsSize: String(
+          systemState.validatorSet?.pendingActiveValidatorsSize
+        ),
+        pendingRemovals: systemState.validatorSet?.pendingRemovals?.map((idx) => String(idx)) ?? [],
+        protocolVersion: String(systemState.protocolConfigs?.protocolVersion),
+        referenceGasPrice: String(systemState.referenceGasPrice),
+        safeMode: systemState.safeMode?.enabled,
+        safeModeComputationCharges: String(
+          systemState.safeMode?.gasSummary?.computationCost
+        ),
+        safeModeComputationChargesBurned: String(
+          systemState.safeMode?.gasSummary?.computationCostBurned
+        ),
+        safeModeNonRefundableStorageFee: String(
+          systemState.safeMode?.gasSummary?.nonRefundableStorageFee
+        ),
+        safeModeStorageRebates: String(systemState.safeMode?.gasSummary?.storageRebate),
+        safeModeStorageCharges: String(systemState.safeMode?.gasSummary?.storageCost),
+        stakingPoolMappingsSize: String(systemState.validatorSet?.stakingPoolMappingsSize),
+        storageFundNonRefundableBalance: String(
+          systemState.storageFund?.nonRefundableBalance
+        ),
+        storageFundTotalObjectStorageRebates: String(
+          systemState.storageFund?.totalObjectStorageRebates
+        ),
+        systemStateVersion: String(systemState.systemStateVersion),
+        totalStake: systemState.validatorSet?.totalStake,
+        validatorCandidatesSize: systemState.validatorSet?.validatorCandidatesSize?.toString(),
+        validatorLowStakeGracePeriod: systemState.systemParameters?.validatorLowStakeGracePeriod,
+        validatorLowStakeThreshold: systemState.systemParameters?.validatorLowStakeThreshold,
+        validatorReportRecords: [],
+        // TODO
+        validatorVeryLowStakeThreshold: systemState.systemParameters?.validatorVeryLowStakeThreshold,
+        validatorCandidatesId: systemState.validatorSet?.validatorCandidatesId,
+        inactivePoolsId: systemState.validatorSet?.inactivePoolsId,
+        pendingActiveValidatorsId: systemState.validatorSet?.pendingActiveValidatorsId,
+        stakingPoolMappingsId: systemState.validatorSet?.stakingPoolMappingsId
+      }
+    };
+  },
+  async queryEvents(transport, [query, cursor, limit, descending]) {
+    const pagination = descending ? { last: limit, before: cursor } : { first: limit, after: cursor };
+    const filter = {
+      sender: "Sender" in query ? query.Sender : void 0,
+      transactionDigest: "Transaction" in query ? query.Transaction : void 0,
+      eventType: "MoveEventType" in query ? query.MoveEventType : void 0,
+      emittingModule: "MoveModule" in query ? `${query.MoveModule.package}::${query.MoveModule.module}` : void 0
+    };
+    if ("MoveEventType" in query) {
+      filter.eventType = query.MoveEventType;
+    } else if ("MoveEventModule" in query) {
+      filter.eventType = `${query.MoveEventModule.package}::${query.MoveEventModule.module}`;
+    }
+    const unsupportedFilters = [
+      "Package",
+      "MoveEventField",
+      "Any",
+      "All",
+      "And",
+      "Or",
+      "TimeRange"
+    ];
+    if (query) {
+      for (const unsupportedFilter of unsupportedFilters) {
+        if (unsupportedFilter in query) {
+          throw new UnsupportedParamError("queryEvents", unsupportedFilter);
+        }
+      }
+    }
+    const { nodes: events, pageInfo } = await transport.graphqlQuery(
+      {
+        query: QueryEventsDocument,
+        variables: {
+          ...pagination,
+          filter
+        }
+      },
+      (data) => data.events
+    );
+    if (pagination.last) {
+      events.reverse();
+    }
+    return {
+      hasNextPage: pagination.last ? pageInfo.hasPreviousPage : pageInfo.hasNextPage,
+      nextCursor: pagination.last ? pageInfo.startCursor : pageInfo.endCursor,
+      data: events.map((event) => ({
+        bcs: event.bcs,
+        bcsEncoding: "base64",
+        id: {
+          eventSeq: "",
+          // TODO
+          txDigest: ""
+          // TODO
+        },
+        packageId: event.sendingModule?.package.address,
+        parsedJson: event.json,
+        sender: event.sender?.address,
+        timestampMs: new Date(event.timestamp).getTime().toString(),
+        transactionModule: `${event.sendingModule?.package.address}::${event.sendingModule?.name}`,
+        type: toShortTypeString(event.type?.repr)
+      }))
+    };
+  },
+  async devInspectTransactionBlock(transport, [sender, devInspectTxBytes, gasPrice]) {
+    const { transaction, error, results } = await transport.graphqlQuery(
+      {
+        query: DevInspectTransactionBlockDocument,
+        variables: {
+          txBytes: devInspectTxBytes,
+          txMeta: {
+            gasPrice: Number.parseInt(gasPrice),
+            sender
+          },
+          showEffects: true,
+          showEvents: true
+        }
+      },
+      (data) => data.dryRunTransactionBlock
+    );
+    if (!transaction) {
+      throw new Error("Unexpected error during dry run");
+    }
+    const result = mapGraphQLTransactionBlockToRpcTransactionBlock(transaction, {
+      showEffects: true,
+      showEvents: true
+    });
+    return {
+      error,
+      effects: result.effects,
+      events: result.events,
+      results: results?.map((result2) => ({
+        mutableReferenceOutputs: result2.mutatedReferences?.map(
+          (ref) => [
+            ref.input.__typename === "GasCoin" ? "GasCoin" : ref.input.__typename === "Input" ? {
+              Input: ref.input.inputIndex
+            } : typeof ref.input.resultIndex === "number" ? {
+              NestedResult: [ref.input.cmd, ref.input.resultIndex]
+            } : {
+              Result: ref.input.cmd
+            },
+            Array.from(fromBase64(ref.bcs)),
+            toShortTypeString(ref.type.repr)
+          ]
+        ),
+        returnValues: result2.returnValues?.map((value) => [
+          Array.from(fromBase64(value.bcs)),
+          toShortTypeString(value.type.repr)
+        ])
+      }))
+    };
+  },
+  async getDynamicFields(transport, [parentId, cursor, limit]) {
+    const { nodes: fields, pageInfo } = await transport.graphqlQuery(
+      {
+        query: GetDynamicFieldsDocument,
+        variables: {
+          parentId,
+          first: limit,
+          cursor
+        }
+      },
+      (data) => data.owner?.dynamicFields
+    );
+    return {
+      data: fields.map((field) => ({
+        bcsName: field.name?.bcs,
+        bcsEncoding: "base64",
+        digest: field.value?.__typename === "MoveObject" ? field.value.digest : void 0,
+        name: {
+          type: toShortTypeString(field.name?.type.repr),
+          value: field.name?.json
+        },
+        objectId: field.value?.__typename === "MoveObject" ? field.value.address : void 0,
+        objectType: field.value?.__typename === "MoveObject" ? field.value.contents?.type.repr : field.value?.type.repr,
+        type: field.value?.__typename === "MoveObject" ? "DynamicObject" : "DynamicField",
+        version: field.value?.__typename === "MoveObject" ? field.value.version : void 0
+      })),
+      nextCursor: pageInfo.endCursor ?? null,
+      hasNextPage: pageInfo.hasNextPage
+    };
+  },
+  async getDynamicFieldObjectV2(transport, inputs) {
+    return await getDynamicFieldObject(transport, inputs);
+  },
+  /**
+   * @deprecated The V1 of this method is deprecated, use `getDynamicFieldObjectV2` instead.
+   */
+  async getDynamicFieldObject(transport, [parentId, name]) {
+    return await getDynamicFieldObject(transport, [
+      parentId,
+      name,
+      {
+        // These are the same defaults as in the JSON RPC.
+        showBcs: true,
+        showContent: true,
+        showDisplay: true,
+        showOwner: true,
+        showPreviousTransaction: true,
+        showStorageRebate: true,
+        showType: true
+      }
+    ]);
+  },
+  async executeTransactionBlock(transport, [txBytes, signatures, options]) {
+    const { effects, errors } = await transport.graphqlQuery(
+      {
+        query: ExecuteTransactionBlockDocument,
+        variables: {
+          txBytes,
+          signatures,
+          showBalanceChanges: options?.showBalanceChanges,
+          showEffects: options?.showEffects,
+          showEvents: options?.showEvents,
+          showInput: options?.showInput,
+          showObjectChanges: options?.showObjectChanges,
+          showRawEffects: options?.showRawEffects,
+          showRawInput: options?.showRawInput
+        }
+      },
+      (data) => data.executeTransactionBlock
+    );
+    if (!effects?.transactionBlock) {
+      const tx = Transaction.from(fromBase64(txBytes));
+      return { errors: errors ?? void 0, digest: await tx.getDigest() };
+    }
+    await paginateTransactionBlockLists(transport, effects.transactionBlock);
+    return mapGraphQLTransactionBlockToRpcTransactionBlock(
+      effects.transactionBlock,
+      options,
+      errors
+    );
+  },
+  async dryRunTransactionBlock(transport, [txBytes]) {
+    const tx = Transaction.from(fromBase64(txBytes));
+    const { transaction, error } = await transport.graphqlQuery(
+      {
+        query: DryRunTransactionBlockDocument,
+        variables: {
+          txBytes,
+          showBalanceChanges: true,
+          showEffects: true,
+          showEvents: true,
+          showInput: true,
+          showObjectChanges: true
+        }
+      },
+      (data) => data.dryRunTransactionBlock
+    );
+    if (error || !transaction) {
+      throw new Error(error ?? "Unexpected error during dry run");
+    }
+    const result = mapGraphQLTransactionBlockToRpcTransactionBlock(
+      { ...transaction, digest: await tx.getDigest() },
+      {
+        showBalanceChanges: true,
+        showEffects: true,
+        showEvents: true,
+        showInput: true,
+        showObjectChanges: true
+      }
+    );
+    return {
+      input: result.transaction?.data,
+      balanceChanges: result.balanceChanges,
+      effects: result.effects,
+      events: result.events,
+      objectChanges: result.objectChanges
+    };
+  },
+  async getLatestCheckpointSequenceNumber(transport) {
+    const sequenceNumber = await transport.graphqlQuery(
+      {
+        query: GetLatestCheckpointSequenceNumberDocument
+      },
+      (data) => data.checkpoint?.sequenceNumber
+    );
+    return sequenceNumber.toString();
+  },
+  async getCheckpoint(transport, [id]) {
+    const checkpoint = await transport.graphqlQuery(
+      {
+        query: GetCheckpointDocument,
+        variables: {
+          id: typeof id === "number" || isNumericString(id) ? {
+            sequenceNumber: Number.parseInt(id.toString(), 10)
+          } : {
+            digest: id
+          }
+        }
+      },
+      (data) => data.checkpoint
+    );
+    await paginateCheckpointLists(transport, checkpoint);
+    return mapGraphQLCheckpointToRpcCheckpoint(checkpoint);
+  },
+  async getCheckpoints(transport, [cursor, limit, descendingOrder]) {
+    const pagination = descendingOrder ? { last: limit, before: cursor } : { first: limit, after: cursor };
+    const { nodes: checkpoints, pageInfo } = await transport.graphqlQuery(
+      {
+        query: GetCheckpointsDocument,
+        variables: {
+          ...pagination
+        }
+      },
+      (data) => data.checkpoints
+    );
+    for (const checkpoint of checkpoints) {
+      await paginateCheckpointLists(transport, checkpoint);
+    }
+    if (pagination.last) {
+      checkpoints.reverse();
+    }
+    return {
+      hasNextPage: pagination.last ? pageInfo.hasPreviousPage : pageInfo.hasNextPage,
+      nextCursor: pagination.last ? pageInfo.startCursor : pageInfo.endCursor,
+      data: checkpoints.map((checkpoint) => mapGraphQLCheckpointToRpcCheckpoint(checkpoint))
+    };
+  },
+  async getCommitteeInfo(transport, [epoch]) {
+    const { validatorSet, epochId } = await transport.graphqlQuery(
+      {
+        query: GetCommitteeInfoDocument,
+        variables: {
+          epochId: epoch ? Number.parseInt(epoch) : void 0
+        }
+      },
+      (data) => data.epoch
+    );
+    let hasNextPage = validatorSet?.committeeMembers?.pageInfo.hasNextPage;
+    let after = validatorSet?.committeeMembers?.pageInfo.endCursor;
+    while (hasNextPage) {
+      const page = await transport.graphqlQuery(
+        {
+          query: GetCommitteeInfoDocument,
+          variables: {
+            epochId: epoch ? Number.parseInt(epoch) : void 0,
+            after
+          }
+        },
+        (data) => data.epoch?.validatorSet?.committeeMembers
+      );
+      validatorSet?.committeeMembers.nodes.push(...page.nodes);
+      hasNextPage = page.pageInfo.hasNextPage;
+      after = page.pageInfo.endCursor;
+    }
+    return {
+      epoch: epochId.toString(),
+      validators: validatorSet?.committeeMembers?.nodes.map((val) => [
+        val.credentials?.authorityPubKey,
+        String(val.votingPower)
+      ])
+    };
+  },
+  async getCurrentEpoch(transport) {
+    const epoch = await transport.graphqlQuery(
+      {
+        query: GetCurrentEpochDocument
+      },
+      (data) => data.epoch
+    );
+    let hasNextPageActiveValidators = epoch.validatorSet?.activeValidators?.pageInfo.hasNextPage;
+    let afterActiveValidators = epoch.validatorSet?.activeValidators?.pageInfo.endCursor;
+    while (hasNextPageActiveValidators) {
+      const page = await transport.graphqlQuery(
+        {
+          query: PaginateEpochValidatorsDocument,
+          variables: {
+            id: epoch.epochId,
+            after: afterActiveValidators
+          }
+        },
+        (data) => data.epoch?.validatorSet?.activeValidators
+      );
+      epoch.validatorSet?.activeValidators?.nodes.push(...page.nodes);
+      hasNextPageActiveValidators = page.pageInfo.hasNextPage;
+      afterActiveValidators = page.pageInfo.endCursor;
+    }
+    let hasNextPageCommitteeMembers = epoch.validatorSet?.committeeMembers?.pageInfo.hasNextPage;
+    let afterCommitteeMembers = epoch.validatorSet?.committeeMembers?.pageInfo.endCursor;
+    while (hasNextPageCommitteeMembers) {
+      const page = await transport.graphqlQuery(
+        {
+          query: PaginateEpochValidatorsDocument,
+          variables: {
+            id: epoch.epochId,
+            after: afterCommitteeMembers
+          }
+        },
+        (data) => data.epoch?.validatorSet?.committeeMembers
+      );
+      epoch.validatorSet?.committeeMembers?.nodes.push(...page.nodes);
+      hasNextPageCommitteeMembers = page.pageInfo.hasNextPage;
+      afterCommitteeMembers = page.pageInfo.endCursor;
+    }
+    const validatorsAddresses = epoch.validatorSet?.activeValidators?.nodes.map((val) => val.address.address) ?? [];
+    const committeeMembersAddresses = epoch.validatorSet?.committeeMembers?.nodes.map((val) => val.address.address) ?? [];
+    const committeeValidatorsIndexes = committeeMembersAddresses.map(
+      (val) => validatorsAddresses.indexOf(val)?.toString()
+    );
+    return {
+      epoch: String(epoch.epochId),
+      validators: epoch.validatorSet?.activeValidators?.nodes.map(
+        mapGraphQlValidatorToRpcValidator
+      ),
+      committeeMembers: committeeValidatorsIndexes,
+      epochTotalTransactions: "0",
+      // TODO
+      firstCheckpointId: epoch.firstCheckpoint?.nodes[0]?.sequenceNumber.toString(),
+      endOfEpochInfo: null,
+      referenceGasPrice: epoch.referenceGasPrice,
+      epochStartTimestamp: new Date(epoch.startTimestamp).getTime().toString()
+    };
+  },
+  async getValidatorsApy(transport) {
+    const epoch = await transport.graphqlQuery(
+      {
+        query: GetValidatorsApyDocument
+      },
+      (data) => data.epoch
+    );
+    let hasNextPage = epoch.validatorSet?.activeValidators?.pageInfo.hasNextPage;
+    let after = epoch.validatorSet?.activeValidators?.pageInfo.endCursor;
+    while (hasNextPage) {
+      const page = await transport.graphqlQuery(
+        {
+          query: PaginateEpochValidatorsDocument,
+          variables: {
+            id: epoch.epochId,
+            after
+          }
+        },
+        (data) => data.epoch
+      );
+      epoch.validatorSet?.activeValidators?.nodes.push(
+        ...page.validatorSet?.activeValidators?.nodes ?? []
+      );
+      hasNextPage = page.validatorSet?.activeValidators?.pageInfo.hasNextPage;
+      after = page.validatorSet?.activeValidators?.pageInfo.endCursor;
+    }
+    return {
+      epoch: String(epoch.epochId),
+      apys: epoch.validatorSet?.activeValidators?.nodes.map((validator) => ({
+        address: validator.address.address,
+        apy: typeof validator.apy === "number" ? validator.apy / 100 : null
+      }))
+    };
+  },
+  async getChainIdentifier(transport) {
+    const identifier = await transport.graphqlQuery(
+      {
+        query: GetChainIdentifierDocument
+      },
+      (data) => data.chainIdentifier
+    );
+    return identifier;
+  },
+  async getProtocolConfig(transport, [version]) {
+    const protocolConfig = await transport.graphqlQuery(
+      {
+        query: GetProtocolConfigDocument,
+        variables: {
+          protocolVersion: version ? Number.parseInt(version) : void 0
+        }
+      },
+      (data) => data.protocolConfig
+    );
+    const featureFlags = {};
+    const attributes = {};
+    const configTypeMap = {
+      max_arguments: "u32",
+      max_gas_payment_objects: "u32",
+      max_modules_in_publish: "u32",
+      max_programmable_tx_commands: "u32",
+      max_pure_argument_size: "u32",
+      max_type_argument_depth: "u32",
+      max_type_arguments: "u32",
+      move_binary_format_version: "u32",
+      min_move_binary_format_version: "u32",
+      random_beacon_reduction_allowed_delta: "u16",
+      random_beacon_dkg_timeout_round: "u32",
+      random_beacon_reduction_lower_bound: "u32",
+      scoring_decision_cutoff_value: "f64",
+      scoring_decision_mad_divisor: "f64",
+      group_ops_bls12381_msm_max_len: "u32",
+      binary_module_handles: "u16",
+      binary_struct_handles: "u16",
+      binary_function_handles: "u16",
+      binary_function_instantiations: "u16",
+      binary_signatures: "u16",
+      binary_constant_pool: "u16",
+      binary_identifiers: "u16",
+      binary_address_identifiers: "u16",
+      binary_struct_defs: "u16",
+      binary_struct_def_instantiations: "u16",
+      binary_function_defs: "u16",
+      binary_field_handles: "u16",
+      binary_field_instantiations: "u16",
+      binary_friend_decls: "u16",
+      max_package_dependencies: "u32",
+      bridge_should_try_to_finalize_committee: "bool",
+      consensus_gc_depth: "u32"
+    };
+    for (const { key, value } of protocolConfig.configs) {
+      attributes[key] = value === null ? null : {
+        [configTypeMap[key] ?? "u64"]: value
+      };
+    }
+    for (const { key, value } of protocolConfig.featureFlags) {
+      featureFlags[key] = value;
+    }
+    return {
+      maxSupportedProtocolVersion: protocolConfig.protocolVersion?.toString(),
+      minSupportedProtocolVersion: "1",
+      protocolVersion: protocolConfig.protocolVersion?.toString(),
+      attributes,
+      featureFlags
+    };
+  },
+  async isTransactionIndexedOnNode(transport, [digest]) {
+    const isTransactionIndexedOnNode = await transport.graphqlQuery(
+      {
+        query: IsTransactionIndexedOnNodeDocument,
+        variables: {
+          digest
+        }
+      },
+      (data) => data.isTransactionIndexedOnNode
+    );
+    return isTransactionIndexedOnNode;
+  }
+};
+class UnsupportedParamError extends Error {
+  constructor(method, param) {
+    super(`Parameter ${param} is not supported for ${method} in the GraphQL API`);
+  }
+}
+class UnsupportedMethodError extends Error {
+  constructor(method) {
+    super(`Method ${method} is not supported in the GraphQL API`);
+  }
+}
+async function paginateTransactionBlockLists(transport, transactionBlock) {
+  let hasMoreEvents = transactionBlock.effects?.events?.pageInfo.hasNextPage ?? false;
+  let hasMoreBalanceChanges = transactionBlock.effects?.balanceChanges?.pageInfo.hasNextPage ?? false;
+  let hasMoreObjectChanges = transactionBlock.effects?.objectChanges?.pageInfo.hasNextPage ?? false;
+  let afterEvents = transactionBlock.effects?.events?.pageInfo.endCursor;
+  let afterBalanceChanges = transactionBlock.effects?.balanceChanges?.pageInfo.endCursor;
+  let afterObjectChanges = transactionBlock.effects?.objectChanges?.pageInfo.endCursor;
+  while (hasMoreEvents || hasMoreBalanceChanges || hasMoreObjectChanges) {
+    const page = await transport.graphqlQuery(
+      {
+        query: PaginateTransactionBlockListsDocument,
+        variables: {
+          digest: transactionBlock.digest,
+          afterEvents,
+          afterBalanceChanges,
+          afterObjectChanges,
+          hasMoreEvents,
+          hasMoreBalanceChanges,
+          hasMoreObjectChanges
+        }
+      },
+      (data) => data.transactionBlock?.effects
+    );
+    transactionBlock.effects?.events?.nodes.push(...page.events?.nodes ?? []);
+    transactionBlock.effects?.balanceChanges?.nodes.push(...page.balanceChanges?.nodes ?? []);
+    transactionBlock.effects?.objectChanges?.nodes.push(...page.objectChanges?.nodes ?? []);
+    hasMoreEvents = page.events?.pageInfo.hasNextPage ?? false;
+    hasMoreBalanceChanges = page.balanceChanges?.pageInfo.hasNextPage ?? false;
+    hasMoreObjectChanges = page.objectChanges?.pageInfo.hasNextPage ?? false;
+    afterEvents = page.events?.pageInfo.endCursor;
+    afterBalanceChanges = page.balanceChanges?.pageInfo.endCursor;
+    afterObjectChanges = page.objectChanges?.pageInfo.endCursor;
+  }
+}
+async function paginateCheckpointLists(transport, checkpoint) {
+  let hasNextPage = checkpoint.transactionBlocks.pageInfo.hasNextPage;
+  let after = checkpoint.transactionBlocks.pageInfo.endCursor;
+  while (hasNextPage) {
+    const page = await transport.graphqlQuery(
+      {
+        query: PaginateCheckpointTransactionBlocksDocument,
+        variables: {
+          id: { digest: checkpoint.digest },
+          after
+        }
+      },
+      (data) => data.checkpoint?.transactionBlocks
+    );
+    checkpoint.transactionBlocks.nodes.push(...page.nodes);
+    hasNextPage = page.pageInfo.hasNextPage;
+    after = page.pageInfo.endCursor;
+  }
+  const endOfEpochTx = checkpoint.endOfEpoch.nodes[0];
+  if (endOfEpochTx?.kind?.__typename === "EndOfEpochTransaction" && endOfEpochTx.kind?.transactions.nodes[0].__typename === "ChangeEpochTransactionV2" && endOfEpochTx.kind.transactions.nodes[0].epoch?.epochId) {
+    const validatorSet = endOfEpochTx.kind.transactions.nodes[0].epoch.validatorSet;
+    let hasNextPage2 = validatorSet?.committeeMembers.pageInfo.hasNextPage;
+    let after2 = validatorSet?.committeeMembers.pageInfo.endCursor;
+    while (hasNextPage2) {
+      const page = await transport.graphqlQuery(
+        {
+          query: GetCommitteeInfoDocument,
+          variables: {
+            epochId: endOfEpochTx.kind.transactions.nodes[0].epoch?.epochId,
+            after: after2
+          }
+        },
+        (data) => data.epoch?.validatorSet?.committeeMembers
+      );
+      validatorSet?.committeeMembers.nodes.push(...page.nodes);
+      hasNextPage2 = page.pageInfo?.hasNextPage;
+      after2 = page.pageInfo?.endCursor;
+    }
+  }
+}
+async function getDynamicFieldObject(transport, [parentId, name, options]) {
+  const nameLayout = await transport.graphqlQuery(
+    {
+      query: GetTypeLayoutDocument,
+      variables: {
+        type: name.type
+      }
+    },
+    (data) => data.type.layout
+  );
+  const bcsName = mapJsonToBcs(name.value, nameLayout);
+  const parent = await transport.graphqlQuery(
+    {
+      query: GetDynamicFieldObjectDocument,
+      variables: {
+        parentId,
+        name: {
+          type: name.type,
+          bcs: bcsName
+        },
+        showBcs: options?.showBcs,
+        showContent: options?.showContent,
+        showDisplay: options?.showDisplay,
+        showOwner: options?.showOwner,
+        showPreviousTransaction: options?.showPreviousTransaction,
+        showStorageRebate: options?.showStorageRebate,
+        showType: options?.showType
+      }
+    },
+    (data) => {
+      return data.owner?.dynamicObjectField?.value?.__typename === "MoveObject" ? data.owner.dynamicObjectField.value.owner?.__typename === "Parent" ? data.owner.dynamicObjectField.value.owner.parent : void 0 : void 0;
+    }
+  );
+  return {
+    data: {
+      content: parent.asMoveObject ? {
+        dataType: "moveObject",
+        ...moveDataToRpcContent(
+          parent.asMoveObject?.contents?.data,
+          parent.asMoveObject?.contents?.type.layout
+        )
+      } : void 0,
+      digest: parent?.digest,
+      objectId: parent?.address,
+      type: parent?.asMoveObject ? toShortTypeString(parent.asMoveObject.contents?.type.repr) : void 0,
+      version: parent?.version.toString(),
+      storageRebate: parent.storageRebate,
+      previousTransaction: parent.previousTransactionBlock?.digest,
+      owner: parent.owner?.__typename === "Parent" ? {
+        ObjectOwner: parent.owner.parent?.address
+      } : void 0
+    }
+  };
+}
+export {
+  RPC_METHODS,
+  UnsupportedMethodError,
+  UnsupportedParamError
+};
+//# sourceMappingURL=methods.js.map