diff --git a/packages/conditional-star-release-watcher/src/client.ts b/packages/conditional-star-release-watcher/src/client.ts
index ea7fb29..d783bbb 100644
--- a/packages/conditional-star-release-watcher/src/client.ts
+++ b/packages/conditional-star-release-watcher/src/client.ts
@@ -17,501 +17,6 @@ export class Client {
     this._client = new GraphQLClient(config);
   }
 
-  async getIsActive (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { isActive } = await this._client.query(
-      gql(queries.isActive),
-      { blockHash, contractAddress, _point }
-    );
-
-    return isActive;
-  }
-
-  async getGetKeys (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { getKeys } = await this._client.query(
-      gql(queries.getKeys),
-      { blockHash, contractAddress, _point }
-    );
-
-    return getKeys;
-  }
-
-  async getGetKeyRevisionNumber (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { getKeyRevisionNumber } = await this._client.query(
-      gql(queries.getKeyRevisionNumber),
-      { blockHash, contractAddress, _point }
-    );
-
-    return getKeyRevisionNumber;
-  }
-
-  async getHasBeenLinked (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { hasBeenLinked } = await this._client.query(
-      gql(queries.hasBeenLinked),
-      { blockHash, contractAddress, _point }
-    );
-
-    return hasBeenLinked;
-  }
-
-  async getIsLive (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { isLive } = await this._client.query(
-      gql(queries.isLive),
-      { blockHash, contractAddress, _point }
-    );
-
-    return isLive;
-  }
-
-  async getGetContinuityNumber (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { getContinuityNumber } = await this._client.query(
-      gql(queries.getContinuityNumber),
-      { blockHash, contractAddress, _point }
-    );
-
-    return getContinuityNumber;
-  }
-
-  async getGetSpawnCount (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { getSpawnCount } = await this._client.query(
-      gql(queries.getSpawnCount),
-      { blockHash, contractAddress, _point }
-    );
-
-    return getSpawnCount;
-  }
-
-  async getHasSponsor (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { hasSponsor } = await this._client.query(
-      gql(queries.hasSponsor),
-      { blockHash, contractAddress, _point }
-    );
-
-    return hasSponsor;
-  }
-
-  async getGetSponsor (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { getSponsor } = await this._client.query(
-      gql(queries.getSponsor),
-      { blockHash, contractAddress, _point }
-    );
-
-    return getSponsor;
-  }
-
-  async getIsSponsor (blockHash: string, contractAddress: string, _point: bigint, _sponsor: bigint): Promise<any> {
-    const { isSponsor } = await this._client.query(
-      gql(queries.isSponsor),
-      { blockHash, contractAddress, _point, _sponsor }
-    );
-
-    return isSponsor;
-  }
-
-  async getGetSponsoringCount (blockHash: string, contractAddress: string, _sponsor: bigint): Promise<any> {
-    const { getSponsoringCount } = await this._client.query(
-      gql(queries.getSponsoringCount),
-      { blockHash, contractAddress, _sponsor }
-    );
-
-    return getSponsoringCount;
-  }
-
-  async getIsEscaping (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { isEscaping } = await this._client.query(
-      gql(queries.isEscaping),
-      { blockHash, contractAddress, _point }
-    );
-
-    return isEscaping;
-  }
-
-  async getGetEscapeRequest (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { getEscapeRequest } = await this._client.query(
-      gql(queries.getEscapeRequest),
-      { blockHash, contractAddress, _point }
-    );
-
-    return getEscapeRequest;
-  }
-
-  async getIsRequestingEscapeTo (blockHash: string, contractAddress: string, _point: bigint, _sponsor: bigint): Promise<any> {
-    const { isRequestingEscapeTo } = await this._client.query(
-      gql(queries.isRequestingEscapeTo),
-      { blockHash, contractAddress, _point, _sponsor }
-    );
-
-    return isRequestingEscapeTo;
-  }
-
-  async getGetEscapeRequestsCount (blockHash: string, contractAddress: string, _sponsor: bigint): Promise<any> {
-    const { getEscapeRequestsCount } = await this._client.query(
-      gql(queries.getEscapeRequestsCount),
-      { blockHash, contractAddress, _sponsor }
-    );
-
-    return getEscapeRequestsCount;
-  }
-
-  async getGetOwner (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { getOwner } = await this._client.query(
-      gql(queries.getOwner),
-      { blockHash, contractAddress, _point }
-    );
-
-    return getOwner;
-  }
-
-  async getIsOwner (blockHash: string, contractAddress: string, _point: bigint, _address: string): Promise<any> {
-    const { isOwner } = await this._client.query(
-      gql(queries.isOwner),
-      { blockHash, contractAddress, _point, _address }
-    );
-
-    return isOwner;
-  }
-
-  async getGetOwnedPointCount (blockHash: string, contractAddress: string, _whose: string): Promise<any> {
-    const { getOwnedPointCount } = await this._client.query(
-      gql(queries.getOwnedPointCount),
-      { blockHash, contractAddress, _whose }
-    );
-
-    return getOwnedPointCount;
-  }
-
-  async getGetOwnedPointAtIndex (blockHash: string, contractAddress: string, _whose: string, _index: bigint): Promise<any> {
-    const { getOwnedPointAtIndex } = await this._client.query(
-      gql(queries.getOwnedPointAtIndex),
-      { blockHash, contractAddress, _whose, _index }
-    );
-
-    return getOwnedPointAtIndex;
-  }
-
-  async getGetManagementProxy (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { getManagementProxy } = await this._client.query(
-      gql(queries.getManagementProxy),
-      { blockHash, contractAddress, _point }
-    );
-
-    return getManagementProxy;
-  }
-
-  async getIsManagementProxy (blockHash: string, contractAddress: string, _point: bigint, _proxy: string): Promise<any> {
-    const { isManagementProxy } = await this._client.query(
-      gql(queries.isManagementProxy),
-      { blockHash, contractAddress, _point, _proxy }
-    );
-
-    return isManagementProxy;
-  }
-
-  async getCanManage (blockHash: string, contractAddress: string, _point: bigint, _who: string): Promise<any> {
-    const { canManage } = await this._client.query(
-      gql(queries.canManage),
-      { blockHash, contractAddress, _point, _who }
-    );
-
-    return canManage;
-  }
-
-  async getGetManagerForCount (blockHash: string, contractAddress: string, _proxy: string): Promise<any> {
-    const { getManagerForCount } = await this._client.query(
-      gql(queries.getManagerForCount),
-      { blockHash, contractAddress, _proxy }
-    );
-
-    return getManagerForCount;
-  }
-
-  async getGetSpawnProxy (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { getSpawnProxy } = await this._client.query(
-      gql(queries.getSpawnProxy),
-      { blockHash, contractAddress, _point }
-    );
-
-    return getSpawnProxy;
-  }
-
-  async getIsSpawnProxy (blockHash: string, contractAddress: string, _point: bigint, _proxy: string): Promise<any> {
-    const { isSpawnProxy } = await this._client.query(
-      gql(queries.isSpawnProxy),
-      { blockHash, contractAddress, _point, _proxy }
-    );
-
-    return isSpawnProxy;
-  }
-
-  async getCanSpawnAs (blockHash: string, contractAddress: string, _point: bigint, _who: string): Promise<any> {
-    const { canSpawnAs } = await this._client.query(
-      gql(queries.canSpawnAs),
-      { blockHash, contractAddress, _point, _who }
-    );
-
-    return canSpawnAs;
-  }
-
-  async getGetSpawningForCount (blockHash: string, contractAddress: string, _proxy: string): Promise<any> {
-    const { getSpawningForCount } = await this._client.query(
-      gql(queries.getSpawningForCount),
-      { blockHash, contractAddress, _proxy }
-    );
-
-    return getSpawningForCount;
-  }
-
-  async getGetVotingProxy (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { getVotingProxy } = await this._client.query(
-      gql(queries.getVotingProxy),
-      { blockHash, contractAddress, _point }
-    );
-
-    return getVotingProxy;
-  }
-
-  async getIsVotingProxy (blockHash: string, contractAddress: string, _point: bigint, _proxy: string): Promise<any> {
-    const { isVotingProxy } = await this._client.query(
-      gql(queries.isVotingProxy),
-      { blockHash, contractAddress, _point, _proxy }
-    );
-
-    return isVotingProxy;
-  }
-
-  async getCanVoteAs (blockHash: string, contractAddress: string, _point: bigint, _who: string): Promise<any> {
-    const { canVoteAs } = await this._client.query(
-      gql(queries.canVoteAs),
-      { blockHash, contractAddress, _point, _who }
-    );
-
-    return canVoteAs;
-  }
-
-  async getGetVotingForCount (blockHash: string, contractAddress: string, _proxy: string): Promise<any> {
-    const { getVotingForCount } = await this._client.query(
-      gql(queries.getVotingForCount),
-      { blockHash, contractAddress, _proxy }
-    );
-
-    return getVotingForCount;
-  }
-
-  async getGetTransferProxy (blockHash: string, contractAddress: string, _point: bigint): Promise<any> {
-    const { getTransferProxy } = await this._client.query(
-      gql(queries.getTransferProxy),
-      { blockHash, contractAddress, _point }
-    );
-
-    return getTransferProxy;
-  }
-
-  async getIsTransferProxy (blockHash: string, contractAddress: string, _point: bigint, _proxy: string): Promise<any> {
-    const { isTransferProxy } = await this._client.query(
-      gql(queries.isTransferProxy),
-      { blockHash, contractAddress, _point, _proxy }
-    );
-
-    return isTransferProxy;
-  }
-
-  async getCanTransfer (blockHash: string, contractAddress: string, _point: bigint, _who: string): Promise<any> {
-    const { canTransfer } = await this._client.query(
-      gql(queries.canTransfer),
-      { blockHash, contractAddress, _point, _who }
-    );
-
-    return canTransfer;
-  }
-
-  async getGetTransferringForCount (blockHash: string, contractAddress: string, _proxy: string): Promise<any> {
-    const { getTransferringForCount } = await this._client.query(
-      gql(queries.getTransferringForCount),
-      { blockHash, contractAddress, _proxy }
-    );
-
-    return getTransferringForCount;
-  }
-
-  async getIsOperator (blockHash: string, contractAddress: string, _owner: string, _operator: string): Promise<any> {
-    const { isOperator } = await this._client.query(
-      gql(queries.isOperator),
-      { blockHash, contractAddress, _owner, _operator }
-    );
-
-    return isOperator;
-  }
-
-  async getGetUpgradeProposalCount (blockHash: string, contractAddress: string): Promise<any> {
-    const { getUpgradeProposalCount } = await this._client.query(
-      gql(queries.getUpgradeProposalCount),
-      { blockHash, contractAddress }
-    );
-
-    return getUpgradeProposalCount;
-  }
-
-  async getGetDocumentProposalCount (blockHash: string, contractAddress: string): Promise<any> {
-    const { getDocumentProposalCount } = await this._client.query(
-      gql(queries.getDocumentProposalCount),
-      { blockHash, contractAddress }
-    );
-
-    return getDocumentProposalCount;
-  }
-
-  async getHasVotedOnUpgradePoll (blockHash: string, contractAddress: string, _galaxy: number, _proposal: string): Promise<any> {
-    const { hasVotedOnUpgradePoll } = await this._client.query(
-      gql(queries.hasVotedOnUpgradePoll),
-      { blockHash, contractAddress, _galaxy, _proposal }
-    );
-
-    return hasVotedOnUpgradePoll;
-  }
-
-  async getHasVotedOnDocumentPoll (blockHash: string, contractAddress: string, _galaxy: number, _proposal: string): Promise<any> {
-    const { hasVotedOnDocumentPoll } = await this._client.query(
-      gql(queries.hasVotedOnDocumentPoll),
-      { blockHash, contractAddress, _galaxy, _proposal }
-    );
-
-    return hasVotedOnDocumentPoll;
-  }
-
-  async getFindClaim (blockHash: string, contractAddress: string, _whose: bigint, _protocol: string, _claim: string): Promise<any> {
-    const { findClaim } = await this._client.query(
-      gql(queries.findClaim),
-      { blockHash, contractAddress, _whose, _protocol, _claim }
-    );
-
-    return findClaim;
-  }
-
-  async getSupportsInterface (blockHash: string, contractAddress: string, _interfaceId: string): Promise<any> {
-    const { supportsInterface } = await this._client.query(
-      gql(queries.supportsInterface),
-      { blockHash, contractAddress, _interfaceId }
-    );
-
-    return supportsInterface;
-  }
-
-  async getBalanceOf (blockHash: string, contractAddress: string, _owner: string): Promise<any> {
-    const { balanceOf } = await this._client.query(
-      gql(queries.balanceOf),
-      { blockHash, contractAddress, _owner }
-    );
-
-    return balanceOf;
-  }
-
-  async getOwnerOf (blockHash: string, contractAddress: string, _tokenId: bigint): Promise<any> {
-    const { ownerOf } = await this._client.query(
-      gql(queries.ownerOf),
-      { blockHash, contractAddress, _tokenId }
-    );
-
-    return ownerOf;
-  }
-
-  async getExists (blockHash: string, contractAddress: string, _tokenId: bigint): Promise<any> {
-    const { exists } = await this._client.query(
-      gql(queries.exists),
-      { blockHash, contractAddress, _tokenId }
-    );
-
-    return exists;
-  }
-
-  async getGetApproved (blockHash: string, contractAddress: string, _tokenId: bigint): Promise<any> {
-    const { getApproved } = await this._client.query(
-      gql(queries.getApproved),
-      { blockHash, contractAddress, _tokenId }
-    );
-
-    return getApproved;
-  }
-
-  async getIsApprovedForAll (blockHash: string, contractAddress: string, _owner: string, _operator: string): Promise<any> {
-    const { isApprovedForAll } = await this._client.query(
-      gql(queries.isApprovedForAll),
-      { blockHash, contractAddress, _owner, _operator }
-    );
-
-    return isApprovedForAll;
-  }
-
-  async getTotalSupply (blockHash: string, contractAddress: string): Promise<any> {
-    const { totalSupply } = await this._client.query(
-      gql(queries.totalSupply),
-      { blockHash, contractAddress }
-    );
-
-    return totalSupply;
-  }
-
-  async getTokenOfOwnerByIndex (blockHash: string, contractAddress: string, _owner: string, _index: bigint): Promise<any> {
-    const { tokenOfOwnerByIndex } = await this._client.query(
-      gql(queries.tokenOfOwnerByIndex),
-      { blockHash, contractAddress, _owner, _index }
-    );
-
-    return tokenOfOwnerByIndex;
-  }
-
-  async getTokenByIndex (blockHash: string, contractAddress: string, _index: bigint): Promise<any> {
-    const { tokenByIndex } = await this._client.query(
-      gql(queries.tokenByIndex),
-      { blockHash, contractAddress, _index }
-    );
-
-    return tokenByIndex;
-  }
-
-  async getName (blockHash: string, contractAddress: string): Promise<any> {
-    const { name } = await this._client.query(
-      gql(queries.name),
-      { blockHash, contractAddress }
-    );
-
-    return name;
-  }
-
-  async getSymbol (blockHash: string, contractAddress: string): Promise<any> {
-    const { symbol } = await this._client.query(
-      gql(queries.symbol),
-      { blockHash, contractAddress }
-    );
-
-    return symbol;
-  }
-
-  async getTokenURI (blockHash: string, contractAddress: string, _tokenId: bigint): Promise<any> {
-    const { tokenURI } = await this._client.query(
-      gql(queries.tokenURI),
-      { blockHash, contractAddress, _tokenId }
-    );
-
-    return tokenURI;
-  }
-
-  async getGetSpawnLimit (blockHash: string, contractAddress: string, _point: bigint, _time: bigint): Promise<any> {
-    const { getSpawnLimit } = await this._client.query(
-      gql(queries.getSpawnLimit),
-      { blockHash, contractAddress, _point, _time }
-    );
-
-    return getSpawnLimit;
-  }
-
-  async getCanEscapeTo (blockHash: string, contractAddress: string, _point: bigint, _sponsor: bigint): Promise<any> {
-    const { canEscapeTo } = await this._client.query(
-      gql(queries.canEscapeTo),
-      { blockHash, contractAddress, _point, _sponsor }
-    );
-
-    return canEscapeTo;
-  }
-
   async getWithdrawLimit (blockHash: string, contractAddress: string, _participant: string, _batch: number): Promise<any> {
     const { withdrawLimit } = await this._client.query(
       gql(queries.withdrawLimit),
diff --git a/packages/conditional-star-release-watcher/src/database.ts b/packages/conditional-star-release-watcher/src/database.ts
index 316f7e2..82929de 100644
--- a/packages/conditional-star-release-watcher/src/database.ts
+++ b/packages/conditional-star-release-watcher/src/database.ts
@@ -20,68 +20,13 @@ import { SyncStatus } from './entity/SyncStatus';
 import { StateSyncStatus } from './entity/StateSyncStatus';
 import { BlockProgress } from './entity/BlockProgress';
 import { State } from './entity/State';
-import { IsActive } from './entity/IsActive';
-import { GetKeys } from './entity/GetKeys';
-import { GetKeyRevisionNumber } from './entity/GetKeyRevisionNumber';
-import { HasBeenLinked } from './entity/HasBeenLinked';
-import { IsLive } from './entity/IsLive';
-import { GetContinuityNumber } from './entity/GetContinuityNumber';
-import { GetSpawnCount } from './entity/GetSpawnCount';
-import { HasSponsor } from './entity/HasSponsor';
-import { GetSponsor } from './entity/GetSponsor';
-import { IsSponsor } from './entity/IsSponsor';
-import { GetSponsoringCount } from './entity/GetSponsoringCount';
-import { IsEscaping } from './entity/IsEscaping';
-import { GetEscapeRequest } from './entity/GetEscapeRequest';
-import { IsRequestingEscapeTo } from './entity/IsRequestingEscapeTo';
-import { GetEscapeRequestsCount } from './entity/GetEscapeRequestsCount';
-import { GetOwner } from './entity/GetOwner';
-import { IsOwner } from './entity/IsOwner';
-import { GetOwnedPointCount } from './entity/GetOwnedPointCount';
-import { GetOwnedPointAtIndex } from './entity/GetOwnedPointAtIndex';
-import { GetManagementProxy } from './entity/GetManagementProxy';
-import { IsManagementProxy } from './entity/IsManagementProxy';
-import { CanManage } from './entity/CanManage';
-import { GetManagerForCount } from './entity/GetManagerForCount';
-import { GetSpawnProxy } from './entity/GetSpawnProxy';
-import { IsSpawnProxy } from './entity/IsSpawnProxy';
-import { CanSpawnAs } from './entity/CanSpawnAs';
-import { GetSpawningForCount } from './entity/GetSpawningForCount';
-import { GetVotingProxy } from './entity/GetVotingProxy';
-import { IsVotingProxy } from './entity/IsVotingProxy';
-import { CanVoteAs } from './entity/CanVoteAs';
-import { GetVotingForCount } from './entity/GetVotingForCount';
-import { GetTransferProxy } from './entity/GetTransferProxy';
-import { IsTransferProxy } from './entity/IsTransferProxy';
-import { CanTransfer } from './entity/CanTransfer';
-import { GetTransferringForCount } from './entity/GetTransferringForCount';
-import { IsOperator } from './entity/IsOperator';
-import { GetUpgradeProposalCount } from './entity/GetUpgradeProposalCount';
-import { GetDocumentProposalCount } from './entity/GetDocumentProposalCount';
-import { HasVotedOnUpgradePoll } from './entity/HasVotedOnUpgradePoll';
-import { HasVotedOnDocumentPoll } from './entity/HasVotedOnDocumentPoll';
-import { FindClaim } from './entity/FindClaim';
-import { SupportsInterface } from './entity/SupportsInterface';
-import { BalanceOf } from './entity/BalanceOf';
-import { OwnerOf } from './entity/OwnerOf';
-import { Exists } from './entity/Exists';
-import { GetApproved } from './entity/GetApproved';
-import { IsApprovedForAll } from './entity/IsApprovedForAll';
-import { TotalSupply } from './entity/TotalSupply';
-import { TokenOfOwnerByIndex } from './entity/TokenOfOwnerByIndex';
-import { TokenByIndex } from './entity/TokenByIndex';
-import { Name } from './entity/Name';
-import { Symbol } from './entity/Symbol';
-import { TokenURI } from './entity/TokenURI';
-import { GetSpawnLimit } from './entity/GetSpawnLimit';
-import { CanEscapeTo } from './entity/CanEscapeTo';
 import { WithdrawLimit } from './entity/WithdrawLimit';
 import { VerifyBalance } from './entity/VerifyBalance';
 import { GetBatch } from './entity/GetBatch';
 import { GetWithdrawnFromBatch } from './entity/GetWithdrawnFromBatch';
 import { HasForfeitedBatch } from './entity/HasForfeitedBatch';
 
-export const ENTITIES = [IsActive, GetKeys, GetKeyRevisionNumber, HasBeenLinked, IsLive, GetContinuityNumber, GetSpawnCount, HasSponsor, GetSponsor, IsSponsor, GetSponsoringCount, IsEscaping, GetEscapeRequest, IsRequestingEscapeTo, GetEscapeRequestsCount, GetOwner, IsOwner, GetOwnedPointCount, GetOwnedPointAtIndex, GetManagementProxy, IsManagementProxy, CanManage, GetManagerForCount, GetSpawnProxy, IsSpawnProxy, CanSpawnAs, GetSpawningForCount, GetVotingProxy, IsVotingProxy, CanVoteAs, GetVotingForCount, GetTransferProxy, IsTransferProxy, CanTransfer, GetTransferringForCount, IsOperator, GetUpgradeProposalCount, GetDocumentProposalCount, HasVotedOnUpgradePoll, HasVotedOnDocumentPoll, FindClaim, SupportsInterface, BalanceOf, OwnerOf, Exists, GetApproved, IsApprovedForAll, TotalSupply, TokenOfOwnerByIndex, TokenByIndex, Name, Symbol, TokenURI, GetSpawnLimit, CanEscapeTo, WithdrawLimit, VerifyBalance, GetBatch, GetWithdrawnFromBatch, HasForfeitedBatch];
+export const ENTITIES = [WithdrawLimit, VerifyBalance, GetBatch, GetWithdrawnFromBatch, HasForfeitedBatch];
 
 export class Database implements DatabaseInterface {
   _config: ConnectionOptions;
@@ -114,518 +59,6 @@ export class Database implements DatabaseInterface {
     return this._baseDatabase.close();
   }
 
-  async getIsActive ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<IsActive | undefined> {
-    return this._conn.getRepository(IsActive)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getGetKeys ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<GetKeys | undefined> {
-    return this._conn.getRepository(GetKeys)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getGetKeyRevisionNumber ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<GetKeyRevisionNumber | undefined> {
-    return this._conn.getRepository(GetKeyRevisionNumber)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getHasBeenLinked ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<HasBeenLinked | undefined> {
-    return this._conn.getRepository(HasBeenLinked)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getIsLive ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<IsLive | undefined> {
-    return this._conn.getRepository(IsLive)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getGetContinuityNumber ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<GetContinuityNumber | undefined> {
-    return this._conn.getRepository(GetContinuityNumber)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getGetSpawnCount ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<GetSpawnCount | undefined> {
-    return this._conn.getRepository(GetSpawnCount)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getHasSponsor ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<HasSponsor | undefined> {
-    return this._conn.getRepository(HasSponsor)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getGetSponsor ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<GetSponsor | undefined> {
-    return this._conn.getRepository(GetSponsor)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getIsSponsor ({ blockHash, contractAddress, _point, _sponsor }: { blockHash: string, contractAddress: string, _point: bigint, _sponsor: bigint }): Promise<IsSponsor | undefined> {
-    return this._conn.getRepository(IsSponsor)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point,
-        _sponsor
-      });
-  }
-
-  async getGetSponsoringCount ({ blockHash, contractAddress, _sponsor }: { blockHash: string, contractAddress: string, _sponsor: bigint }): Promise<GetSponsoringCount | undefined> {
-    return this._conn.getRepository(GetSponsoringCount)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _sponsor
-      });
-  }
-
-  async getIsEscaping ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<IsEscaping | undefined> {
-    return this._conn.getRepository(IsEscaping)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getGetEscapeRequest ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<GetEscapeRequest | undefined> {
-    return this._conn.getRepository(GetEscapeRequest)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getIsRequestingEscapeTo ({ blockHash, contractAddress, _point, _sponsor }: { blockHash: string, contractAddress: string, _point: bigint, _sponsor: bigint }): Promise<IsRequestingEscapeTo | undefined> {
-    return this._conn.getRepository(IsRequestingEscapeTo)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point,
-        _sponsor
-      });
-  }
-
-  async getGetEscapeRequestsCount ({ blockHash, contractAddress, _sponsor }: { blockHash: string, contractAddress: string, _sponsor: bigint }): Promise<GetEscapeRequestsCount | undefined> {
-    return this._conn.getRepository(GetEscapeRequestsCount)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _sponsor
-      });
-  }
-
-  async getGetOwner ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<GetOwner | undefined> {
-    return this._conn.getRepository(GetOwner)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getIsOwner ({ blockHash, contractAddress, _point, _address }: { blockHash: string, contractAddress: string, _point: bigint, _address: string }): Promise<IsOwner | undefined> {
-    return this._conn.getRepository(IsOwner)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point,
-        _address
-      });
-  }
-
-  async getGetOwnedPointCount ({ blockHash, contractAddress, _whose }: { blockHash: string, contractAddress: string, _whose: string }): Promise<GetOwnedPointCount | undefined> {
-    return this._conn.getRepository(GetOwnedPointCount)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _whose
-      });
-  }
-
-  async getGetOwnedPointAtIndex ({ blockHash, contractAddress, _whose, _index }: { blockHash: string, contractAddress: string, _whose: string, _index: bigint }): Promise<GetOwnedPointAtIndex | undefined> {
-    return this._conn.getRepository(GetOwnedPointAtIndex)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _whose,
-        _index
-      });
-  }
-
-  async getGetManagementProxy ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<GetManagementProxy | undefined> {
-    return this._conn.getRepository(GetManagementProxy)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getIsManagementProxy ({ blockHash, contractAddress, _point, _proxy }: { blockHash: string, contractAddress: string, _point: bigint, _proxy: string }): Promise<IsManagementProxy | undefined> {
-    return this._conn.getRepository(IsManagementProxy)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point,
-        _proxy
-      });
-  }
-
-  async getCanManage ({ blockHash, contractAddress, _point, _who }: { blockHash: string, contractAddress: string, _point: bigint, _who: string }): Promise<CanManage | undefined> {
-    return this._conn.getRepository(CanManage)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point,
-        _who
-      });
-  }
-
-  async getGetManagerForCount ({ blockHash, contractAddress, _proxy }: { blockHash: string, contractAddress: string, _proxy: string }): Promise<GetManagerForCount | undefined> {
-    return this._conn.getRepository(GetManagerForCount)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _proxy
-      });
-  }
-
-  async getGetSpawnProxy ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<GetSpawnProxy | undefined> {
-    return this._conn.getRepository(GetSpawnProxy)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getIsSpawnProxy ({ blockHash, contractAddress, _point, _proxy }: { blockHash: string, contractAddress: string, _point: bigint, _proxy: string }): Promise<IsSpawnProxy | undefined> {
-    return this._conn.getRepository(IsSpawnProxy)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point,
-        _proxy
-      });
-  }
-
-  async getCanSpawnAs ({ blockHash, contractAddress, _point, _who }: { blockHash: string, contractAddress: string, _point: bigint, _who: string }): Promise<CanSpawnAs | undefined> {
-    return this._conn.getRepository(CanSpawnAs)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point,
-        _who
-      });
-  }
-
-  async getGetSpawningForCount ({ blockHash, contractAddress, _proxy }: { blockHash: string, contractAddress: string, _proxy: string }): Promise<GetSpawningForCount | undefined> {
-    return this._conn.getRepository(GetSpawningForCount)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _proxy
-      });
-  }
-
-  async getGetVotingProxy ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<GetVotingProxy | undefined> {
-    return this._conn.getRepository(GetVotingProxy)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getIsVotingProxy ({ blockHash, contractAddress, _point, _proxy }: { blockHash: string, contractAddress: string, _point: bigint, _proxy: string }): Promise<IsVotingProxy | undefined> {
-    return this._conn.getRepository(IsVotingProxy)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point,
-        _proxy
-      });
-  }
-
-  async getCanVoteAs ({ blockHash, contractAddress, _point, _who }: { blockHash: string, contractAddress: string, _point: bigint, _who: string }): Promise<CanVoteAs | undefined> {
-    return this._conn.getRepository(CanVoteAs)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point,
-        _who
-      });
-  }
-
-  async getGetVotingForCount ({ blockHash, contractAddress, _proxy }: { blockHash: string, contractAddress: string, _proxy: string }): Promise<GetVotingForCount | undefined> {
-    return this._conn.getRepository(GetVotingForCount)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _proxy
-      });
-  }
-
-  async getGetTransferProxy ({ blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint }): Promise<GetTransferProxy | undefined> {
-    return this._conn.getRepository(GetTransferProxy)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point
-      });
-  }
-
-  async getIsTransferProxy ({ blockHash, contractAddress, _point, _proxy }: { blockHash: string, contractAddress: string, _point: bigint, _proxy: string }): Promise<IsTransferProxy | undefined> {
-    return this._conn.getRepository(IsTransferProxy)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point,
-        _proxy
-      });
-  }
-
-  async getCanTransfer ({ blockHash, contractAddress, _point, _who }: { blockHash: string, contractAddress: string, _point: bigint, _who: string }): Promise<CanTransfer | undefined> {
-    return this._conn.getRepository(CanTransfer)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point,
-        _who
-      });
-  }
-
-  async getGetTransferringForCount ({ blockHash, contractAddress, _proxy }: { blockHash: string, contractAddress: string, _proxy: string }): Promise<GetTransferringForCount | undefined> {
-    return this._conn.getRepository(GetTransferringForCount)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _proxy
-      });
-  }
-
-  async getIsOperator ({ blockHash, contractAddress, _owner, _operator }: { blockHash: string, contractAddress: string, _owner: string, _operator: string }): Promise<IsOperator | undefined> {
-    return this._conn.getRepository(IsOperator)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _owner,
-        _operator
-      });
-  }
-
-  async getGetUpgradeProposalCount ({ blockHash, contractAddress }: { blockHash: string, contractAddress: string }): Promise<GetUpgradeProposalCount | undefined> {
-    return this._conn.getRepository(GetUpgradeProposalCount)
-      .findOne({
-        blockHash,
-        contractAddress
-      });
-  }
-
-  async getGetDocumentProposalCount ({ blockHash, contractAddress }: { blockHash: string, contractAddress: string }): Promise<GetDocumentProposalCount | undefined> {
-    return this._conn.getRepository(GetDocumentProposalCount)
-      .findOne({
-        blockHash,
-        contractAddress
-      });
-  }
-
-  async getHasVotedOnUpgradePoll ({ blockHash, contractAddress, _galaxy, _proposal }: { blockHash: string, contractAddress: string, _galaxy: number, _proposal: string }): Promise<HasVotedOnUpgradePoll | undefined> {
-    return this._conn.getRepository(HasVotedOnUpgradePoll)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _galaxy,
-        _proposal
-      });
-  }
-
-  async getHasVotedOnDocumentPoll ({ blockHash, contractAddress, _galaxy, _proposal }: { blockHash: string, contractAddress: string, _galaxy: number, _proposal: string }): Promise<HasVotedOnDocumentPoll | undefined> {
-    return this._conn.getRepository(HasVotedOnDocumentPoll)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _galaxy,
-        _proposal
-      });
-  }
-
-  async getFindClaim ({ blockHash, contractAddress, _whose, _protocol, _claim }: { blockHash: string, contractAddress: string, _whose: bigint, _protocol: string, _claim: string }): Promise<FindClaim | undefined> {
-    return this._conn.getRepository(FindClaim)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _whose,
-        _protocol,
-        _claim
-      });
-  }
-
-  async getSupportsInterface ({ blockHash, contractAddress, _interfaceId }: { blockHash: string, contractAddress: string, _interfaceId: string }): Promise<SupportsInterface | undefined> {
-    return this._conn.getRepository(SupportsInterface)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _interfaceId
-      });
-  }
-
-  async getBalanceOf ({ blockHash, contractAddress, _owner }: { blockHash: string, contractAddress: string, _owner: string }): Promise<BalanceOf | undefined> {
-    return this._conn.getRepository(BalanceOf)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _owner
-      });
-  }
-
-  async getOwnerOf ({ blockHash, contractAddress, _tokenId }: { blockHash: string, contractAddress: string, _tokenId: bigint }): Promise<OwnerOf | undefined> {
-    return this._conn.getRepository(OwnerOf)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _tokenId
-      });
-  }
-
-  async getExists ({ blockHash, contractAddress, _tokenId }: { blockHash: string, contractAddress: string, _tokenId: bigint }): Promise<Exists | undefined> {
-    return this._conn.getRepository(Exists)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _tokenId
-      });
-  }
-
-  async getGetApproved ({ blockHash, contractAddress, _tokenId }: { blockHash: string, contractAddress: string, _tokenId: bigint }): Promise<GetApproved | undefined> {
-    return this._conn.getRepository(GetApproved)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _tokenId
-      });
-  }
-
-  async getIsApprovedForAll ({ blockHash, contractAddress, _owner, _operator }: { blockHash: string, contractAddress: string, _owner: string, _operator: string }): Promise<IsApprovedForAll | undefined> {
-    return this._conn.getRepository(IsApprovedForAll)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _owner,
-        _operator
-      });
-  }
-
-  async getTotalSupply ({ blockHash, contractAddress }: { blockHash: string, contractAddress: string }): Promise<TotalSupply | undefined> {
-    return this._conn.getRepository(TotalSupply)
-      .findOne({
-        blockHash,
-        contractAddress
-      });
-  }
-
-  async getTokenOfOwnerByIndex ({ blockHash, contractAddress, _owner, _index }: { blockHash: string, contractAddress: string, _owner: string, _index: bigint }): Promise<TokenOfOwnerByIndex | undefined> {
-    return this._conn.getRepository(TokenOfOwnerByIndex)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _owner,
-        _index
-      });
-  }
-
-  async getTokenByIndex ({ blockHash, contractAddress, _index }: { blockHash: string, contractAddress: string, _index: bigint }): Promise<TokenByIndex | undefined> {
-    return this._conn.getRepository(TokenByIndex)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _index
-      });
-  }
-
-  async getName ({ blockHash, contractAddress }: { blockHash: string, contractAddress: string }): Promise<Name | undefined> {
-    return this._conn.getRepository(Name)
-      .findOne({
-        blockHash,
-        contractAddress
-      });
-  }
-
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  async getSymbol ({ blockHash, contractAddress }: { blockHash: string, contractAddress: string }): Promise<Symbol | undefined> {
-    return this._conn.getRepository(Symbol)
-      .findOne({
-        blockHash,
-        contractAddress
-      });
-  }
-
-  async getTokenURI ({ blockHash, contractAddress, _tokenId }: { blockHash: string, contractAddress: string, _tokenId: bigint }): Promise<TokenURI | undefined> {
-    return this._conn.getRepository(TokenURI)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _tokenId
-      });
-  }
-
-  async getGetSpawnLimit ({ blockHash, contractAddress, _point, _time }: { blockHash: string, contractAddress: string, _point: bigint, _time: bigint }): Promise<GetSpawnLimit | undefined> {
-    return this._conn.getRepository(GetSpawnLimit)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point,
-        _time
-      });
-  }
-
-  async getCanEscapeTo ({ blockHash, contractAddress, _point, _sponsor }: { blockHash: string, contractAddress: string, _point: bigint, _sponsor: bigint }): Promise<CanEscapeTo | undefined> {
-    return this._conn.getRepository(CanEscapeTo)
-      .findOne({
-        blockHash,
-        contractAddress,
-        _point,
-        _sponsor
-      });
-  }
-
   async getWithdrawLimit ({ blockHash, contractAddress, _participant, _batch }: { blockHash: string, contractAddress: string, _participant: string, _batch: number }): Promise<WithdrawLimit | undefined> {
     return this._conn.getRepository(WithdrawLimit)
       .findOne({
@@ -675,337 +108,6 @@ export class Database implements DatabaseInterface {
       });
   }
 
-  async saveIsActive ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<IsActive>): Promise<IsActive> {
-    const repo = this._conn.getRepository(IsActive);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetKeys ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<GetKeys>): Promise<GetKeys> {
-    const repo = this._conn.getRepository(GetKeys);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetKeyRevisionNumber ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<GetKeyRevisionNumber>): Promise<GetKeyRevisionNumber> {
-    const repo = this._conn.getRepository(GetKeyRevisionNumber);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveHasBeenLinked ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<HasBeenLinked>): Promise<HasBeenLinked> {
-    const repo = this._conn.getRepository(HasBeenLinked);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveIsLive ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<IsLive>): Promise<IsLive> {
-    const repo = this._conn.getRepository(IsLive);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetContinuityNumber ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<GetContinuityNumber>): Promise<GetContinuityNumber> {
-    const repo = this._conn.getRepository(GetContinuityNumber);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetSpawnCount ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<GetSpawnCount>): Promise<GetSpawnCount> {
-    const repo = this._conn.getRepository(GetSpawnCount);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveHasSponsor ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<HasSponsor>): Promise<HasSponsor> {
-    const repo = this._conn.getRepository(HasSponsor);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetSponsor ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<GetSponsor>): Promise<GetSponsor> {
-    const repo = this._conn.getRepository(GetSponsor);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveIsSponsor ({ blockHash, blockNumber, contractAddress, _point, _sponsor, value, proof }: DeepPartial<IsSponsor>): Promise<IsSponsor> {
-    const repo = this._conn.getRepository(IsSponsor);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, _sponsor, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetSponsoringCount ({ blockHash, blockNumber, contractAddress, _sponsor, value, proof }: DeepPartial<GetSponsoringCount>): Promise<GetSponsoringCount> {
-    const repo = this._conn.getRepository(GetSponsoringCount);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _sponsor, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveIsEscaping ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<IsEscaping>): Promise<IsEscaping> {
-    const repo = this._conn.getRepository(IsEscaping);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetEscapeRequest ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<GetEscapeRequest>): Promise<GetEscapeRequest> {
-    const repo = this._conn.getRepository(GetEscapeRequest);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveIsRequestingEscapeTo ({ blockHash, blockNumber, contractAddress, _point, _sponsor, value, proof }: DeepPartial<IsRequestingEscapeTo>): Promise<IsRequestingEscapeTo> {
-    const repo = this._conn.getRepository(IsRequestingEscapeTo);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, _sponsor, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetEscapeRequestsCount ({ blockHash, blockNumber, contractAddress, _sponsor, value, proof }: DeepPartial<GetEscapeRequestsCount>): Promise<GetEscapeRequestsCount> {
-    const repo = this._conn.getRepository(GetEscapeRequestsCount);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _sponsor, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetOwner ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<GetOwner>): Promise<GetOwner> {
-    const repo = this._conn.getRepository(GetOwner);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveIsOwner ({ blockHash, blockNumber, contractAddress, _point, _address, value, proof }: DeepPartial<IsOwner>): Promise<IsOwner> {
-    const repo = this._conn.getRepository(IsOwner);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, _address, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetOwnedPointCount ({ blockHash, blockNumber, contractAddress, _whose, value, proof }: DeepPartial<GetOwnedPointCount>): Promise<GetOwnedPointCount> {
-    const repo = this._conn.getRepository(GetOwnedPointCount);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _whose, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetOwnedPointAtIndex ({ blockHash, blockNumber, contractAddress, _whose, _index, value, proof }: DeepPartial<GetOwnedPointAtIndex>): Promise<GetOwnedPointAtIndex> {
-    const repo = this._conn.getRepository(GetOwnedPointAtIndex);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _whose, _index, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetManagementProxy ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<GetManagementProxy>): Promise<GetManagementProxy> {
-    const repo = this._conn.getRepository(GetManagementProxy);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveIsManagementProxy ({ blockHash, blockNumber, contractAddress, _point, _proxy, value, proof }: DeepPartial<IsManagementProxy>): Promise<IsManagementProxy> {
-    const repo = this._conn.getRepository(IsManagementProxy);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, _proxy, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveCanManage ({ blockHash, blockNumber, contractAddress, _point, _who, value, proof }: DeepPartial<CanManage>): Promise<CanManage> {
-    const repo = this._conn.getRepository(CanManage);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, _who, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetManagerForCount ({ blockHash, blockNumber, contractAddress, _proxy, value, proof }: DeepPartial<GetManagerForCount>): Promise<GetManagerForCount> {
-    const repo = this._conn.getRepository(GetManagerForCount);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _proxy, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetSpawnProxy ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<GetSpawnProxy>): Promise<GetSpawnProxy> {
-    const repo = this._conn.getRepository(GetSpawnProxy);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveIsSpawnProxy ({ blockHash, blockNumber, contractAddress, _point, _proxy, value, proof }: DeepPartial<IsSpawnProxy>): Promise<IsSpawnProxy> {
-    const repo = this._conn.getRepository(IsSpawnProxy);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, _proxy, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveCanSpawnAs ({ blockHash, blockNumber, contractAddress, _point, _who, value, proof }: DeepPartial<CanSpawnAs>): Promise<CanSpawnAs> {
-    const repo = this._conn.getRepository(CanSpawnAs);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, _who, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetSpawningForCount ({ blockHash, blockNumber, contractAddress, _proxy, value, proof }: DeepPartial<GetSpawningForCount>): Promise<GetSpawningForCount> {
-    const repo = this._conn.getRepository(GetSpawningForCount);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _proxy, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetVotingProxy ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<GetVotingProxy>): Promise<GetVotingProxy> {
-    const repo = this._conn.getRepository(GetVotingProxy);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveIsVotingProxy ({ blockHash, blockNumber, contractAddress, _point, _proxy, value, proof }: DeepPartial<IsVotingProxy>): Promise<IsVotingProxy> {
-    const repo = this._conn.getRepository(IsVotingProxy);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, _proxy, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveCanVoteAs ({ blockHash, blockNumber, contractAddress, _point, _who, value, proof }: DeepPartial<CanVoteAs>): Promise<CanVoteAs> {
-    const repo = this._conn.getRepository(CanVoteAs);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, _who, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetVotingForCount ({ blockHash, blockNumber, contractAddress, _proxy, value, proof }: DeepPartial<GetVotingForCount>): Promise<GetVotingForCount> {
-    const repo = this._conn.getRepository(GetVotingForCount);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _proxy, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetTransferProxy ({ blockHash, blockNumber, contractAddress, _point, value, proof }: DeepPartial<GetTransferProxy>): Promise<GetTransferProxy> {
-    const repo = this._conn.getRepository(GetTransferProxy);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveIsTransferProxy ({ blockHash, blockNumber, contractAddress, _point, _proxy, value, proof }: DeepPartial<IsTransferProxy>): Promise<IsTransferProxy> {
-    const repo = this._conn.getRepository(IsTransferProxy);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, _proxy, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveCanTransfer ({ blockHash, blockNumber, contractAddress, _point, _who, value, proof }: DeepPartial<CanTransfer>): Promise<CanTransfer> {
-    const repo = this._conn.getRepository(CanTransfer);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, _who, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetTransferringForCount ({ blockHash, blockNumber, contractAddress, _proxy, value, proof }: DeepPartial<GetTransferringForCount>): Promise<GetTransferringForCount> {
-    const repo = this._conn.getRepository(GetTransferringForCount);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _proxy, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveIsOperator ({ blockHash, blockNumber, contractAddress, _owner, _operator, value, proof }: DeepPartial<IsOperator>): Promise<IsOperator> {
-    const repo = this._conn.getRepository(IsOperator);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _owner, _operator, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetUpgradeProposalCount ({ blockHash, blockNumber, contractAddress, value, proof }: DeepPartial<GetUpgradeProposalCount>): Promise<GetUpgradeProposalCount> {
-    const repo = this._conn.getRepository(GetUpgradeProposalCount);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetDocumentProposalCount ({ blockHash, blockNumber, contractAddress, value, proof }: DeepPartial<GetDocumentProposalCount>): Promise<GetDocumentProposalCount> {
-    const repo = this._conn.getRepository(GetDocumentProposalCount);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveHasVotedOnUpgradePoll ({ blockHash, blockNumber, contractAddress, _galaxy, _proposal, value, proof }: DeepPartial<HasVotedOnUpgradePoll>): Promise<HasVotedOnUpgradePoll> {
-    const repo = this._conn.getRepository(HasVotedOnUpgradePoll);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _galaxy, _proposal, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveHasVotedOnDocumentPoll ({ blockHash, blockNumber, contractAddress, _galaxy, _proposal, value, proof }: DeepPartial<HasVotedOnDocumentPoll>): Promise<HasVotedOnDocumentPoll> {
-    const repo = this._conn.getRepository(HasVotedOnDocumentPoll);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _galaxy, _proposal, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveFindClaim ({ blockHash, blockNumber, contractAddress, _whose, _protocol, _claim, value, proof }: DeepPartial<FindClaim>): Promise<FindClaim> {
-    const repo = this._conn.getRepository(FindClaim);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _whose, _protocol, _claim, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveSupportsInterface ({ blockHash, blockNumber, contractAddress, _interfaceId, value, proof }: DeepPartial<SupportsInterface>): Promise<SupportsInterface> {
-    const repo = this._conn.getRepository(SupportsInterface);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _interfaceId, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveBalanceOf ({ blockHash, blockNumber, contractAddress, _owner, value, proof }: DeepPartial<BalanceOf>): Promise<BalanceOf> {
-    const repo = this._conn.getRepository(BalanceOf);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _owner, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveOwnerOf ({ blockHash, blockNumber, contractAddress, _tokenId, value, proof }: DeepPartial<OwnerOf>): Promise<OwnerOf> {
-    const repo = this._conn.getRepository(OwnerOf);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _tokenId, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveExists ({ blockHash, blockNumber, contractAddress, _tokenId, value, proof }: DeepPartial<Exists>): Promise<Exists> {
-    const repo = this._conn.getRepository(Exists);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _tokenId, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetApproved ({ blockHash, blockNumber, contractAddress, _tokenId, value, proof }: DeepPartial<GetApproved>): Promise<GetApproved> {
-    const repo = this._conn.getRepository(GetApproved);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _tokenId, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveIsApprovedForAll ({ blockHash, blockNumber, contractAddress, _owner, _operator, value, proof }: DeepPartial<IsApprovedForAll>): Promise<IsApprovedForAll> {
-    const repo = this._conn.getRepository(IsApprovedForAll);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _owner, _operator, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveTotalSupply ({ blockHash, blockNumber, contractAddress, value, proof }: DeepPartial<TotalSupply>): Promise<TotalSupply> {
-    const repo = this._conn.getRepository(TotalSupply);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveTokenOfOwnerByIndex ({ blockHash, blockNumber, contractAddress, _owner, _index, value, proof }: DeepPartial<TokenOfOwnerByIndex>): Promise<TokenOfOwnerByIndex> {
-    const repo = this._conn.getRepository(TokenOfOwnerByIndex);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _owner, _index, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveTokenByIndex ({ blockHash, blockNumber, contractAddress, _index, value, proof }: DeepPartial<TokenByIndex>): Promise<TokenByIndex> {
-    const repo = this._conn.getRepository(TokenByIndex);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _index, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveName ({ blockHash, blockNumber, contractAddress, value, proof }: DeepPartial<Name>): Promise<Name> {
-    const repo = this._conn.getRepository(Name);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, value, proof });
-    return repo.save(entity);
-  }
-
-  // eslint-disable-next-line @typescript-eslint/ban-types
-  async saveSymbol ({ blockHash, blockNumber, contractAddress, value, proof }: DeepPartial<Symbol>): Promise<Symbol> {
-    const repo = this._conn.getRepository(Symbol);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveTokenURI ({ blockHash, blockNumber, contractAddress, _tokenId, value, proof }: DeepPartial<TokenURI>): Promise<TokenURI> {
-    const repo = this._conn.getRepository(TokenURI);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _tokenId, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveGetSpawnLimit ({ blockHash, blockNumber, contractAddress, _point, _time, value, proof }: DeepPartial<GetSpawnLimit>): Promise<GetSpawnLimit> {
-    const repo = this._conn.getRepository(GetSpawnLimit);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, _time, value, proof });
-    return repo.save(entity);
-  }
-
-  async saveCanEscapeTo ({ blockHash, blockNumber, contractAddress, _point, _sponsor, value, proof }: DeepPartial<CanEscapeTo>): Promise<CanEscapeTo> {
-    const repo = this._conn.getRepository(CanEscapeTo);
-    const entity = repo.create({ blockHash, blockNumber, contractAddress, _point, _sponsor, value, proof });
-    return repo.save(entity);
-  }
-
   async saveWithdrawLimit ({ blockHash, blockNumber, contractAddress, _participant, _batch, value, proof }: DeepPartial<WithdrawLimit>): Promise<WithdrawLimit> {
     const repo = this._conn.getRepository(WithdrawLimit);
     const entity = repo.create({ blockHash, blockNumber, contractAddress, _participant, _batch, value, proof });
@@ -1241,61 +343,6 @@ export class Database implements DatabaseInterface {
   }
 
   _setPropColMaps (): void {
-    this._propColMaps.IsActive = this._getPropertyColumnMapForEntity('IsActive');
-    this._propColMaps.GetKeys = this._getPropertyColumnMapForEntity('GetKeys');
-    this._propColMaps.GetKeyRevisionNumber = this._getPropertyColumnMapForEntity('GetKeyRevisionNumber');
-    this._propColMaps.HasBeenLinked = this._getPropertyColumnMapForEntity('HasBeenLinked');
-    this._propColMaps.IsLive = this._getPropertyColumnMapForEntity('IsLive');
-    this._propColMaps.GetContinuityNumber = this._getPropertyColumnMapForEntity('GetContinuityNumber');
-    this._propColMaps.GetSpawnCount = this._getPropertyColumnMapForEntity('GetSpawnCount');
-    this._propColMaps.HasSponsor = this._getPropertyColumnMapForEntity('HasSponsor');
-    this._propColMaps.GetSponsor = this._getPropertyColumnMapForEntity('GetSponsor');
-    this._propColMaps.IsSponsor = this._getPropertyColumnMapForEntity('IsSponsor');
-    this._propColMaps.GetSponsoringCount = this._getPropertyColumnMapForEntity('GetSponsoringCount');
-    this._propColMaps.IsEscaping = this._getPropertyColumnMapForEntity('IsEscaping');
-    this._propColMaps.GetEscapeRequest = this._getPropertyColumnMapForEntity('GetEscapeRequest');
-    this._propColMaps.IsRequestingEscapeTo = this._getPropertyColumnMapForEntity('IsRequestingEscapeTo');
-    this._propColMaps.GetEscapeRequestsCount = this._getPropertyColumnMapForEntity('GetEscapeRequestsCount');
-    this._propColMaps.GetOwner = this._getPropertyColumnMapForEntity('GetOwner');
-    this._propColMaps.IsOwner = this._getPropertyColumnMapForEntity('IsOwner');
-    this._propColMaps.GetOwnedPointCount = this._getPropertyColumnMapForEntity('GetOwnedPointCount');
-    this._propColMaps.GetOwnedPointAtIndex = this._getPropertyColumnMapForEntity('GetOwnedPointAtIndex');
-    this._propColMaps.GetManagementProxy = this._getPropertyColumnMapForEntity('GetManagementProxy');
-    this._propColMaps.IsManagementProxy = this._getPropertyColumnMapForEntity('IsManagementProxy');
-    this._propColMaps.CanManage = this._getPropertyColumnMapForEntity('CanManage');
-    this._propColMaps.GetManagerForCount = this._getPropertyColumnMapForEntity('GetManagerForCount');
-    this._propColMaps.GetSpawnProxy = this._getPropertyColumnMapForEntity('GetSpawnProxy');
-    this._propColMaps.IsSpawnProxy = this._getPropertyColumnMapForEntity('IsSpawnProxy');
-    this._propColMaps.CanSpawnAs = this._getPropertyColumnMapForEntity('CanSpawnAs');
-    this._propColMaps.GetSpawningForCount = this._getPropertyColumnMapForEntity('GetSpawningForCount');
-    this._propColMaps.GetVotingProxy = this._getPropertyColumnMapForEntity('GetVotingProxy');
-    this._propColMaps.IsVotingProxy = this._getPropertyColumnMapForEntity('IsVotingProxy');
-    this._propColMaps.CanVoteAs = this._getPropertyColumnMapForEntity('CanVoteAs');
-    this._propColMaps.GetVotingForCount = this._getPropertyColumnMapForEntity('GetVotingForCount');
-    this._propColMaps.GetTransferProxy = this._getPropertyColumnMapForEntity('GetTransferProxy');
-    this._propColMaps.IsTransferProxy = this._getPropertyColumnMapForEntity('IsTransferProxy');
-    this._propColMaps.CanTransfer = this._getPropertyColumnMapForEntity('CanTransfer');
-    this._propColMaps.GetTransferringForCount = this._getPropertyColumnMapForEntity('GetTransferringForCount');
-    this._propColMaps.IsOperator = this._getPropertyColumnMapForEntity('IsOperator');
-    this._propColMaps.GetUpgradeProposalCount = this._getPropertyColumnMapForEntity('GetUpgradeProposalCount');
-    this._propColMaps.GetDocumentProposalCount = this._getPropertyColumnMapForEntity('GetDocumentProposalCount');
-    this._propColMaps.HasVotedOnUpgradePoll = this._getPropertyColumnMapForEntity('HasVotedOnUpgradePoll');
-    this._propColMaps.HasVotedOnDocumentPoll = this._getPropertyColumnMapForEntity('HasVotedOnDocumentPoll');
-    this._propColMaps.FindClaim = this._getPropertyColumnMapForEntity('FindClaim');
-    this._propColMaps.SupportsInterface = this._getPropertyColumnMapForEntity('SupportsInterface');
-    this._propColMaps.BalanceOf = this._getPropertyColumnMapForEntity('BalanceOf');
-    this._propColMaps.OwnerOf = this._getPropertyColumnMapForEntity('OwnerOf');
-    this._propColMaps.Exists = this._getPropertyColumnMapForEntity('Exists');
-    this._propColMaps.GetApproved = this._getPropertyColumnMapForEntity('GetApproved');
-    this._propColMaps.IsApprovedForAll = this._getPropertyColumnMapForEntity('IsApprovedForAll');
-    this._propColMaps.TotalSupply = this._getPropertyColumnMapForEntity('TotalSupply');
-    this._propColMaps.TokenOfOwnerByIndex = this._getPropertyColumnMapForEntity('TokenOfOwnerByIndex');
-    this._propColMaps.TokenByIndex = this._getPropertyColumnMapForEntity('TokenByIndex');
-    this._propColMaps.Name = this._getPropertyColumnMapForEntity('Name');
-    this._propColMaps.Symbol = this._getPropertyColumnMapForEntity('Symbol');
-    this._propColMaps.TokenURI = this._getPropertyColumnMapForEntity('TokenURI');
-    this._propColMaps.GetSpawnLimit = this._getPropertyColumnMapForEntity('GetSpawnLimit');
-    this._propColMaps.CanEscapeTo = this._getPropertyColumnMapForEntity('CanEscapeTo');
     this._propColMaps.WithdrawLimit = this._getPropertyColumnMapForEntity('WithdrawLimit');
     this._propColMaps.VerifyBalance = this._getPropertyColumnMapForEntity('VerifyBalance');
     this._propColMaps.GetBatch = this._getPropertyColumnMapForEntity('GetBatch');
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/balanceOf.gql b/packages/conditional-star-release-watcher/src/gql/queries/balanceOf.gql
deleted file mode 100644
index 246d366..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/balanceOf.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query balanceOf($blockHash: String!, $contractAddress: String!, $_owner: String!){
-    balanceOf(blockHash: $blockHash, contractAddress: $contractAddress, _owner: $_owner){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/canEscapeTo.gql b/packages/conditional-star-release-watcher/src/gql/queries/canEscapeTo.gql
deleted file mode 100644
index 54e9c5a..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/canEscapeTo.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query canEscapeTo($blockHash: String!, $contractAddress: String!, $_point: BigInt!, $_sponsor: BigInt!){
-    canEscapeTo(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point, _sponsor: $_sponsor){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/canManage.gql b/packages/conditional-star-release-watcher/src/gql/queries/canManage.gql
deleted file mode 100644
index dad1626..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/canManage.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query canManage($blockHash: String!, $contractAddress: String!, $_point: BigInt!, $_who: String!){
-    canManage(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point, _who: $_who){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/canSpawnAs.gql b/packages/conditional-star-release-watcher/src/gql/queries/canSpawnAs.gql
deleted file mode 100644
index 040dd32..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/canSpawnAs.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query canSpawnAs($blockHash: String!, $contractAddress: String!, $_point: BigInt!, $_who: String!){
-    canSpawnAs(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point, _who: $_who){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/canTransfer.gql b/packages/conditional-star-release-watcher/src/gql/queries/canTransfer.gql
deleted file mode 100644
index 994578f..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/canTransfer.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query canTransfer($blockHash: String!, $contractAddress: String!, $_point: BigInt!, $_who: String!){
-    canTransfer(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point, _who: $_who){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/canVoteAs.gql b/packages/conditional-star-release-watcher/src/gql/queries/canVoteAs.gql
deleted file mode 100644
index 87871a2..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/canVoteAs.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query canVoteAs($blockHash: String!, $contractAddress: String!, $_point: BigInt!, $_who: String!){
-    canVoteAs(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point, _who: $_who){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/exists.gql b/packages/conditional-star-release-watcher/src/gql/queries/exists.gql
deleted file mode 100644
index d01fa34..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/exists.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query exists($blockHash: String!, $contractAddress: String!, $_tokenId: BigInt!){
-    exists(blockHash: $blockHash, contractAddress: $contractAddress, _tokenId: $_tokenId){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/findClaim.gql b/packages/conditional-star-release-watcher/src/gql/queries/findClaim.gql
deleted file mode 100644
index 2d6efb4..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/findClaim.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query findClaim($blockHash: String!, $contractAddress: String!, $_whose: BigInt!, $_protocol: String!, $_claim: String!){
-    findClaim(blockHash: $blockHash, contractAddress: $contractAddress, _whose: $_whose, _protocol: $_protocol, _claim: $_claim){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getApproved.gql b/packages/conditional-star-release-watcher/src/gql/queries/getApproved.gql
deleted file mode 100644
index 10d4bae..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getApproved.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getApproved($blockHash: String!, $contractAddress: String!, $_tokenId: BigInt!){
-    getApproved(blockHash: $blockHash, contractAddress: $contractAddress, _tokenId: $_tokenId){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getContinuityNumber.gql b/packages/conditional-star-release-watcher/src/gql/queries/getContinuityNumber.gql
deleted file mode 100644
index 244398d..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getContinuityNumber.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getContinuityNumber($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    getContinuityNumber(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getDocumentMajorities.gql b/packages/conditional-star-release-watcher/src/gql/queries/getDocumentMajorities.gql
deleted file mode 100644
index 89fd856..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getDocumentMajorities.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getDocumentMajorities($blockHash: String!, $contractAddress: String!){
-    getDocumentMajorities(blockHash: $blockHash, contractAddress: $contractAddress){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getDocumentProposalCount.gql b/packages/conditional-star-release-watcher/src/gql/queries/getDocumentProposalCount.gql
deleted file mode 100644
index 225d59f..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getDocumentProposalCount.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getDocumentProposalCount($blockHash: String!, $contractAddress: String!){
-    getDocumentProposalCount(blockHash: $blockHash, contractAddress: $contractAddress){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getDocumentProposals.gql b/packages/conditional-star-release-watcher/src/gql/queries/getDocumentProposals.gql
deleted file mode 100644
index 75b30c2..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getDocumentProposals.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getDocumentProposals($blockHash: String!, $contractAddress: String!){
-    getDocumentProposals(blockHash: $blockHash, contractAddress: $contractAddress){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getEscapeRequest.gql b/packages/conditional-star-release-watcher/src/gql/queries/getEscapeRequest.gql
deleted file mode 100644
index 7215f8b..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getEscapeRequest.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getEscapeRequest($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    getEscapeRequest(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getEscapeRequests.gql b/packages/conditional-star-release-watcher/src/gql/queries/getEscapeRequests.gql
deleted file mode 100644
index 13b81ac..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getEscapeRequests.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getEscapeRequests($blockHash: String!, $contractAddress: String!, $_sponsor: BigInt!){
-    getEscapeRequests(blockHash: $blockHash, contractAddress: $contractAddress, _sponsor: $_sponsor){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getEscapeRequestsCount.gql b/packages/conditional-star-release-watcher/src/gql/queries/getEscapeRequestsCount.gql
deleted file mode 100644
index ca7f8ef..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getEscapeRequestsCount.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getEscapeRequestsCount($blockHash: String!, $contractAddress: String!, $_sponsor: BigInt!){
-    getEscapeRequestsCount(blockHash: $blockHash, contractAddress: $contractAddress, _sponsor: $_sponsor){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getKeyRevisionNumber.gql b/packages/conditional-star-release-watcher/src/gql/queries/getKeyRevisionNumber.gql
deleted file mode 100644
index fdccc8b..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getKeyRevisionNumber.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getKeyRevisionNumber($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    getKeyRevisionNumber(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getKeys.gql b/packages/conditional-star-release-watcher/src/gql/queries/getKeys.gql
deleted file mode 100644
index 8c8a5b6..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getKeys.gql
+++ /dev/null
@@ -1,13 +0,0 @@
-query getKeys($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    getKeys(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value{
-            value0
-            value1
-            value2
-            value3
-        }
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getManagementProxy.gql b/packages/conditional-star-release-watcher/src/gql/queries/getManagementProxy.gql
deleted file mode 100644
index a9be364..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getManagementProxy.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getManagementProxy($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    getManagementProxy(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getManagerFor.gql b/packages/conditional-star-release-watcher/src/gql/queries/getManagerFor.gql
deleted file mode 100644
index 12e6ca0..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getManagerFor.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getManagerFor($blockHash: String!, $contractAddress: String!, $_proxy: String!){
-    getManagerFor(blockHash: $blockHash, contractAddress: $contractAddress, _proxy: $_proxy){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getManagerForCount.gql b/packages/conditional-star-release-watcher/src/gql/queries/getManagerForCount.gql
deleted file mode 100644
index afc9de7..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getManagerForCount.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getManagerForCount($blockHash: String!, $contractAddress: String!, $_proxy: String!){
-    getManagerForCount(blockHash: $blockHash, contractAddress: $contractAddress, _proxy: $_proxy){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getOwnedPointAtIndex.gql b/packages/conditional-star-release-watcher/src/gql/queries/getOwnedPointAtIndex.gql
deleted file mode 100644
index 0d3d02c..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getOwnedPointAtIndex.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getOwnedPointAtIndex($blockHash: String!, $contractAddress: String!, $_whose: String!, $_index: BigInt!){
-    getOwnedPointAtIndex(blockHash: $blockHash, contractAddress: $contractAddress, _whose: $_whose, _index: $_index){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getOwnedPointCount.gql b/packages/conditional-star-release-watcher/src/gql/queries/getOwnedPointCount.gql
deleted file mode 100644
index f506e9e..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getOwnedPointCount.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getOwnedPointCount($blockHash: String!, $contractAddress: String!, $_whose: String!){
-    getOwnedPointCount(blockHash: $blockHash, contractAddress: $contractAddress, _whose: $_whose){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getOwnedPoints.gql b/packages/conditional-star-release-watcher/src/gql/queries/getOwnedPoints.gql
deleted file mode 100644
index 869ed24..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getOwnedPoints.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getOwnedPoints($blockHash: String!, $contractAddress: String!, $_whose: String!){
-    getOwnedPoints(blockHash: $blockHash, contractAddress: $contractAddress, _whose: $_whose){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getOwner.gql b/packages/conditional-star-release-watcher/src/gql/queries/getOwner.gql
deleted file mode 100644
index cc665d0..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getOwner.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getOwner($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    getOwner(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getSpawnCount.gql b/packages/conditional-star-release-watcher/src/gql/queries/getSpawnCount.gql
deleted file mode 100644
index f990551..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getSpawnCount.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getSpawnCount($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    getSpawnCount(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getSpawnLimit.gql b/packages/conditional-star-release-watcher/src/gql/queries/getSpawnLimit.gql
deleted file mode 100644
index fe0174c..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getSpawnLimit.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getSpawnLimit($blockHash: String!, $contractAddress: String!, $_point: BigInt!, $_time: BigInt!){
-    getSpawnLimit(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point, _time: $_time){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getSpawnProxy.gql b/packages/conditional-star-release-watcher/src/gql/queries/getSpawnProxy.gql
deleted file mode 100644
index f542279..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getSpawnProxy.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getSpawnProxy($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    getSpawnProxy(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getSpawned.gql b/packages/conditional-star-release-watcher/src/gql/queries/getSpawned.gql
deleted file mode 100644
index ab9ea11..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getSpawned.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getSpawned($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    getSpawned(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getSpawningFor.gql b/packages/conditional-star-release-watcher/src/gql/queries/getSpawningFor.gql
deleted file mode 100644
index 5059aa6..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getSpawningFor.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getSpawningFor($blockHash: String!, $contractAddress: String!, $_proxy: String!){
-    getSpawningFor(blockHash: $blockHash, contractAddress: $contractAddress, _proxy: $_proxy){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getSpawningForCount.gql b/packages/conditional-star-release-watcher/src/gql/queries/getSpawningForCount.gql
deleted file mode 100644
index df6f040..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getSpawningForCount.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getSpawningForCount($blockHash: String!, $contractAddress: String!, $_proxy: String!){
-    getSpawningForCount(blockHash: $blockHash, contractAddress: $contractAddress, _proxy: $_proxy){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getSponsor.gql b/packages/conditional-star-release-watcher/src/gql/queries/getSponsor.gql
deleted file mode 100644
index 56a5305..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getSponsor.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getSponsor($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    getSponsor(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getSponsoring.gql b/packages/conditional-star-release-watcher/src/gql/queries/getSponsoring.gql
deleted file mode 100644
index cb6a4b4..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getSponsoring.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getSponsoring($blockHash: String!, $contractAddress: String!, $_sponsor: BigInt!){
-    getSponsoring(blockHash: $blockHash, contractAddress: $contractAddress, _sponsor: $_sponsor){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getSponsoringCount.gql b/packages/conditional-star-release-watcher/src/gql/queries/getSponsoringCount.gql
deleted file mode 100644
index ee62745..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getSponsoringCount.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getSponsoringCount($blockHash: String!, $contractAddress: String!, $_sponsor: BigInt!){
-    getSponsoringCount(blockHash: $blockHash, contractAddress: $contractAddress, _sponsor: $_sponsor){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getTransferProxy.gql b/packages/conditional-star-release-watcher/src/gql/queries/getTransferProxy.gql
deleted file mode 100644
index c14c0ab..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getTransferProxy.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getTransferProxy($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    getTransferProxy(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getTransferringFor.gql b/packages/conditional-star-release-watcher/src/gql/queries/getTransferringFor.gql
deleted file mode 100644
index 0911c39..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getTransferringFor.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getTransferringFor($blockHash: String!, $contractAddress: String!, $_proxy: String!){
-    getTransferringFor(blockHash: $blockHash, contractAddress: $contractAddress, _proxy: $_proxy){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getTransferringForCount.gql b/packages/conditional-star-release-watcher/src/gql/queries/getTransferringForCount.gql
deleted file mode 100644
index b3245eb..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getTransferringForCount.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getTransferringForCount($blockHash: String!, $contractAddress: String!, $_proxy: String!){
-    getTransferringForCount(blockHash: $blockHash, contractAddress: $contractAddress, _proxy: $_proxy){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getUpgradeProposalCount.gql b/packages/conditional-star-release-watcher/src/gql/queries/getUpgradeProposalCount.gql
deleted file mode 100644
index 33dd2f6..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getUpgradeProposalCount.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getUpgradeProposalCount($blockHash: String!, $contractAddress: String!){
-    getUpgradeProposalCount(blockHash: $blockHash, contractAddress: $contractAddress){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getUpgradeProposals.gql b/packages/conditional-star-release-watcher/src/gql/queries/getUpgradeProposals.gql
deleted file mode 100644
index 4cb89ce..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getUpgradeProposals.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getUpgradeProposals($blockHash: String!, $contractAddress: String!){
-    getUpgradeProposals(blockHash: $blockHash, contractAddress: $contractAddress){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getVotingFor.gql b/packages/conditional-star-release-watcher/src/gql/queries/getVotingFor.gql
deleted file mode 100644
index 30186d8..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getVotingFor.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getVotingFor($blockHash: String!, $contractAddress: String!, $_proxy: String!){
-    getVotingFor(blockHash: $blockHash, contractAddress: $contractAddress, _proxy: $_proxy){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getVotingForCount.gql b/packages/conditional-star-release-watcher/src/gql/queries/getVotingForCount.gql
deleted file mode 100644
index 6f7e1e0..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getVotingForCount.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getVotingForCount($blockHash: String!, $contractAddress: String!, $_proxy: String!){
-    getVotingForCount(blockHash: $blockHash, contractAddress: $contractAddress, _proxy: $_proxy){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/getVotingProxy.gql b/packages/conditional-star-release-watcher/src/gql/queries/getVotingProxy.gql
deleted file mode 100644
index 49d37ab..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/getVotingProxy.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query getVotingProxy($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    getVotingProxy(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/hasBeenLinked.gql b/packages/conditional-star-release-watcher/src/gql/queries/hasBeenLinked.gql
deleted file mode 100644
index a50505c..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/hasBeenLinked.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query hasBeenLinked($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    hasBeenLinked(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/hasSponsor.gql b/packages/conditional-star-release-watcher/src/gql/queries/hasSponsor.gql
deleted file mode 100644
index 0261c6e..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/hasSponsor.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query hasSponsor($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    hasSponsor(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/hasVotedOnDocumentPoll.gql b/packages/conditional-star-release-watcher/src/gql/queries/hasVotedOnDocumentPoll.gql
deleted file mode 100644
index 55c6eac..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/hasVotedOnDocumentPoll.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query hasVotedOnDocumentPoll($blockHash: String!, $contractAddress: String!, $_galaxy: Int!, $_proposal: String!){
-    hasVotedOnDocumentPoll(blockHash: $blockHash, contractAddress: $contractAddress, _galaxy: $_galaxy, _proposal: $_proposal){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/hasVotedOnUpgradePoll.gql b/packages/conditional-star-release-watcher/src/gql/queries/hasVotedOnUpgradePoll.gql
deleted file mode 100644
index 7c30daa..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/hasVotedOnUpgradePoll.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query hasVotedOnUpgradePoll($blockHash: String!, $contractAddress: String!, $_galaxy: Int!, $_proposal: String!){
-    hasVotedOnUpgradePoll(blockHash: $blockHash, contractAddress: $contractAddress, _galaxy: $_galaxy, _proposal: $_proposal){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/index.ts b/packages/conditional-star-release-watcher/src/gql/queries/index.ts
index 4f7b041..cd3c03e 100644
--- a/packages/conditional-star-release-watcher/src/gql/queries/index.ts
+++ b/packages/conditional-star-release-watcher/src/gql/queries/index.ts
@@ -3,72 +3,6 @@ import path from 'path';
 
 export const events = fs.readFileSync(path.join(__dirname, 'events.gql'), 'utf8');
 export const eventsInRange = fs.readFileSync(path.join(__dirname, 'eventsInRange.gql'), 'utf8');
-export const isActive = fs.readFileSync(path.join(__dirname, 'isActive.gql'), 'utf8');
-export const getKeys = fs.readFileSync(path.join(__dirname, 'getKeys.gql'), 'utf8');
-export const getKeyRevisionNumber = fs.readFileSync(path.join(__dirname, 'getKeyRevisionNumber.gql'), 'utf8');
-export const hasBeenLinked = fs.readFileSync(path.join(__dirname, 'hasBeenLinked.gql'), 'utf8');
-export const isLive = fs.readFileSync(path.join(__dirname, 'isLive.gql'), 'utf8');
-export const getContinuityNumber = fs.readFileSync(path.join(__dirname, 'getContinuityNumber.gql'), 'utf8');
-export const getSpawnCount = fs.readFileSync(path.join(__dirname, 'getSpawnCount.gql'), 'utf8');
-export const getSpawned = fs.readFileSync(path.join(__dirname, 'getSpawned.gql'), 'utf8');
-export const hasSponsor = fs.readFileSync(path.join(__dirname, 'hasSponsor.gql'), 'utf8');
-export const getSponsor = fs.readFileSync(path.join(__dirname, 'getSponsor.gql'), 'utf8');
-export const isSponsor = fs.readFileSync(path.join(__dirname, 'isSponsor.gql'), 'utf8');
-export const getSponsoringCount = fs.readFileSync(path.join(__dirname, 'getSponsoringCount.gql'), 'utf8');
-export const getSponsoring = fs.readFileSync(path.join(__dirname, 'getSponsoring.gql'), 'utf8');
-export const isEscaping = fs.readFileSync(path.join(__dirname, 'isEscaping.gql'), 'utf8');
-export const getEscapeRequest = fs.readFileSync(path.join(__dirname, 'getEscapeRequest.gql'), 'utf8');
-export const isRequestingEscapeTo = fs.readFileSync(path.join(__dirname, 'isRequestingEscapeTo.gql'), 'utf8');
-export const getEscapeRequestsCount = fs.readFileSync(path.join(__dirname, 'getEscapeRequestsCount.gql'), 'utf8');
-export const getEscapeRequests = fs.readFileSync(path.join(__dirname, 'getEscapeRequests.gql'), 'utf8');
-export const getOwner = fs.readFileSync(path.join(__dirname, 'getOwner.gql'), 'utf8');
-export const isOwner = fs.readFileSync(path.join(__dirname, 'isOwner.gql'), 'utf8');
-export const getOwnedPointCount = fs.readFileSync(path.join(__dirname, 'getOwnedPointCount.gql'), 'utf8');
-export const getOwnedPoints = fs.readFileSync(path.join(__dirname, 'getOwnedPoints.gql'), 'utf8');
-export const getOwnedPointAtIndex = fs.readFileSync(path.join(__dirname, 'getOwnedPointAtIndex.gql'), 'utf8');
-export const getManagementProxy = fs.readFileSync(path.join(__dirname, 'getManagementProxy.gql'), 'utf8');
-export const isManagementProxy = fs.readFileSync(path.join(__dirname, 'isManagementProxy.gql'), 'utf8');
-export const canManage = fs.readFileSync(path.join(__dirname, 'canManage.gql'), 'utf8');
-export const getManagerForCount = fs.readFileSync(path.join(__dirname, 'getManagerForCount.gql'), 'utf8');
-export const getManagerFor = fs.readFileSync(path.join(__dirname, 'getManagerFor.gql'), 'utf8');
-export const getSpawnProxy = fs.readFileSync(path.join(__dirname, 'getSpawnProxy.gql'), 'utf8');
-export const isSpawnProxy = fs.readFileSync(path.join(__dirname, 'isSpawnProxy.gql'), 'utf8');
-export const canSpawnAs = fs.readFileSync(path.join(__dirname, 'canSpawnAs.gql'), 'utf8');
-export const getSpawningForCount = fs.readFileSync(path.join(__dirname, 'getSpawningForCount.gql'), 'utf8');
-export const getSpawningFor = fs.readFileSync(path.join(__dirname, 'getSpawningFor.gql'), 'utf8');
-export const getVotingProxy = fs.readFileSync(path.join(__dirname, 'getVotingProxy.gql'), 'utf8');
-export const isVotingProxy = fs.readFileSync(path.join(__dirname, 'isVotingProxy.gql'), 'utf8');
-export const canVoteAs = fs.readFileSync(path.join(__dirname, 'canVoteAs.gql'), 'utf8');
-export const getVotingForCount = fs.readFileSync(path.join(__dirname, 'getVotingForCount.gql'), 'utf8');
-export const getVotingFor = fs.readFileSync(path.join(__dirname, 'getVotingFor.gql'), 'utf8');
-export const getTransferProxy = fs.readFileSync(path.join(__dirname, 'getTransferProxy.gql'), 'utf8');
-export const isTransferProxy = fs.readFileSync(path.join(__dirname, 'isTransferProxy.gql'), 'utf8');
-export const canTransfer = fs.readFileSync(path.join(__dirname, 'canTransfer.gql'), 'utf8');
-export const getTransferringForCount = fs.readFileSync(path.join(__dirname, 'getTransferringForCount.gql'), 'utf8');
-export const getTransferringFor = fs.readFileSync(path.join(__dirname, 'getTransferringFor.gql'), 'utf8');
-export const isOperator = fs.readFileSync(path.join(__dirname, 'isOperator.gql'), 'utf8');
-export const getUpgradeProposals = fs.readFileSync(path.join(__dirname, 'getUpgradeProposals.gql'), 'utf8');
-export const getUpgradeProposalCount = fs.readFileSync(path.join(__dirname, 'getUpgradeProposalCount.gql'), 'utf8');
-export const getDocumentProposals = fs.readFileSync(path.join(__dirname, 'getDocumentProposals.gql'), 'utf8');
-export const getDocumentProposalCount = fs.readFileSync(path.join(__dirname, 'getDocumentProposalCount.gql'), 'utf8');
-export const getDocumentMajorities = fs.readFileSync(path.join(__dirname, 'getDocumentMajorities.gql'), 'utf8');
-export const hasVotedOnUpgradePoll = fs.readFileSync(path.join(__dirname, 'hasVotedOnUpgradePoll.gql'), 'utf8');
-export const hasVotedOnDocumentPoll = fs.readFileSync(path.join(__dirname, 'hasVotedOnDocumentPoll.gql'), 'utf8');
-export const findClaim = fs.readFileSync(path.join(__dirname, 'findClaim.gql'), 'utf8');
-export const supportsInterface = fs.readFileSync(path.join(__dirname, 'supportsInterface.gql'), 'utf8');
-export const balanceOf = fs.readFileSync(path.join(__dirname, 'balanceOf.gql'), 'utf8');
-export const ownerOf = fs.readFileSync(path.join(__dirname, 'ownerOf.gql'), 'utf8');
-export const exists = fs.readFileSync(path.join(__dirname, 'exists.gql'), 'utf8');
-export const getApproved = fs.readFileSync(path.join(__dirname, 'getApproved.gql'), 'utf8');
-export const isApprovedForAll = fs.readFileSync(path.join(__dirname, 'isApprovedForAll.gql'), 'utf8');
-export const totalSupply = fs.readFileSync(path.join(__dirname, 'totalSupply.gql'), 'utf8');
-export const tokenOfOwnerByIndex = fs.readFileSync(path.join(__dirname, 'tokenOfOwnerByIndex.gql'), 'utf8');
-export const tokenByIndex = fs.readFileSync(path.join(__dirname, 'tokenByIndex.gql'), 'utf8');
-export const name = fs.readFileSync(path.join(__dirname, 'name.gql'), 'utf8');
-export const symbol = fs.readFileSync(path.join(__dirname, 'symbol.gql'), 'utf8');
-export const tokenURI = fs.readFileSync(path.join(__dirname, 'tokenURI.gql'), 'utf8');
-export const getSpawnLimit = fs.readFileSync(path.join(__dirname, 'getSpawnLimit.gql'), 'utf8');
-export const canEscapeTo = fs.readFileSync(path.join(__dirname, 'canEscapeTo.gql'), 'utf8');
 export const withdrawLimit = fs.readFileSync(path.join(__dirname, 'withdrawLimit.gql'), 'utf8');
 export const verifyBalance = fs.readFileSync(path.join(__dirname, 'verifyBalance.gql'), 'utf8');
 export const getBatches = fs.readFileSync(path.join(__dirname, 'getBatches.gql'), 'utf8');
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/isActive.gql b/packages/conditional-star-release-watcher/src/gql/queries/isActive.gql
deleted file mode 100644
index 74bc87f..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/isActive.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query isActive($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    isActive(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/isApprovedForAll.gql b/packages/conditional-star-release-watcher/src/gql/queries/isApprovedForAll.gql
deleted file mode 100644
index d080750..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/isApprovedForAll.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query isApprovedForAll($blockHash: String!, $contractAddress: String!, $_owner: String!, $_operator: String!){
-    isApprovedForAll(blockHash: $blockHash, contractAddress: $contractAddress, _owner: $_owner, _operator: $_operator){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/isEscaping.gql b/packages/conditional-star-release-watcher/src/gql/queries/isEscaping.gql
deleted file mode 100644
index 4ed499f..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/isEscaping.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query isEscaping($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    isEscaping(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/isLive.gql b/packages/conditional-star-release-watcher/src/gql/queries/isLive.gql
deleted file mode 100644
index 78a61fd..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/isLive.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query isLive($blockHash: String!, $contractAddress: String!, $_point: BigInt!){
-    isLive(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/isManagementProxy.gql b/packages/conditional-star-release-watcher/src/gql/queries/isManagementProxy.gql
deleted file mode 100644
index 64b7656..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/isManagementProxy.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query isManagementProxy($blockHash: String!, $contractAddress: String!, $_point: BigInt!, $_proxy: String!){
-    isManagementProxy(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point, _proxy: $_proxy){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/isOperator.gql b/packages/conditional-star-release-watcher/src/gql/queries/isOperator.gql
deleted file mode 100644
index c67f1e2..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/isOperator.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query isOperator($blockHash: String!, $contractAddress: String!, $_owner: String!, $_operator: String!){
-    isOperator(blockHash: $blockHash, contractAddress: $contractAddress, _owner: $_owner, _operator: $_operator){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/isOwner.gql b/packages/conditional-star-release-watcher/src/gql/queries/isOwner.gql
deleted file mode 100644
index 9378225..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/isOwner.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query isOwner($blockHash: String!, $contractAddress: String!, $_point: BigInt!, $_address: String!){
-    isOwner(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point, _address: $_address){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/isRequestingEscapeTo.gql b/packages/conditional-star-release-watcher/src/gql/queries/isRequestingEscapeTo.gql
deleted file mode 100644
index f1c9afb..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/isRequestingEscapeTo.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query isRequestingEscapeTo($blockHash: String!, $contractAddress: String!, $_point: BigInt!, $_sponsor: BigInt!){
-    isRequestingEscapeTo(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point, _sponsor: $_sponsor){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/isSpawnProxy.gql b/packages/conditional-star-release-watcher/src/gql/queries/isSpawnProxy.gql
deleted file mode 100644
index 2223af6..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/isSpawnProxy.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query isSpawnProxy($blockHash: String!, $contractAddress: String!, $_point: BigInt!, $_proxy: String!){
-    isSpawnProxy(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point, _proxy: $_proxy){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/isSponsor.gql b/packages/conditional-star-release-watcher/src/gql/queries/isSponsor.gql
deleted file mode 100644
index 3e1b3cc..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/isSponsor.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query isSponsor($blockHash: String!, $contractAddress: String!, $_point: BigInt!, $_sponsor: BigInt!){
-    isSponsor(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point, _sponsor: $_sponsor){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/isTransferProxy.gql b/packages/conditional-star-release-watcher/src/gql/queries/isTransferProxy.gql
deleted file mode 100644
index feccdf0..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/isTransferProxy.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query isTransferProxy($blockHash: String!, $contractAddress: String!, $_point: BigInt!, $_proxy: String!){
-    isTransferProxy(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point, _proxy: $_proxy){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/isVotingProxy.gql b/packages/conditional-star-release-watcher/src/gql/queries/isVotingProxy.gql
deleted file mode 100644
index 3bf33c8..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/isVotingProxy.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query isVotingProxy($blockHash: String!, $contractAddress: String!, $_point: BigInt!, $_proxy: String!){
-    isVotingProxy(blockHash: $blockHash, contractAddress: $contractAddress, _point: $_point, _proxy: $_proxy){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/name.gql b/packages/conditional-star-release-watcher/src/gql/queries/name.gql
deleted file mode 100644
index 0431f0d..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/name.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query name($blockHash: String!, $contractAddress: String!){
-    name(blockHash: $blockHash, contractAddress: $contractAddress){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/ownerOf.gql b/packages/conditional-star-release-watcher/src/gql/queries/ownerOf.gql
deleted file mode 100644
index 56e0cd8..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/ownerOf.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query ownerOf($blockHash: String!, $contractAddress: String!, $_tokenId: BigInt!){
-    ownerOf(blockHash: $blockHash, contractAddress: $contractAddress, _tokenId: $_tokenId){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/supportsInterface.gql b/packages/conditional-star-release-watcher/src/gql/queries/supportsInterface.gql
deleted file mode 100644
index ab758a9..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/supportsInterface.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query supportsInterface($blockHash: String!, $contractAddress: String!, $_interfaceId: String!){
-    supportsInterface(blockHash: $blockHash, contractAddress: $contractAddress, _interfaceId: $_interfaceId){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/symbol.gql b/packages/conditional-star-release-watcher/src/gql/queries/symbol.gql
deleted file mode 100644
index fa278b8..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/symbol.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query symbol($blockHash: String!, $contractAddress: String!){
-    symbol(blockHash: $blockHash, contractAddress: $contractAddress){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/tokenByIndex.gql b/packages/conditional-star-release-watcher/src/gql/queries/tokenByIndex.gql
deleted file mode 100644
index e743dcd..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/tokenByIndex.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query tokenByIndex($blockHash: String!, $contractAddress: String!, $_index: BigInt!){
-    tokenByIndex(blockHash: $blockHash, contractAddress: $contractAddress, _index: $_index){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/tokenOfOwnerByIndex.gql b/packages/conditional-star-release-watcher/src/gql/queries/tokenOfOwnerByIndex.gql
deleted file mode 100644
index 27eda46..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/tokenOfOwnerByIndex.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query tokenOfOwnerByIndex($blockHash: String!, $contractAddress: String!, $_owner: String!, $_index: BigInt!){
-    tokenOfOwnerByIndex(blockHash: $blockHash, contractAddress: $contractAddress, _owner: $_owner, _index: $_index){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/tokenURI.gql b/packages/conditional-star-release-watcher/src/gql/queries/tokenURI.gql
deleted file mode 100644
index 28aa08c..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/tokenURI.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query tokenURI($blockHash: String!, $contractAddress: String!, $_tokenId: BigInt!){
-    tokenURI(blockHash: $blockHash, contractAddress: $contractAddress, _tokenId: $_tokenId){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/gql/queries/totalSupply.gql b/packages/conditional-star-release-watcher/src/gql/queries/totalSupply.gql
deleted file mode 100644
index d1be1e4..0000000
--- a/packages/conditional-star-release-watcher/src/gql/queries/totalSupply.gql
+++ /dev/null
@@ -1,8 +0,0 @@
-query totalSupply($blockHash: String!, $contractAddress: String!){
-    totalSupply(blockHash: $blockHash, contractAddress: $contractAddress){
-        value
-        proof{
-            data
-        }
-    }
-}
\ No newline at end of file
diff --git a/packages/conditional-star-release-watcher/src/indexer.ts b/packages/conditional-star-release-watcher/src/indexer.ts
index fbd4555..488e76c 100644
--- a/packages/conditional-star-release-watcher/src/indexer.ts
+++ b/packages/conditional-star-release-watcher/src/indexer.ts
@@ -93,1832 +93,6 @@ export class Indexer implements IndexerInterface {
     return getResultEvent(event);
   }
 
-  async isActive (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    const entity = await this._db.getIsActive({ blockHash, contractAddress, _point });
-    if (entity) {
-      log('isActive: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('isActive: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.isActive(_point, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveIsActive({ blockHash, blockNumber, contractAddress, _point, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getKeys (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    log('getKeys: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getKeys(_point, { blockTag: blockHash });
-
-    const value = {
-      value0: contractResult[0],
-      value1: contractResult[1],
-      value2: ethers.BigNumber.from(contractResult[2]).toBigInt(),
-      value3: ethers.BigNumber.from(contractResult[3]).toBigInt()
-    };
-
-    const result: ValueResult = { value };
-
-    return result;
-  }
-
-  async getKeyRevisionNumber (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    const entity = await this._db.getGetKeyRevisionNumber({ blockHash, contractAddress, _point });
-    if (entity) {
-      log('getKeyRevisionNumber: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getKeyRevisionNumber: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getKeyRevisionNumber(_point, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetKeyRevisionNumber({ blockHash, blockNumber, contractAddress, _point, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async hasBeenLinked (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    const entity = await this._db.getHasBeenLinked({ blockHash, contractAddress, _point });
-    if (entity) {
-      log('hasBeenLinked: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('hasBeenLinked: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.hasBeenLinked(_point, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveHasBeenLinked({ blockHash, blockNumber, contractAddress, _point, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async isLive (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    const entity = await this._db.getIsLive({ blockHash, contractAddress, _point });
-    if (entity) {
-      log('isLive: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('isLive: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.isLive(_point, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveIsLive({ blockHash, blockNumber, contractAddress, _point, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getContinuityNumber (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    const entity = await this._db.getGetContinuityNumber({ blockHash, contractAddress, _point });
-    if (entity) {
-      log('getContinuityNumber: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getContinuityNumber: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getContinuityNumber(_point, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetContinuityNumber({ blockHash, blockNumber, contractAddress, _point, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getSpawnCount (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    const entity = await this._db.getGetSpawnCount({ blockHash, contractAddress, _point });
-    if (entity) {
-      log('getSpawnCount: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getSpawnCount: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getSpawnCount(_point, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetSpawnCount({ blockHash, blockNumber, contractAddress, _point, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getSpawned (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    log('getSpawned: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getSpawned(_point, { blockTag: blockHash });
-
-    const value = contractResult.map((val: ethers.BigNumber | number) => ethers.BigNumber.from(val).toBigInt());
-    const result: ValueResult = { value };
-
-    return result;
-  }
-
-  async hasSponsor (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    const entity = await this._db.getHasSponsor({ blockHash, contractAddress, _point });
-    if (entity) {
-      log('hasSponsor: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('hasSponsor: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.hasSponsor(_point, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveHasSponsor({ blockHash, blockNumber, contractAddress, _point, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getSponsor (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    const entity = await this._db.getGetSponsor({ blockHash, contractAddress, _point });
-    if (entity) {
-      log('getSponsor: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getSponsor: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getSponsor(_point, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetSponsor({ blockHash, blockNumber, contractAddress, _point, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async isSponsor (blockHash: string, contractAddress: string, _point: bigint, _sponsor: bigint): Promise<ValueResult> {
-    const entity = await this._db.getIsSponsor({ blockHash, contractAddress, _point, _sponsor });
-    if (entity) {
-      log('isSponsor: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('isSponsor: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.isSponsor(_point, _sponsor, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveIsSponsor({ blockHash, blockNumber, contractAddress, _point, _sponsor, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getSponsoringCount (blockHash: string, contractAddress: string, _sponsor: bigint): Promise<ValueResult> {
-    const entity = await this._db.getGetSponsoringCount({ blockHash, contractAddress, _sponsor });
-    if (entity) {
-      log('getSponsoringCount: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getSponsoringCount: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getSponsoringCount(_sponsor, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetSponsoringCount({ blockHash, blockNumber, contractAddress, _sponsor, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getSponsoring (blockHash: string, contractAddress: string, _sponsor: bigint): Promise<ValueResult> {
-    log('getSponsoring: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getSponsoring(_sponsor, { blockTag: blockHash });
-
-    const value = contractResult.map((val: ethers.BigNumber | number) => ethers.BigNumber.from(val).toBigInt());
-    const result: ValueResult = { value };
-
-    return result;
-  }
-
-  async isEscaping (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    const entity = await this._db.getIsEscaping({ blockHash, contractAddress, _point });
-    if (entity) {
-      log('isEscaping: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('isEscaping: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.isEscaping(_point, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveIsEscaping({ blockHash, blockNumber, contractAddress, _point, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getEscapeRequest (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    const entity = await this._db.getGetEscapeRequest({ blockHash, contractAddress, _point });
-    if (entity) {
-      log('getEscapeRequest: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getEscapeRequest: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getEscapeRequest(_point, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetEscapeRequest({ blockHash, blockNumber, contractAddress, _point, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async isRequestingEscapeTo (blockHash: string, contractAddress: string, _point: bigint, _sponsor: bigint): Promise<ValueResult> {
-    const entity = await this._db.getIsRequestingEscapeTo({ blockHash, contractAddress, _point, _sponsor });
-    if (entity) {
-      log('isRequestingEscapeTo: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('isRequestingEscapeTo: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.isRequestingEscapeTo(_point, _sponsor, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveIsRequestingEscapeTo({ blockHash, blockNumber, contractAddress, _point, _sponsor, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getEscapeRequestsCount (blockHash: string, contractAddress: string, _sponsor: bigint): Promise<ValueResult> {
-    const entity = await this._db.getGetEscapeRequestsCount({ blockHash, contractAddress, _sponsor });
-    if (entity) {
-      log('getEscapeRequestsCount: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getEscapeRequestsCount: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getEscapeRequestsCount(_sponsor, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetEscapeRequestsCount({ blockHash, blockNumber, contractAddress, _sponsor, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getEscapeRequests (blockHash: string, contractAddress: string, _sponsor: bigint): Promise<ValueResult> {
-    log('getEscapeRequests: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getEscapeRequests(_sponsor, { blockTag: blockHash });
-
-    const value = contractResult.map((val: ethers.BigNumber | number) => ethers.BigNumber.from(val).toBigInt());
-    const result: ValueResult = { value };
-
-    return result;
-  }
-
-  async getOwner (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    const entity = await this._db.getGetOwner({ blockHash, contractAddress, _point });
-    if (entity) {
-      log('getOwner: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getOwner: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getOwner(_point, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveGetOwner({ blockHash, blockNumber, contractAddress, _point, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async isOwner (blockHash: string, contractAddress: string, _point: bigint, _address: string): Promise<ValueResult> {
-    const entity = await this._db.getIsOwner({ blockHash, contractAddress, _point, _address });
-    if (entity) {
-      log('isOwner: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('isOwner: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.isOwner(_point, _address, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveIsOwner({ blockHash, blockNumber, contractAddress, _point, _address, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getOwnedPointCount (blockHash: string, contractAddress: string, _whose: string): Promise<ValueResult> {
-    const entity = await this._db.getGetOwnedPointCount({ blockHash, contractAddress, _whose });
-    if (entity) {
-      log('getOwnedPointCount: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getOwnedPointCount: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getOwnedPointCount(_whose, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetOwnedPointCount({ blockHash, blockNumber, contractAddress, _whose, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getOwnedPoints (blockHash: string, contractAddress: string, _whose: string): Promise<ValueResult> {
-    log('getOwnedPoints: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getOwnedPoints(_whose, { blockTag: blockHash });
-
-    const value = contractResult.map((val: ethers.BigNumber | number) => ethers.BigNumber.from(val).toBigInt());
-    const result: ValueResult = { value };
-
-    return result;
-  }
-
-  async getOwnedPointAtIndex (blockHash: string, contractAddress: string, _whose: string, _index: bigint): Promise<ValueResult> {
-    const entity = await this._db.getGetOwnedPointAtIndex({ blockHash, contractAddress, _whose, _index });
-    if (entity) {
-      log('getOwnedPointAtIndex: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getOwnedPointAtIndex: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getOwnedPointAtIndex(_whose, _index, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetOwnedPointAtIndex({ blockHash, blockNumber, contractAddress, _whose, _index, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getManagementProxy (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    const entity = await this._db.getGetManagementProxy({ blockHash, contractAddress, _point });
-    if (entity) {
-      log('getManagementProxy: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getManagementProxy: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getManagementProxy(_point, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveGetManagementProxy({ blockHash, blockNumber, contractAddress, _point, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async isManagementProxy (blockHash: string, contractAddress: string, _point: bigint, _proxy: string): Promise<ValueResult> {
-    const entity = await this._db.getIsManagementProxy({ blockHash, contractAddress, _point, _proxy });
-    if (entity) {
-      log('isManagementProxy: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('isManagementProxy: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.isManagementProxy(_point, _proxy, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveIsManagementProxy({ blockHash, blockNumber, contractAddress, _point, _proxy, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async canManage (blockHash: string, contractAddress: string, _point: bigint, _who: string): Promise<ValueResult> {
-    const entity = await this._db.getCanManage({ blockHash, contractAddress, _point, _who });
-    if (entity) {
-      log('canManage: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('canManage: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.canManage(_point, _who, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveCanManage({ blockHash, blockNumber, contractAddress, _point, _who, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getManagerForCount (blockHash: string, contractAddress: string, _proxy: string): Promise<ValueResult> {
-    const entity = await this._db.getGetManagerForCount({ blockHash, contractAddress, _proxy });
-    if (entity) {
-      log('getManagerForCount: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getManagerForCount: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getManagerForCount(_proxy, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetManagerForCount({ blockHash, blockNumber, contractAddress, _proxy, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getManagerFor (blockHash: string, contractAddress: string, _proxy: string): Promise<ValueResult> {
-    log('getManagerFor: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getManagerFor(_proxy, { blockTag: blockHash });
-
-    const value = contractResult.map((val: ethers.BigNumber | number) => ethers.BigNumber.from(val).toBigInt());
-    const result: ValueResult = { value };
-
-    return result;
-  }
-
-  async getSpawnProxy (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    const entity = await this._db.getGetSpawnProxy({ blockHash, contractAddress, _point });
-    if (entity) {
-      log('getSpawnProxy: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getSpawnProxy: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getSpawnProxy(_point, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveGetSpawnProxy({ blockHash, blockNumber, contractAddress, _point, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async isSpawnProxy (blockHash: string, contractAddress: string, _point: bigint, _proxy: string): Promise<ValueResult> {
-    const entity = await this._db.getIsSpawnProxy({ blockHash, contractAddress, _point, _proxy });
-    if (entity) {
-      log('isSpawnProxy: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('isSpawnProxy: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.isSpawnProxy(_point, _proxy, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveIsSpawnProxy({ blockHash, blockNumber, contractAddress, _point, _proxy, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async canSpawnAs (blockHash: string, contractAddress: string, _point: bigint, _who: string): Promise<ValueResult> {
-    const entity = await this._db.getCanSpawnAs({ blockHash, contractAddress, _point, _who });
-    if (entity) {
-      log('canSpawnAs: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('canSpawnAs: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.canSpawnAs(_point, _who, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveCanSpawnAs({ blockHash, blockNumber, contractAddress, _point, _who, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getSpawningForCount (blockHash: string, contractAddress: string, _proxy: string): Promise<ValueResult> {
-    const entity = await this._db.getGetSpawningForCount({ blockHash, contractAddress, _proxy });
-    if (entity) {
-      log('getSpawningForCount: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getSpawningForCount: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getSpawningForCount(_proxy, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetSpawningForCount({ blockHash, blockNumber, contractAddress, _proxy, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getSpawningFor (blockHash: string, contractAddress: string, _proxy: string): Promise<ValueResult> {
-    log('getSpawningFor: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getSpawningFor(_proxy, { blockTag: blockHash });
-
-    const value = contractResult.map((val: ethers.BigNumber | number) => ethers.BigNumber.from(val).toBigInt());
-    const result: ValueResult = { value };
-
-    return result;
-  }
-
-  async getVotingProxy (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    const entity = await this._db.getGetVotingProxy({ blockHash, contractAddress, _point });
-    if (entity) {
-      log('getVotingProxy: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getVotingProxy: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getVotingProxy(_point, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveGetVotingProxy({ blockHash, blockNumber, contractAddress, _point, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async isVotingProxy (blockHash: string, contractAddress: string, _point: bigint, _proxy: string): Promise<ValueResult> {
-    const entity = await this._db.getIsVotingProxy({ blockHash, contractAddress, _point, _proxy });
-    if (entity) {
-      log('isVotingProxy: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('isVotingProxy: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.isVotingProxy(_point, _proxy, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveIsVotingProxy({ blockHash, blockNumber, contractAddress, _point, _proxy, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async canVoteAs (blockHash: string, contractAddress: string, _point: bigint, _who: string): Promise<ValueResult> {
-    const entity = await this._db.getCanVoteAs({ blockHash, contractAddress, _point, _who });
-    if (entity) {
-      log('canVoteAs: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('canVoteAs: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.canVoteAs(_point, _who, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveCanVoteAs({ blockHash, blockNumber, contractAddress, _point, _who, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getVotingForCount (blockHash: string, contractAddress: string, _proxy: string): Promise<ValueResult> {
-    const entity = await this._db.getGetVotingForCount({ blockHash, contractAddress, _proxy });
-    if (entity) {
-      log('getVotingForCount: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getVotingForCount: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getVotingForCount(_proxy, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetVotingForCount({ blockHash, blockNumber, contractAddress, _proxy, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getVotingFor (blockHash: string, contractAddress: string, _proxy: string): Promise<ValueResult> {
-    log('getVotingFor: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getVotingFor(_proxy, { blockTag: blockHash });
-
-    const value = contractResult.map((val: ethers.BigNumber | number) => ethers.BigNumber.from(val).toBigInt());
-    const result: ValueResult = { value };
-
-    return result;
-  }
-
-  async getTransferProxy (blockHash: string, contractAddress: string, _point: bigint): Promise<ValueResult> {
-    const entity = await this._db.getGetTransferProxy({ blockHash, contractAddress, _point });
-    if (entity) {
-      log('getTransferProxy: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getTransferProxy: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getTransferProxy(_point, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveGetTransferProxy({ blockHash, blockNumber, contractAddress, _point, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async isTransferProxy (blockHash: string, contractAddress: string, _point: bigint, _proxy: string): Promise<ValueResult> {
-    const entity = await this._db.getIsTransferProxy({ blockHash, contractAddress, _point, _proxy });
-    if (entity) {
-      log('isTransferProxy: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('isTransferProxy: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.isTransferProxy(_point, _proxy, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveIsTransferProxy({ blockHash, blockNumber, contractAddress, _point, _proxy, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async canTransfer (blockHash: string, contractAddress: string, _point: bigint, _who: string): Promise<ValueResult> {
-    const entity = await this._db.getCanTransfer({ blockHash, contractAddress, _point, _who });
-    if (entity) {
-      log('canTransfer: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('canTransfer: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.canTransfer(_point, _who, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveCanTransfer({ blockHash, blockNumber, contractAddress, _point, _who, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getTransferringForCount (blockHash: string, contractAddress: string, _proxy: string): Promise<ValueResult> {
-    const entity = await this._db.getGetTransferringForCount({ blockHash, contractAddress, _proxy });
-    if (entity) {
-      log('getTransferringForCount: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getTransferringForCount: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getTransferringForCount(_proxy, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetTransferringForCount({ blockHash, blockNumber, contractAddress, _proxy, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getTransferringFor (blockHash: string, contractAddress: string, _proxy: string): Promise<ValueResult> {
-    log('getTransferringFor: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getTransferringFor(_proxy, { blockTag: blockHash });
-
-    const value = contractResult.map((val: ethers.BigNumber | number) => ethers.BigNumber.from(val).toBigInt());
-    const result: ValueResult = { value };
-
-    return result;
-  }
-
-  async isOperator (blockHash: string, contractAddress: string, _owner: string, _operator: string): Promise<ValueResult> {
-    const entity = await this._db.getIsOperator({ blockHash, contractAddress, _owner, _operator });
-    if (entity) {
-      log('isOperator: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('isOperator: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.isOperator(_owner, _operator, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveIsOperator({ blockHash, blockNumber, contractAddress, _owner, _operator, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getUpgradeProposals (blockHash: string, contractAddress: string): Promise<ValueResult> {
-    log('getUpgradeProposals: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getUpgradeProposals({ blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    return result;
-  }
-
-  async getUpgradeProposalCount (blockHash: string, contractAddress: string): Promise<ValueResult> {
-    const entity = await this._db.getGetUpgradeProposalCount({ blockHash, contractAddress });
-    if (entity) {
-      log('getUpgradeProposalCount: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getUpgradeProposalCount: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getUpgradeProposalCount({ blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetUpgradeProposalCount({ blockHash, blockNumber, contractAddress, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getDocumentProposals (blockHash: string, contractAddress: string): Promise<ValueResult> {
-    log('getDocumentProposals: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getDocumentProposals({ blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    return result;
-  }
-
-  async getDocumentProposalCount (blockHash: string, contractAddress: string): Promise<ValueResult> {
-    const entity = await this._db.getGetDocumentProposalCount({ blockHash, contractAddress });
-    if (entity) {
-      log('getDocumentProposalCount: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getDocumentProposalCount: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getDocumentProposalCount({ blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetDocumentProposalCount({ blockHash, blockNumber, contractAddress, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getDocumentMajorities (blockHash: string, contractAddress: string): Promise<ValueResult> {
-    log('getDocumentMajorities: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getDocumentMajorities({ blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    return result;
-  }
-
-  async hasVotedOnUpgradePoll (blockHash: string, contractAddress: string, _galaxy: number, _proposal: string): Promise<ValueResult> {
-    const entity = await this._db.getHasVotedOnUpgradePoll({ blockHash, contractAddress, _galaxy, _proposal });
-    if (entity) {
-      log('hasVotedOnUpgradePoll: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('hasVotedOnUpgradePoll: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.hasVotedOnUpgradePoll(_galaxy, _proposal, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveHasVotedOnUpgradePoll({ blockHash, blockNumber, contractAddress, _galaxy, _proposal, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async hasVotedOnDocumentPoll (blockHash: string, contractAddress: string, _galaxy: number, _proposal: string): Promise<ValueResult> {
-    const entity = await this._db.getHasVotedOnDocumentPoll({ blockHash, contractAddress, _galaxy, _proposal });
-    if (entity) {
-      log('hasVotedOnDocumentPoll: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('hasVotedOnDocumentPoll: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.hasVotedOnDocumentPoll(_galaxy, _proposal, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveHasVotedOnDocumentPoll({ blockHash, blockNumber, contractAddress, _galaxy, _proposal, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async findClaim (blockHash: string, contractAddress: string, _whose: bigint, _protocol: string, _claim: string): Promise<ValueResult> {
-    const entity = await this._db.getFindClaim({ blockHash, contractAddress, _whose, _protocol, _claim });
-    if (entity) {
-      log('findClaim: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('findClaim: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.findClaim(_whose, _protocol, _claim, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveFindClaim({ blockHash, blockNumber, contractAddress, _whose, _protocol, _claim, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async supportsInterface (blockHash: string, contractAddress: string, _interfaceId: string): Promise<ValueResult> {
-    const entity = await this._db.getSupportsInterface({ blockHash, contractAddress, _interfaceId });
-    if (entity) {
-      log('supportsInterface: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('supportsInterface: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.supportsInterface(_interfaceId, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveSupportsInterface({ blockHash, blockNumber, contractAddress, _interfaceId, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async balanceOf (blockHash: string, contractAddress: string, _owner: string): Promise<ValueResult> {
-    const entity = await this._db.getBalanceOf({ blockHash, contractAddress, _owner });
-    if (entity) {
-      log('balanceOf: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('balanceOf: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.balanceOf(_owner, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveBalanceOf({ blockHash, blockNumber, contractAddress, _owner, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async ownerOf (blockHash: string, contractAddress: string, _tokenId: bigint): Promise<ValueResult> {
-    const entity = await this._db.getOwnerOf({ blockHash, contractAddress, _tokenId });
-    if (entity) {
-      log('ownerOf: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('ownerOf: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.ownerOf(_tokenId, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveOwnerOf({ blockHash, blockNumber, contractAddress, _tokenId, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async exists (blockHash: string, contractAddress: string, _tokenId: bigint): Promise<ValueResult> {
-    const entity = await this._db.getExists({ blockHash, contractAddress, _tokenId });
-    if (entity) {
-      log('exists: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('exists: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.exists(_tokenId, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveExists({ blockHash, blockNumber, contractAddress, _tokenId, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getApproved (blockHash: string, contractAddress: string, _tokenId: bigint): Promise<ValueResult> {
-    const entity = await this._db.getGetApproved({ blockHash, contractAddress, _tokenId });
-    if (entity) {
-      log('getApproved: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getApproved: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getApproved(_tokenId, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveGetApproved({ blockHash, blockNumber, contractAddress, _tokenId, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async isApprovedForAll (blockHash: string, contractAddress: string, _owner: string, _operator: string): Promise<ValueResult> {
-    const entity = await this._db.getIsApprovedForAll({ blockHash, contractAddress, _owner, _operator });
-    if (entity) {
-      log('isApprovedForAll: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('isApprovedForAll: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.isApprovedForAll(_owner, _operator, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveIsApprovedForAll({ blockHash, blockNumber, contractAddress, _owner, _operator, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async totalSupply (blockHash: string, contractAddress: string): Promise<ValueResult> {
-    const entity = await this._db.getTotalSupply({ blockHash, contractAddress });
-    if (entity) {
-      log('totalSupply: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('totalSupply: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.totalSupply({ blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveTotalSupply({ blockHash, blockNumber, contractAddress, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async tokenOfOwnerByIndex (blockHash: string, contractAddress: string, _owner: string, _index: bigint): Promise<ValueResult> {
-    const entity = await this._db.getTokenOfOwnerByIndex({ blockHash, contractAddress, _owner, _index });
-    if (entity) {
-      log('tokenOfOwnerByIndex: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('tokenOfOwnerByIndex: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.tokenOfOwnerByIndex(_owner, _index, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveTokenOfOwnerByIndex({ blockHash, blockNumber, contractAddress, _owner, _index, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async tokenByIndex (blockHash: string, contractAddress: string, _index: bigint): Promise<ValueResult> {
-    const entity = await this._db.getTokenByIndex({ blockHash, contractAddress, _index });
-    if (entity) {
-      log('tokenByIndex: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('tokenByIndex: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.tokenByIndex(_index, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveTokenByIndex({ blockHash, blockNumber, contractAddress, _index, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async name (blockHash: string, contractAddress: string): Promise<ValueResult> {
-    const entity = await this._db.getName({ blockHash, contractAddress });
-    if (entity) {
-      log('name: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('name: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.name({ blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveName({ blockHash, blockNumber, contractAddress, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async symbol (blockHash: string, contractAddress: string): Promise<ValueResult> {
-    const entity = await this._db.getSymbol({ blockHash, contractAddress });
-    if (entity) {
-      log('symbol: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('symbol: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.symbol({ blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveSymbol({ blockHash, blockNumber, contractAddress, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async tokenURI (blockHash: string, contractAddress: string, _tokenId: bigint): Promise<ValueResult> {
-    const entity = await this._db.getTokenURI({ blockHash, contractAddress, _tokenId });
-    if (entity) {
-      log('tokenURI: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('tokenURI: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.tokenURI(_tokenId, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveTokenURI({ blockHash, blockNumber, contractAddress, _tokenId, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async getSpawnLimit (blockHash: string, contractAddress: string, _point: bigint, _time: bigint): Promise<ValueResult> {
-    const entity = await this._db.getGetSpawnLimit({ blockHash, contractAddress, _point, _time });
-    if (entity) {
-      log('getSpawnLimit: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('getSpawnLimit: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.getSpawnLimit(_point, _time, { blockTag: blockHash });
-
-    const value = ethers.BigNumber.from(contractResult).toBigInt();
-
-    const result: ValueResult = { value };
-
-    await this._db.saveGetSpawnLimit({ blockHash, blockNumber, contractAddress, _point, _time, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
-  async canEscapeTo (blockHash: string, contractAddress: string, _point: bigint, _sponsor: bigint): Promise<ValueResult> {
-    const entity = await this._db.getCanEscapeTo({ blockHash, contractAddress, _point, _sponsor });
-    if (entity) {
-      log('canEscapeTo: db hit.');
-
-      return {
-        value: entity.value,
-        proof: JSON.parse(entity.proof)
-      };
-    }
-
-    const { block: { number } } = await this._ethClient.getBlockByHash(blockHash);
-    const blockNumber = ethers.BigNumber.from(number).toNumber();
-
-    log('canEscapeTo: db miss, fetching from upstream server');
-
-    const abi = this._abiMap.get(KIND_CONDITIONALSTARRELEASE);
-    assert(abi);
-
-    const contract = new ethers.Contract(contractAddress, abi, this._ethProvider);
-    const contractResult = await contract.canEscapeTo(_point, _sponsor, { blockTag: blockHash });
-
-    const value = contractResult;
-    const result: ValueResult = { value };
-
-    await this._db.saveCanEscapeTo({ blockHash, blockNumber, contractAddress, _point, _sponsor, value: result.value, proof: JSONbigNative.stringify(result.proof) });
-
-    return result;
-  }
-
   async withdrawLimit (blockHash: string, contractAddress: string, _participant: string, _batch: number): Promise<ValueResult> {
     const entity = await this._db.getWithdrawLimit({ blockHash, contractAddress, _participant, _batch });
     if (entity) {
diff --git a/packages/conditional-star-release-watcher/src/resolvers.ts b/packages/conditional-star-release-watcher/src/resolvers.ts
index 271bb31..832381e 100644
--- a/packages/conditional-star-release-watcher/src/resolvers.ts
+++ b/packages/conditional-star-release-watcher/src/resolvers.ts
@@ -72,1194 +72,6 @@ export const createResolvers = async (indexerArg: IndexerInterface, eventWatcher
     },
 
     Query: {
-      isActive: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('isActive', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('isActive').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.isActive(blockHash, contractAddress, _point);
-      },
-
-      getKeys: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getKeys', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getKeys').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getKeys(blockHash, contractAddress, _point);
-      },
-
-      getKeyRevisionNumber: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getKeyRevisionNumber', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getKeyRevisionNumber').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getKeyRevisionNumber(blockHash, contractAddress, _point);
-      },
-
-      hasBeenLinked: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('hasBeenLinked', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('hasBeenLinked').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.hasBeenLinked(blockHash, contractAddress, _point);
-      },
-
-      isLive: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('isLive', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('isLive').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.isLive(blockHash, contractAddress, _point);
-      },
-
-      getContinuityNumber: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getContinuityNumber', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getContinuityNumber').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getContinuityNumber(blockHash, contractAddress, _point);
-      },
-
-      getSpawnCount: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getSpawnCount', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getSpawnCount').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getSpawnCount(blockHash, contractAddress, _point);
-      },
-
-      getSpawned: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getSpawned', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getSpawned').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getSpawned(blockHash, contractAddress, _point);
-      },
-
-      hasSponsor: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('hasSponsor', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('hasSponsor').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.hasSponsor(blockHash, contractAddress, _point);
-      },
-
-      getSponsor: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getSponsor', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getSponsor').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getSponsor(blockHash, contractAddress, _point);
-      },
-
-      isSponsor: (
-        _: any,
-        { blockHash, contractAddress, _point, _sponsor }: { blockHash: string, contractAddress: string, _point: bigint, _sponsor: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('isSponsor', blockHash, contractAddress, _point, _sponsor);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('isSponsor').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.isSponsor(blockHash, contractAddress, _point, _sponsor);
-      },
-
-      getSponsoringCount: (
-        _: any,
-        { blockHash, contractAddress, _sponsor }: { blockHash: string, contractAddress: string, _sponsor: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getSponsoringCount', blockHash, contractAddress, _sponsor);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getSponsoringCount').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getSponsoringCount(blockHash, contractAddress, _sponsor);
-      },
-
-      getSponsoring: (
-        _: any,
-        { blockHash, contractAddress, _sponsor }: { blockHash: string, contractAddress: string, _sponsor: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getSponsoring', blockHash, contractAddress, _sponsor);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getSponsoring').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getSponsoring(blockHash, contractAddress, _sponsor);
-      },
-
-      isEscaping: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('isEscaping', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('isEscaping').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.isEscaping(blockHash, contractAddress, _point);
-      },
-
-      getEscapeRequest: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getEscapeRequest', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getEscapeRequest').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getEscapeRequest(blockHash, contractAddress, _point);
-      },
-
-      isRequestingEscapeTo: (
-        _: any,
-        { blockHash, contractAddress, _point, _sponsor }: { blockHash: string, contractAddress: string, _point: bigint, _sponsor: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('isRequestingEscapeTo', blockHash, contractAddress, _point, _sponsor);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('isRequestingEscapeTo').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.isRequestingEscapeTo(blockHash, contractAddress, _point, _sponsor);
-      },
-
-      getEscapeRequestsCount: (
-        _: any,
-        { blockHash, contractAddress, _sponsor }: { blockHash: string, contractAddress: string, _sponsor: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getEscapeRequestsCount', blockHash, contractAddress, _sponsor);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getEscapeRequestsCount').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getEscapeRequestsCount(blockHash, contractAddress, _sponsor);
-      },
-
-      getEscapeRequests: (
-        _: any,
-        { blockHash, contractAddress, _sponsor }: { blockHash: string, contractAddress: string, _sponsor: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getEscapeRequests', blockHash, contractAddress, _sponsor);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getEscapeRequests').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getEscapeRequests(blockHash, contractAddress, _sponsor);
-      },
-
-      getOwner: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getOwner', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getOwner').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getOwner(blockHash, contractAddress, _point);
-      },
-
-      isOwner: (
-        _: any,
-        { blockHash, contractAddress, _point, _address }: { blockHash: string, contractAddress: string, _point: bigint, _address: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('isOwner', blockHash, contractAddress, _point, _address);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('isOwner').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.isOwner(blockHash, contractAddress, _point, _address);
-      },
-
-      getOwnedPointCount: (
-        _: any,
-        { blockHash, contractAddress, _whose }: { blockHash: string, contractAddress: string, _whose: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getOwnedPointCount', blockHash, contractAddress, _whose);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getOwnedPointCount').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getOwnedPointCount(blockHash, contractAddress, _whose);
-      },
-
-      getOwnedPoints: (
-        _: any,
-        { blockHash, contractAddress, _whose }: { blockHash: string, contractAddress: string, _whose: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getOwnedPoints', blockHash, contractAddress, _whose);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getOwnedPoints').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getOwnedPoints(blockHash, contractAddress, _whose);
-      },
-
-      getOwnedPointAtIndex: (
-        _: any,
-        { blockHash, contractAddress, _whose, _index }: { blockHash: string, contractAddress: string, _whose: string, _index: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getOwnedPointAtIndex', blockHash, contractAddress, _whose, _index);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getOwnedPointAtIndex').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getOwnedPointAtIndex(blockHash, contractAddress, _whose, _index);
-      },
-
-      getManagementProxy: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getManagementProxy', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getManagementProxy').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getManagementProxy(blockHash, contractAddress, _point);
-      },
-
-      isManagementProxy: (
-        _: any,
-        { blockHash, contractAddress, _point, _proxy }: { blockHash: string, contractAddress: string, _point: bigint, _proxy: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('isManagementProxy', blockHash, contractAddress, _point, _proxy);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('isManagementProxy').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.isManagementProxy(blockHash, contractAddress, _point, _proxy);
-      },
-
-      canManage: (
-        _: any,
-        { blockHash, contractAddress, _point, _who }: { blockHash: string, contractAddress: string, _point: bigint, _who: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('canManage', blockHash, contractAddress, _point, _who);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('canManage').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.canManage(blockHash, contractAddress, _point, _who);
-      },
-
-      getManagerForCount: (
-        _: any,
-        { blockHash, contractAddress, _proxy }: { blockHash: string, contractAddress: string, _proxy: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getManagerForCount', blockHash, contractAddress, _proxy);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getManagerForCount').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getManagerForCount(blockHash, contractAddress, _proxy);
-      },
-
-      getManagerFor: (
-        _: any,
-        { blockHash, contractAddress, _proxy }: { blockHash: string, contractAddress: string, _proxy: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getManagerFor', blockHash, contractAddress, _proxy);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getManagerFor').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getManagerFor(blockHash, contractAddress, _proxy);
-      },
-
-      getSpawnProxy: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getSpawnProxy', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getSpawnProxy').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getSpawnProxy(blockHash, contractAddress, _point);
-      },
-
-      isSpawnProxy: (
-        _: any,
-        { blockHash, contractAddress, _point, _proxy }: { blockHash: string, contractAddress: string, _point: bigint, _proxy: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('isSpawnProxy', blockHash, contractAddress, _point, _proxy);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('isSpawnProxy').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.isSpawnProxy(blockHash, contractAddress, _point, _proxy);
-      },
-
-      canSpawnAs: (
-        _: any,
-        { blockHash, contractAddress, _point, _who }: { blockHash: string, contractAddress: string, _point: bigint, _who: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('canSpawnAs', blockHash, contractAddress, _point, _who);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('canSpawnAs').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.canSpawnAs(blockHash, contractAddress, _point, _who);
-      },
-
-      getSpawningForCount: (
-        _: any,
-        { blockHash, contractAddress, _proxy }: { blockHash: string, contractAddress: string, _proxy: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getSpawningForCount', blockHash, contractAddress, _proxy);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getSpawningForCount').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getSpawningForCount(blockHash, contractAddress, _proxy);
-      },
-
-      getSpawningFor: (
-        _: any,
-        { blockHash, contractAddress, _proxy }: { blockHash: string, contractAddress: string, _proxy: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getSpawningFor', blockHash, contractAddress, _proxy);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getSpawningFor').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getSpawningFor(blockHash, contractAddress, _proxy);
-      },
-
-      getVotingProxy: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getVotingProxy', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getVotingProxy').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getVotingProxy(blockHash, contractAddress, _point);
-      },
-
-      isVotingProxy: (
-        _: any,
-        { blockHash, contractAddress, _point, _proxy }: { blockHash: string, contractAddress: string, _point: bigint, _proxy: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('isVotingProxy', blockHash, contractAddress, _point, _proxy);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('isVotingProxy').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.isVotingProxy(blockHash, contractAddress, _point, _proxy);
-      },
-
-      canVoteAs: (
-        _: any,
-        { blockHash, contractAddress, _point, _who }: { blockHash: string, contractAddress: string, _point: bigint, _who: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('canVoteAs', blockHash, contractAddress, _point, _who);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('canVoteAs').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.canVoteAs(blockHash, contractAddress, _point, _who);
-      },
-
-      getVotingForCount: (
-        _: any,
-        { blockHash, contractAddress, _proxy }: { blockHash: string, contractAddress: string, _proxy: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getVotingForCount', blockHash, contractAddress, _proxy);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getVotingForCount').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getVotingForCount(blockHash, contractAddress, _proxy);
-      },
-
-      getVotingFor: (
-        _: any,
-        { blockHash, contractAddress, _proxy }: { blockHash: string, contractAddress: string, _proxy: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getVotingFor', blockHash, contractAddress, _proxy);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getVotingFor').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getVotingFor(blockHash, contractAddress, _proxy);
-      },
-
-      getTransferProxy: (
-        _: any,
-        { blockHash, contractAddress, _point }: { blockHash: string, contractAddress: string, _point: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getTransferProxy', blockHash, contractAddress, _point);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getTransferProxy').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getTransferProxy(blockHash, contractAddress, _point);
-      },
-
-      isTransferProxy: (
-        _: any,
-        { blockHash, contractAddress, _point, _proxy }: { blockHash: string, contractAddress: string, _point: bigint, _proxy: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('isTransferProxy', blockHash, contractAddress, _point, _proxy);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('isTransferProxy').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.isTransferProxy(blockHash, contractAddress, _point, _proxy);
-      },
-
-      canTransfer: (
-        _: any,
-        { blockHash, contractAddress, _point, _who }: { blockHash: string, contractAddress: string, _point: bigint, _who: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('canTransfer', blockHash, contractAddress, _point, _who);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('canTransfer').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.canTransfer(blockHash, contractAddress, _point, _who);
-      },
-
-      getTransferringForCount: (
-        _: any,
-        { blockHash, contractAddress, _proxy }: { blockHash: string, contractAddress: string, _proxy: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getTransferringForCount', blockHash, contractAddress, _proxy);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getTransferringForCount').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getTransferringForCount(blockHash, contractAddress, _proxy);
-      },
-
-      getTransferringFor: (
-        _: any,
-        { blockHash, contractAddress, _proxy }: { blockHash: string, contractAddress: string, _proxy: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getTransferringFor', blockHash, contractAddress, _proxy);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getTransferringFor').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getTransferringFor(blockHash, contractAddress, _proxy);
-      },
-
-      isOperator: (
-        _: any,
-        { blockHash, contractAddress, _owner, _operator }: { blockHash: string, contractAddress: string, _owner: string, _operator: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('isOperator', blockHash, contractAddress, _owner, _operator);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('isOperator').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.isOperator(blockHash, contractAddress, _owner, _operator);
-      },
-
-      getUpgradeProposals: (
-        _: any,
-        { blockHash, contractAddress }: { blockHash: string, contractAddress: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getUpgradeProposals', blockHash, contractAddress);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getUpgradeProposals').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getUpgradeProposals(blockHash, contractAddress);
-      },
-
-      getUpgradeProposalCount: (
-        _: any,
-        { blockHash, contractAddress }: { blockHash: string, contractAddress: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getUpgradeProposalCount', blockHash, contractAddress);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getUpgradeProposalCount').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getUpgradeProposalCount(blockHash, contractAddress);
-      },
-
-      getDocumentProposals: (
-        _: any,
-        { blockHash, contractAddress }: { blockHash: string, contractAddress: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getDocumentProposals', blockHash, contractAddress);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getDocumentProposals').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getDocumentProposals(blockHash, contractAddress);
-      },
-
-      getDocumentProposalCount: (
-        _: any,
-        { blockHash, contractAddress }: { blockHash: string, contractAddress: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getDocumentProposalCount', blockHash, contractAddress);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getDocumentProposalCount').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getDocumentProposalCount(blockHash, contractAddress);
-      },
-
-      getDocumentMajorities: (
-        _: any,
-        { blockHash, contractAddress }: { blockHash: string, contractAddress: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getDocumentMajorities', blockHash, contractAddress);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getDocumentMajorities').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getDocumentMajorities(blockHash, contractAddress);
-      },
-
-      hasVotedOnUpgradePoll: (
-        _: any,
-        { blockHash, contractAddress, _galaxy, _proposal }: { blockHash: string, contractAddress: string, _galaxy: number, _proposal: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('hasVotedOnUpgradePoll', blockHash, contractAddress, _galaxy, _proposal);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('hasVotedOnUpgradePoll').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.hasVotedOnUpgradePoll(blockHash, contractAddress, _galaxy, _proposal);
-      },
-
-      hasVotedOnDocumentPoll: (
-        _: any,
-        { blockHash, contractAddress, _galaxy, _proposal }: { blockHash: string, contractAddress: string, _galaxy: number, _proposal: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('hasVotedOnDocumentPoll', blockHash, contractAddress, _galaxy, _proposal);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('hasVotedOnDocumentPoll').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.hasVotedOnDocumentPoll(blockHash, contractAddress, _galaxy, _proposal);
-      },
-
-      findClaim: (
-        _: any,
-        { blockHash, contractAddress, _whose, _protocol, _claim }: { blockHash: string, contractAddress: string, _whose: bigint, _protocol: string, _claim: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('findClaim', blockHash, contractAddress, _whose, _protocol, _claim);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('findClaim').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.findClaim(blockHash, contractAddress, _whose, _protocol, _claim);
-      },
-
-      supportsInterface: (
-        _: any,
-        { blockHash, contractAddress, _interfaceId }: { blockHash: string, contractAddress: string, _interfaceId: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('supportsInterface', blockHash, contractAddress, _interfaceId);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('supportsInterface').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.supportsInterface(blockHash, contractAddress, _interfaceId);
-      },
-
-      balanceOf: (
-        _: any,
-        { blockHash, contractAddress, _owner }: { blockHash: string, contractAddress: string, _owner: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('balanceOf', blockHash, contractAddress, _owner);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('balanceOf').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.balanceOf(blockHash, contractAddress, _owner);
-      },
-
-      ownerOf: (
-        _: any,
-        { blockHash, contractAddress, _tokenId }: { blockHash: string, contractAddress: string, _tokenId: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('ownerOf', blockHash, contractAddress, _tokenId);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('ownerOf').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.ownerOf(blockHash, contractAddress, _tokenId);
-      },
-
-      exists: (
-        _: any,
-        { blockHash, contractAddress, _tokenId }: { blockHash: string, contractAddress: string, _tokenId: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('exists', blockHash, contractAddress, _tokenId);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('exists').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.exists(blockHash, contractAddress, _tokenId);
-      },
-
-      getApproved: (
-        _: any,
-        { blockHash, contractAddress, _tokenId }: { blockHash: string, contractAddress: string, _tokenId: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getApproved', blockHash, contractAddress, _tokenId);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getApproved').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getApproved(blockHash, contractAddress, _tokenId);
-      },
-
-      isApprovedForAll: (
-        _: any,
-        { blockHash, contractAddress, _owner, _operator }: { blockHash: string, contractAddress: string, _owner: string, _operator: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('isApprovedForAll', blockHash, contractAddress, _owner, _operator);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('isApprovedForAll').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.isApprovedForAll(blockHash, contractAddress, _owner, _operator);
-      },
-
-      totalSupply: (
-        _: any,
-        { blockHash, contractAddress }: { blockHash: string, contractAddress: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('totalSupply', blockHash, contractAddress);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('totalSupply').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.totalSupply(blockHash, contractAddress);
-      },
-
-      tokenOfOwnerByIndex: (
-        _: any,
-        { blockHash, contractAddress, _owner, _index }: { blockHash: string, contractAddress: string, _owner: string, _index: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('tokenOfOwnerByIndex', blockHash, contractAddress, _owner, _index);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('tokenOfOwnerByIndex').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.tokenOfOwnerByIndex(blockHash, contractAddress, _owner, _index);
-      },
-
-      tokenByIndex: (
-        _: any,
-        { blockHash, contractAddress, _index }: { blockHash: string, contractAddress: string, _index: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('tokenByIndex', blockHash, contractAddress, _index);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('tokenByIndex').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.tokenByIndex(blockHash, contractAddress, _index);
-      },
-
-      name: (
-        _: any,
-        { blockHash, contractAddress }: { blockHash: string, contractAddress: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('name', blockHash, contractAddress);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('name').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.name(blockHash, contractAddress);
-      },
-
-      symbol: (
-        _: any,
-        { blockHash, contractAddress }: { blockHash: string, contractAddress: string },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('symbol', blockHash, contractAddress);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('symbol').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.symbol(blockHash, contractAddress);
-      },
-
-      tokenURI: (
-        _: any,
-        { blockHash, contractAddress, _tokenId }: { blockHash: string, contractAddress: string, _tokenId: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('tokenURI', blockHash, contractAddress, _tokenId);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('tokenURI').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.tokenURI(blockHash, contractAddress, _tokenId);
-      },
-
-      getSpawnLimit: (
-        _: any,
-        { blockHash, contractAddress, _point, _time }: { blockHash: string, contractAddress: string, _point: bigint, _time: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('getSpawnLimit', blockHash, contractAddress, _point, _time);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('getSpawnLimit').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.getSpawnLimit(blockHash, contractAddress, _point, _time);
-      },
-
-      canEscapeTo: (
-        _: any,
-        { blockHash, contractAddress, _point, _sponsor }: { blockHash: string, contractAddress: string, _point: bigint, _sponsor: bigint },
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        __: any,
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        info: GraphQLResolveInfo
-      ): Promise<ValueResult> => {
-        log('canEscapeTo', blockHash, contractAddress, _point, _sponsor);
-        gqlTotalQueryCount.inc(1);
-        gqlQueryCount.labels('canEscapeTo').inc(1);
-
-        // Set cache-control hints
-        // setGQLCacheHints(info, {}, gqlCacheConfig);
-
-        return indexer.canEscapeTo(blockHash, contractAddress, _point, _sponsor);
-      },
-
       withdrawLimit: (
         _: any,
         { blockHash, contractAddress, _participant, _batch }: { blockHash: string, contractAddress: string, _participant: string, _batch: number },
diff --git a/packages/conditional-star-release-watcher/src/schema.gql b/packages/conditional-star-release-watcher/src/schema.gql
index 2874312..0de039d 100644
--- a/packages/conditional-star-release-watcher/src/schema.gql
+++ b/packages/conditional-star-release-watcher/src/schema.gql
@@ -61,45 +61,13 @@ type OwnershipTransferredEvent {
   newOwner: String!
 }
 
-type ResultBoolean {
-  value: Boolean!
-  proof: Proof
-}
-
-type ResultGetKeysType {
-  value: GetKeysType!
-  proof: Proof
-}
-
-type GetKeysType {
-  value0: String!
-  value1: String!
-  value2: BigInt!
-  value3: BigInt!
-}
-
-type ResultBigInt {
-  value: BigInt!
-  proof: Proof
-}
-
-type ResultBigIntArray {
-  value: [BigInt!]!
-  proof: Proof
-}
-
-type ResultString {
-  value: String!
-  proof: Proof
-}
-
-type ResultStringArray {
-  value: [String!]!
+type ResultInt {
+  value: Int!
   proof: Proof
 }
 
-type ResultInt {
-  value: Int!
+type ResultBoolean {
+  value: Boolean!
   proof: Proof
 }
 
@@ -143,72 +111,6 @@ type ResultState {
 type Query {
   events(blockHash: String!, contractAddress: String!, name: String): [ResultEvent!]
   eventsInRange(fromBlockNumber: Int!, toBlockNumber: Int!): [ResultEvent!]
-  isActive(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultBoolean!
-  getKeys(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultGetKeysType!
-  getKeyRevisionNumber(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultBigInt!
-  hasBeenLinked(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultBoolean!
-  isLive(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultBoolean!
-  getContinuityNumber(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultBigInt!
-  getSpawnCount(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultBigInt!
-  getSpawned(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultBigIntArray!
-  hasSponsor(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultBoolean!
-  getSponsor(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultBigInt!
-  isSponsor(blockHash: String!, contractAddress: String!, _point: BigInt!, _sponsor: BigInt!): ResultBoolean!
-  getSponsoringCount(blockHash: String!, contractAddress: String!, _sponsor: BigInt!): ResultBigInt!
-  getSponsoring(blockHash: String!, contractAddress: String!, _sponsor: BigInt!): ResultBigIntArray!
-  isEscaping(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultBoolean!
-  getEscapeRequest(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultBigInt!
-  isRequestingEscapeTo(blockHash: String!, contractAddress: String!, _point: BigInt!, _sponsor: BigInt!): ResultBoolean!
-  getEscapeRequestsCount(blockHash: String!, contractAddress: String!, _sponsor: BigInt!): ResultBigInt!
-  getEscapeRequests(blockHash: String!, contractAddress: String!, _sponsor: BigInt!): ResultBigIntArray!
-  getOwner(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultString!
-  isOwner(blockHash: String!, contractAddress: String!, _point: BigInt!, _address: String!): ResultBoolean!
-  getOwnedPointCount(blockHash: String!, contractAddress: String!, _whose: String!): ResultBigInt!
-  getOwnedPoints(blockHash: String!, contractAddress: String!, _whose: String!): ResultBigIntArray!
-  getOwnedPointAtIndex(blockHash: String!, contractAddress: String!, _whose: String!, _index: BigInt!): ResultBigInt!
-  getManagementProxy(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultString!
-  isManagementProxy(blockHash: String!, contractAddress: String!, _point: BigInt!, _proxy: String!): ResultBoolean!
-  canManage(blockHash: String!, contractAddress: String!, _point: BigInt!, _who: String!): ResultBoolean!
-  getManagerForCount(blockHash: String!, contractAddress: String!, _proxy: String!): ResultBigInt!
-  getManagerFor(blockHash: String!, contractAddress: String!, _proxy: String!): ResultBigIntArray!
-  getSpawnProxy(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultString!
-  isSpawnProxy(blockHash: String!, contractAddress: String!, _point: BigInt!, _proxy: String!): ResultBoolean!
-  canSpawnAs(blockHash: String!, contractAddress: String!, _point: BigInt!, _who: String!): ResultBoolean!
-  getSpawningForCount(blockHash: String!, contractAddress: String!, _proxy: String!): ResultBigInt!
-  getSpawningFor(blockHash: String!, contractAddress: String!, _proxy: String!): ResultBigIntArray!
-  getVotingProxy(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultString!
-  isVotingProxy(blockHash: String!, contractAddress: String!, _point: BigInt!, _proxy: String!): ResultBoolean!
-  canVoteAs(blockHash: String!, contractAddress: String!, _point: BigInt!, _who: String!): ResultBoolean!
-  getVotingForCount(blockHash: String!, contractAddress: String!, _proxy: String!): ResultBigInt!
-  getVotingFor(blockHash: String!, contractAddress: String!, _proxy: String!): ResultBigIntArray!
-  getTransferProxy(blockHash: String!, contractAddress: String!, _point: BigInt!): ResultString!
-  isTransferProxy(blockHash: String!, contractAddress: String!, _point: BigInt!, _proxy: String!): ResultBoolean!
-  canTransfer(blockHash: String!, contractAddress: String!, _point: BigInt!, _who: String!): ResultBoolean!
-  getTransferringForCount(blockHash: String!, contractAddress: String!, _proxy: String!): ResultBigInt!
-  getTransferringFor(blockHash: String!, contractAddress: String!, _proxy: String!): ResultBigIntArray!
-  isOperator(blockHash: String!, contractAddress: String!, _owner: String!, _operator: String!): ResultBoolean!
-  getUpgradeProposals(blockHash: String!, contractAddress: String!): ResultStringArray!
-  getUpgradeProposalCount(blockHash: String!, contractAddress: String!): ResultBigInt!
-  getDocumentProposals(blockHash: String!, contractAddress: String!): ResultStringArray!
-  getDocumentProposalCount(blockHash: String!, contractAddress: String!): ResultBigInt!
-  getDocumentMajorities(blockHash: String!, contractAddress: String!): ResultStringArray!
-  hasVotedOnUpgradePoll(blockHash: String!, contractAddress: String!, _galaxy: Int!, _proposal: String!): ResultBoolean!
-  hasVotedOnDocumentPoll(blockHash: String!, contractAddress: String!, _galaxy: Int!, _proposal: String!): ResultBoolean!
-  findClaim(blockHash: String!, contractAddress: String!, _whose: BigInt!, _protocol: String!, _claim: String!): ResultInt!
-  supportsInterface(blockHash: String!, contractAddress: String!, _interfaceId: String!): ResultBoolean!
-  balanceOf(blockHash: String!, contractAddress: String!, _owner: String!): ResultBigInt!
-  ownerOf(blockHash: String!, contractAddress: String!, _tokenId: BigInt!): ResultString!
-  exists(blockHash: String!, contractAddress: String!, _tokenId: BigInt!): ResultBoolean!
-  getApproved(blockHash: String!, contractAddress: String!, _tokenId: BigInt!): ResultString!
-  isApprovedForAll(blockHash: String!, contractAddress: String!, _owner: String!, _operator: String!): ResultBoolean!
-  totalSupply(blockHash: String!, contractAddress: String!): ResultBigInt!
-  tokenOfOwnerByIndex(blockHash: String!, contractAddress: String!, _owner: String!, _index: BigInt!): ResultBigInt!
-  tokenByIndex(blockHash: String!, contractAddress: String!, _index: BigInt!): ResultBigInt!
-  name(blockHash: String!, contractAddress: String!): ResultString!
-  symbol(blockHash: String!, contractAddress: String!): ResultString!
-  tokenURI(blockHash: String!, contractAddress: String!, _tokenId: BigInt!): ResultString!
-  getSpawnLimit(blockHash: String!, contractAddress: String!, _point: BigInt!, _time: BigInt!): ResultBigInt!
-  canEscapeTo(blockHash: String!, contractAddress: String!, _point: BigInt!, _sponsor: BigInt!): ResultBoolean!
   withdrawLimit(blockHash: String!, contractAddress: String!, _participant: String!, _batch: Int!): ResultInt!
   verifyBalance(blockHash: String!, contractAddress: String!, _participant: String!): ResultBoolean!
   getBatches(blockHash: String!, contractAddress: String!, _participant: String!): ResultIntArray!