@iota/graphql-transport 0.1.0

package/dist/cjs/methods.js

@@ -0,0 +1,1276 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var methods_exports = {};
+__export(methods_exports, {
+  RPC_METHODS: () => RPC_METHODS,
+  UnsupportedMethodError: () => UnsupportedMethodError,
+  UnsupportedParamError: () => UnsupportedParamError
+});
+module.exports = __toCommonJS(methods_exports);
+var import_bcs = require("@iota/bcs");
+var import_transactions = require("@iota/iota-sdk/transactions");
+var import_utils = require("@iota/iota-sdk/utils");
+var import_queries = require("./generated/queries.js");
+var import_bcs2 = require("./mappers/bcs.js");
+var import_checkpint = require("./mappers/checkpint.js");
+var import_move = require("./mappers/move.js");
+var import_object = require("./mappers/object.js");
+var import_stakes = require("./mappers/stakes.js");
+var import_transaction_block = require("./mappers/transaction-block.js");
+var import_util = require("./mappers/util.js");
+var import_validator = require("./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: import_queries.GetCoinsDocument,
+        variables: {
+          owner,
+          type: coinType,
+          cursor,
+          first: limit
+        }
+      },
+      (data) => data.address?.coins
+    );
+    return {
+      data: coins.map((coin) => ({
+        balance: coin.coinBalance,
+        coinObjectId: coin.address,
+        coinType: (0, import_util.toShortTypeString)(
+          (0, import_utils.normalizeStructTag)((0, import_utils.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: import_queries.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: (0, import_util.toShortTypeString)(
+          (0, import_utils.normalizeStructTag)((0, import_utils.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: import_queries.GetBalanceDocument,
+        variables: {
+          owner: inputs[0],
+          type: inputs[1]
+        }
+      },
+      (data) => data.address?.balance
+    );
+    return {
+      coinType: (0, import_util.toShortTypeString)(balance.coinType?.repr),
+      coinObjectCount: balance.coinObjectCount,
+      totalBalance: balance.totalBalance,
+      lockedBalance: {}
+    };
+  },
+  async getAllBalances(transport, inputs) {
+    const balances = await transport.graphqlQuery(
+      {
+        query: import_queries.GetAllBalancesDocument,
+        variables: {
+          owner: inputs[0]
+        }
+      },
+      (data) => data.address?.balances?.nodes
+    );
+    return balances.map((balance) => ({
+      coinType: (0, import_util.toShortTypeString)(balance.coinType?.repr),
+      coinObjectCount: balance.coinObjectCount,
+      totalBalance: balance.totalBalance,
+      lockedBalance: {}
+    }));
+  },
+  async getCoinMetadata(transport, inputs) {
+    const metadata = await transport.graphqlQuery(
+      {
+        query: import_queries.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: import_queries.GetTotalSupplyDocument,
+        variables: {
+          coinType: inputs[0]
+        }
+      },
+      (data) => data.coinMetadata
+    );
+    return {
+      value: BigInt(metadata.supply).toString()
+    };
+  },
+  async getMoveFunctionArgTypes(transport, [pkg, module2, fn]) {
+    const moveModule = await transport.graphqlQuery(
+      {
+        query: import_queries.GetMoveFunctionArgTypesDocument,
+        variables: {
+          module: module2,
+          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, module2, fn]) {
+    const moveFunction = await transport.graphqlQuery(
+      {
+        query: import_queries.GetNormalizedMoveFunctionDocument,
+        variables: {
+          module: module2,
+          packageId: pkg,
+          function: fn
+        }
+      },
+      (data) => data.object?.asMovePackage?.module?.function
+    );
+    return (0, import_move.mapNormalizedMoveFunction)(moveFunction);
+  },
+  async getNormalizedMoveModulesByPackage(transport, [pkg]) {
+    const movePackage = await transport.graphqlQuery(
+      {
+        query: import_queries.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: import_queries.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 = (0, import_util.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: import_queries.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((module2) => {
+      modules[module2.name] = (0, import_move.mapNormalizedMoveModule)(module2, address);
+    });
+    return modules;
+  },
+  async getNormalizedMoveModule(transport, [pkg, module2]) {
+    const moveModule = await transport.graphqlQuery(
+      {
+        query: import_queries.GetNormalizedMoveModuleDocument,
+        variables: {
+          module: module2,
+          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: import_queries.PaginateMoveModuleListsDocument,
+          variables: {
+            module: module2,
+            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 (0, import_move.mapNormalizedMoveModule)(moveModule, (0, import_utils.normalizeIotaAddress)(pkg));
+  },
+  async getNormalizedMoveStruct(transport, [pkg, module2, struct]) {
+    const moveStruct = await transport.graphqlQuery(
+      {
+        query: import_queries.GetNormalizedMoveStructDocument,
+        variables: {
+          packageId: pkg,
+          module: module2,
+          struct
+        }
+      },
+      (data) => data.object?.asMovePackage?.module?.struct
+    );
+    return (0, import_move.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 = ["MatchAll", "MatchAny", "MatchNone", "Version"];
+      for (const unsupportedFilter of unsupportedFilters) {
+        if (unsupportedFilter in inputFilter) {
+          throw new UnsupportedParamError("getOwnedObjects", unsupportedFilter);
+        }
+      }
+    }
+    const { nodes: objects, pageInfo } = await transport.graphqlQuery(
+      {
+        query: import_queries.GetOwnedObjectsDocument,
+        variables: {
+          owner,
+          limit,
+          cursor,
+          showBcs: options?.showBcs,
+          showContent: options?.showContent,
+          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: (0, import_object.mapGraphQLMoveObjectToRpcObject)(object, options ?? {})
+      }))
+    };
+  },
+  async getObject(transport, [id, options]) {
+    const object = await transport.graphqlQuery(
+      {
+        query: import_queries.GetObjectDocument,
+        variables: {
+          id,
+          showBcs: options?.showBcs,
+          showContent: options?.showContent,
+          showOwner: options?.showOwner,
+          showPreviousTransaction: options?.showPreviousTransaction,
+          showStorageRebate: options?.showStorageRebate,
+          showType: options?.showType
+        }
+      },
+      (data) => data.object
+    );
+    return {
+      data: (0, import_object.mapGraphQLObjectToRpcObject)(object, options ?? {})
+    };
+  },
+  async tryGetPastObject(transport, [id, version, options]) {
+    const data = await transport.graphqlQuery({
+      query: import_queries.TryGetPastObjectDocument,
+      variables: {
+        id,
+        version,
+        showBcs: options?.showBcs,
+        showContent: options?.showContent,
+        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: (0, import_object.mapGraphQLObjectToRpcObject)(data.object, options ?? {})
+    };
+  },
+  async multiGetObjects(transport, [ids, options]) {
+    const objects = await transport.graphqlQuery(
+      {
+        query: import_queries.MultiGetObjectsDocument,
+        variables: {
+          ids,
+          showBcs: options?.showBcs,
+          showContent: options?.showContent,
+          showOwner: options?.showOwner,
+          showPreviousTransaction: options?.showPreviousTransaction,
+          showStorageRebate: options?.showStorageRebate,
+          showType: options?.showType,
+          limit: ids.length
+        }
+      },
+      (data) => data.objects?.nodes
+    );
+    return objects.map((object) => ({
+      data: (0, import_object.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);
+        }
+      }
+    }
+    const { nodes: transactionBlocks, pageInfo } = await transport.graphqlQuery(
+      {
+        query: import_queries.QueryTransactionBlocksDocument,
+        variables: {
+          ...pagination,
+          showBalanceChanges: options?.showBalanceChanges,
+          showEffects: options?.showEffects,
+          showObjectChanges: options?.showObjectChanges,
+          showRawInput: options?.showRawInput,
+          showInput: options?.showInput,
+          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: "TransactionKind" in filter ? filter.TransactionKind === "ProgrammableTransaction" ? import_queries.TransactionBlockKindInput.ProgrammableTx : import_queries.TransactionBlockKindInput.SystemTx : void 0
+          } : {}
+        }
+      },
+      (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) => (0, import_transaction_block.mapGraphQLTransactionBlockToRpcTransactionBlock)(transactionBlock, options ?? {})
+      )
+    };
+  },
+  async getTransactionBlock(transport, [digest, options]) {
+    const transactionBlock = await transport.graphqlQuery(
+      {
+        query: import_queries.GetTransactionBlockDocument,
+        variables: {
+          digest,
+          showBalanceChanges: options?.showBalanceChanges,
+          showEffects: options?.showEffects,
+          showObjectChanges: options?.showObjectChanges,
+          showRawInput: options?.showRawInput,
+          showInput: options?.showInput
+        }
+      },
+      (data) => data.transactionBlock
+    );
+    await paginateTransactionBlockLists(transport, transactionBlock);
+    return (0, import_transaction_block.mapGraphQLTransactionBlockToRpcTransactionBlock)(transactionBlock, options);
+  },
+  async multiGetTransactionBlocks(transport, [digests, options]) {
+    const transactionBlocks = await transport.graphqlQuery(
+      {
+        query: import_queries.MultiGetTransactionBlocksDocument,
+        variables: {
+          digests,
+          showBalanceChanges: options?.showBalanceChanges,
+          showEffects: options?.showEffects,
+          showObjectChanges: options?.showObjectChanges,
+          showRawInput: options?.showRawInput,
+          showInput: options?.showInput,
+          limit: digests.length
+        }
+      },
+      (data) => data.transactionBlocks?.nodes
+    );
+    for (const transactionBlock of transactionBlocks) {
+      await paginateTransactionBlockLists(transport, transactionBlock);
+    }
+    return transactionBlocks.map(
+      (transactionBlock) => (0, import_transaction_block.mapGraphQLTransactionBlockToRpcTransactionBlock)(transactionBlock, options)
+    );
+  },
+  async getTotalTransactionBlocks(transport) {
+    return transport.graphqlQuery(
+      {
+        query: import_queries.GetTotalTransactionBlocksDocument
+      },
+      (data) => BigInt(data.checkpoint?.networkTotalTransactions)
+    );
+  },
+  async getReferenceGasPrice(transport) {
+    const epoch = await transport.graphqlQuery(
+      {
+        query: import_queries.GetReferenceGasPriceDocument,
+        variables: {}
+      },
+      (data) => data.epoch
+    );
+    return BigInt(epoch.referenceGasPrice);
+  },
+  async getStakes(transport, [owner]) {
+    const stakes = await transport.graphqlQuery(
+      {
+        query: import_queries.GetStakesDocument,
+        variables: {
+          owner
+        }
+      },
+      (data) => data.address?.stakedIotas?.nodes
+    );
+    return (0, import_stakes.mapGraphQLStakeToRpcStake)(stakes);
+  },
+  async getStakesByIds(transport, [stakedIotaIds]) {
+    const stakes = await transport.graphqlQuery(
+      {
+        query: import_queries.GetStakesByIdsDocument,
+        variables: {
+          ids: stakedIotaIds
+        }
+      },
+      (data) => data.objects?.nodes.map((node) => node?.asMoveObject?.asStakedIota).filter(Boolean)
+    );
+    return (0, import_stakes.mapGraphQLStakeToRpcStake)(stakes);
+  },
+  async getLatestIotaSystemState(transport) {
+    const systemState = await transport.graphqlQuery(
+      {
+        query: import_queries.GetLatestIotaSystemStateDocument
+      },
+      (data) => data.epoch
+    );
+    let hasMoreValidators = systemState.validatorSet?.activeValidators?.pageInfo.hasNextPage ?? false;
+    let afterValidators = systemState.validatorSet?.activeValidators?.pageInfo.endCursor;
+    while (hasMoreValidators) {
+      const page = await transport.graphqlQuery(
+        {
+          query: import_queries.PaginateEpochValidatorsDocument,
+          variables: {
+            id: systemState.epochId,
+            after: afterValidators
+          }
+        },
+        (data) => data.epoch
+      );
+      systemState.validatorSet?.activeValidators?.nodes.push(
+        ...page.validatorSet?.activeValidators?.nodes ?? []
+      );
+      hasMoreValidators = page.validatorSet?.activeValidators?.pageInfo.hasNextPage ?? false;
+      afterValidators = page.validatorSet?.activeValidators?.pageInfo.endCursor;
+    }
+    return {
+      activeValidators: systemState.validatorSet?.activeValidators?.nodes.map(
+        import_validator.mapGraphQlValidatorToRpcValidator
+      ),
+      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),
+      maxValidatorCount: String(systemState.systemParameters?.maxValidatorCount),
+      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,
+      safeModeComputationRewards: String(systemState.safeMode?.gasSummary?.computationCost),
+      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: "",
+      // TODO
+      inactivePoolsId: "",
+      // TODO
+      pendingActiveValidatorsId: "",
+      // TODO
+      stakingPoolMappingsId: ""
+      // TODO
+    };
+  },
+  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: import_queries.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,
+        id: {
+          eventSeq: "",
+          // TODO
+          txDigest: ""
+          // TODO
+        },
+        packageId: event.sendingModule?.package.address,
+        parsedJson: event.json ? JSON.parse(event.json) : void 0,
+        sender: event.sender?.address,
+        timestampMs: new Date(event.timestamp).getTime().toString(),
+        transactionModule: `${event.sendingModule?.package.address}::${event.sendingModule?.name}`,
+        type: (0, import_util.toShortTypeString)(event.type?.repr)
+      }))
+    };
+  },
+  async devInspectTransactionBlock(transport, [sender, devInspectTxBytes, gasPrice]) {
+    const { transaction, error, results } = await transport.graphqlQuery(
+      {
+        query: import_queries.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 = (0, import_transaction_block.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((0, import_bcs.fromB64)(ref.bcs)),
+            (0, import_util.toShortTypeString)(ref.type.repr)
+          ]
+        ),
+        returnValues: result2.returnValues?.map((value) => [
+          Array.from((0, import_bcs.fromB64)(value.bcs)),
+          (0, import_util.toShortTypeString)(value.type.repr)
+        ])
+      }))
+    };
+  },
+  async getDynamicFields(transport, [parentId, cursor, limit]) {
+    const { nodes: fields, pageInfo } = await transport.graphqlQuery(
+      {
+        query: import_queries.GetDynamicFieldsDocument,
+        variables: {
+          parentId,
+          first: limit,
+          cursor
+        }
+      },
+      (data) => data.object?.dynamicFields
+    );
+    return {
+      data: fields.map((field) => ({
+        bcsName: field.name?.bcs && (0, import_bcs.toB58)((0, import_bcs.fromB64)(field.name.bcs)),
+        digest: field.value?.__typename === "MoveObject" ? field.value.digest : void 0,
+        name: {
+          type: (0, import_util.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 getDynamicFieldObject(transport, [parentId, name]) {
+    const nameLayout = await transport.graphqlQuery(
+      {
+        query: import_queries.GetTypeLayoutDocument,
+        variables: {
+          type: name.type
+        }
+      },
+      (data) => data.type.layout
+    );
+    const bcsName = (0, import_bcs2.mapJsonToBcs)(name.value, nameLayout);
+    const parent = await transport.graphqlQuery(
+      {
+        query: import_queries.GetDynamicFieldObjectDocument,
+        variables: {
+          parentId,
+          name: {
+            type: name.type,
+            bcs: bcsName
+          }
+        }
+      },
+      (data) => {
+        return data.object?.dynamicObjectField?.value?.__typename === "MoveObject" ? data.object.dynamicObjectField.value.owner?.__typename === "Parent" ? data.object.dynamicObjectField.value.owner.parent : void 0 : void 0;
+      }
+    );
+    return {
+      data: {
+        content: {
+          dataType: "moveObject",
+          ...(0, import_move.moveDataToRpcContent)(
+            parent?.asMoveObject?.contents?.data,
+            parent?.asMoveObject?.contents?.type.layout
+          ),
+          hasPublicTransfer: parent?.asMoveObject?.hasPublicTransfer
+        },
+        digest: parent?.digest,
+        objectId: parent?.address,
+        type: (0, import_util.toShortTypeString)(parent?.asMoveObject?.contents?.type.repr),
+        version: parent?.version.toString(),
+        storageRebate: parent.storageRebate,
+        previousTransaction: parent.previousTransactionBlock?.digest,
+        owner: parent.owner?.__typename === "Parent" ? {
+          ObjectOwner: parent.owner.parent?.address
+        } : void 0
+      }
+    };
+  },
+  async executeTransactionBlock(transport, [txBytes, signatures, options, _requestType]) {
+    const { effects, errors } = await transport.graphqlQuery(
+      {
+        query: import_queries.ExecuteTransactionBlockDocument,
+        variables: {
+          txBytes,
+          signatures,
+          showBalanceChanges: options?.showBalanceChanges,
+          showEffects: options?.showEffects,
+          showInput: options?.showInput,
+          showEvents: options?.showEvents,
+          showObjectChanges: options?.showObjectChanges,
+          showRawInput: options?.showRawInput
+        }
+      },
+      (data) => data.executeTransactionBlock
+    );
+    if (!effects?.transactionBlock) {
+      const txb = import_transactions.TransactionBlock.from((0, import_bcs.fromB64)(txBytes));
+      return { errors: errors ?? void 0, digest: await txb.getDigest() };
+    }
+    await paginateTransactionBlockLists(transport, effects.transactionBlock);
+    return (0, import_transaction_block.mapGraphQLTransactionBlockToRpcTransactionBlock)(
+      effects.transactionBlock,
+      options,
+      errors
+    );
+  },
+  async dryRunTransactionBlock(transport, [txBytes]) {
+    const txb = import_transactions.TransactionBlock.from((0, import_bcs.fromB64)(txBytes));
+    const { transaction, error } = await transport.graphqlQuery(
+      {
+        query: import_queries.DryRunTransactionBlockDocument,
+        variables: {
+          txBytes,
+          showBalanceChanges: true,
+          showEffects: true,
+          showEvents: true,
+          showObjectChanges: true,
+          showInput: true
+        }
+      },
+      (data) => data.dryRunTransactionBlock
+    );
+    if (error || !transaction) {
+      throw new Error(error ?? "Unexpected error during dry run");
+    }
+    const result = (0, import_transaction_block.mapGraphQLTransactionBlockToRpcTransactionBlock)(
+      { ...transaction, digest: await txb.getDigest() },
+      {
+        showBalanceChanges: true,
+        showEffects: true,
+        showEvents: true,
+        showObjectChanges: true,
+        showInput: 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: import_queries.GetLatestCheckpointSequenceNumberDocument
+      },
+      (data) => data.checkpoint?.sequenceNumber
+    );
+    return sequenceNumber.toString();
+  },
+  async getCheckpoint(transport, [id]) {
+    const checkpoint = await transport.graphqlQuery(
+      {
+        query: import_queries.GetCheckpointDocument,
+        variables: {
+          id: typeof id === "number" || (0, import_util.isNumericString)(id) ? {
+            sequenceNumber: Number.parseInt(id.toString(), 10)
+          } : {
+            digest: id
+          }
+        }
+      },
+      (data) => data.checkpoint
+    );
+    await paginateCheckpointLists(transport, checkpoint);
+    return (0, import_checkpint.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: import_queries.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) => (0, import_checkpint.mapGraphQLCheckpointToRpcCheckpoint)(checkpoint))
+    };
+  },
+  async getCommitteeInfo(transport, [epoch]) {
+    const { validatorSet, epochId } = await transport.graphqlQuery(
+      {
+        query: import_queries.GetCommitteeInfoDocument,
+        variables: {
+          epochId: epoch ? Number.parseInt(epoch) : void 0
+        }
+      },
+      (data) => data.epoch
+    );
+    let hasNextPage = validatorSet?.activeValidators?.pageInfo.hasNextPage;
+    let after = validatorSet?.activeValidators?.pageInfo.endCursor;
+    while (hasNextPage) {
+      const page = await transport.graphqlQuery(
+        {
+          query: import_queries.GetCommitteeInfoDocument,
+          variables: {
+            epochId: epoch ? Number.parseInt(epoch) : void 0,
+            after
+          }
+        },
+        (data) => data.epoch?.validatorSet?.activeValidators
+      );
+      validatorSet?.activeValidators.nodes.push(...page.nodes);
+      hasNextPage = page.pageInfo.hasNextPage;
+      after = page.pageInfo.endCursor;
+    }
+    return {
+      epoch: epochId.toString(),
+      validators: validatorSet?.activeValidators?.nodes.map((val) => [
+        val.credentials?.protocolPubKey,
+        String(val.votingPower)
+      ])
+    };
+  },
+  async getCurrentEpoch(transport) {
+    const epoch = await transport.graphqlQuery(
+      {
+        query: import_queries.GetCurrentEpochDocument
+      },
+      (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: import_queries.PaginateEpochValidatorsDocument,
+          variables: {
+            id: epoch.epochId,
+            after
+          }
+        },
+        (data) => data.epoch?.validatorSet?.activeValidators
+      );
+      epoch.validatorSet?.activeValidators?.nodes.push(...page.nodes);
+      hasNextPage = page.pageInfo.hasNextPage;
+      after = page.pageInfo.endCursor;
+    }
+    return {
+      epoch: String(epoch.epochId),
+      validators: epoch.validatorSet?.activeValidators?.nodes.map(
+        import_validator.mapGraphQlValidatorToRpcValidator
+      ),
+      epochTotalTransactions: "0",
+      // TODO
+      firstCheckpointId: epoch.firstCheckpoint?.nodes[0]?.sequenceNumber.toString(),
+      endOfEpochInfo: null,
+      referenceGasPrice: Number.parseInt(epoch.referenceGasPrice, 10),
+      epochStartTimestamp: new Date(epoch.startTimestamp).getTime().toString()
+    };
+  },
+  async getValidatorsApy(transport) {
+    const epoch = await transport.graphqlQuery(
+      {
+        query: import_queries.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: import_queries.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: import_queries.GetChainIdentifierDocument
+      },
+      (data) => data.chainIdentifier
+    );
+    return identifier;
+  },
+  async getProtocolConfig(transport, [version]) {
+    const protocolConfig = await transport.graphqlQuery(
+      {
+        query: import_queries.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",
+      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"
+    };
+    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 resolveNameServiceAddress(transport, [name]) {
+    const data = await transport.graphqlQuery({
+      query: import_queries.ResolveNameServiceAddressDocument,
+      variables: {
+        domain: name
+      }
+    });
+    return data.resolveIotansAddress?.address ?? null;
+  },
+  async resolveNameServiceNames(transport, [address, cursor, limit]) {
+    const iotansRegistrations = await transport.graphqlQuery(
+      {
+        query: import_queries.ResolveNameServiceNamesDocument,
+        variables: {
+          address,
+          cursor,
+          limit
+        }
+      },
+      (data) => data.address?.iotansRegistrations
+    );
+    return {
+      hasNextPage: iotansRegistrations.pageInfo.hasNextPage,
+      nextCursor: iotansRegistrations.pageInfo.endCursor ?? null,
+      data: iotansRegistrations?.nodes.map((node) => node.domain) ?? []
+    };
+  }
+};
+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 hasMoreDependencies = transactionBlock.effects?.dependencies?.pageInfo.hasNextPage ?? false;
+  let afterEvents = transactionBlock.effects?.events?.pageInfo.endCursor;
+  let afterBalanceChanges = transactionBlock.effects?.balanceChanges?.pageInfo.endCursor;
+  let afterObjectChanges = transactionBlock.effects?.objectChanges?.pageInfo.endCursor;
+  let afterDependencies = transactionBlock.effects?.dependencies?.pageInfo.endCursor;
+  while (hasMoreEvents || hasMoreBalanceChanges || hasMoreObjectChanges || hasMoreDependencies) {
+    const page = await transport.graphqlQuery(
+      {
+        query: import_queries.PaginateTransactionBlockListsDocument,
+        variables: {
+          digest: transactionBlock.digest,
+          afterEvents,
+          afterBalanceChanges,
+          afterObjectChanges,
+          afterDependencies,
+          hasMoreEvents,
+          hasMoreBalanceChanges,
+          hasMoreObjectChanges,
+          hasMoreDependencies
+        }
+      },
+      (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 ?? []);
+    transactionBlock.effects?.dependencies?.nodes.push(...page.dependencies?.nodes ?? []);
+    hasMoreEvents = page.events?.pageInfo.hasNextPage ?? false;
+    hasMoreBalanceChanges = page.balanceChanges?.pageInfo.hasNextPage ?? false;
+    hasMoreObjectChanges = page.objectChanges?.pageInfo.hasNextPage ?? false;
+    hasMoreDependencies = page.dependencies?.pageInfo.hasNextPage ?? false;
+    afterEvents = page.events?.pageInfo.endCursor;
+    afterBalanceChanges = page.balanceChanges?.pageInfo.endCursor;
+    afterObjectChanges = page.objectChanges?.pageInfo.endCursor;
+    afterDependencies = page.dependencies?.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: import_queries.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 === "ChangeEpochTransaction" && endOfEpochTx.kind.transactions.nodes[0].epoch?.epochId) {
+    const validatorSet = endOfEpochTx.kind.transactions.nodes[0].epoch.validatorSet;
+    let hasNextPage2 = validatorSet?.activeValidators.pageInfo.hasNextPage;
+    let after2 = validatorSet?.activeValidators.pageInfo.endCursor;
+    while (hasNextPage2) {
+      const page = await transport.graphqlQuery(
+        {
+          query: import_queries.GetCommitteeInfoDocument,
+          variables: {
+            epochId: endOfEpochTx.kind.transactions.nodes[0].epoch?.epochId,
+            after: after2
+          }
+        },
+        (data) => data.epoch?.validatorSet?.activeValidators
+      );
+      validatorSet?.activeValidators.nodes.push(...page.nodes);
+      hasNextPage2 = page.pageInfo?.hasNextPage;
+      after2 = page.pageInfo?.endCursor;
+    }
+  }
+}
+//# sourceMappingURL=methods.js.map