From 704e0777a02ed658a72fee1285ab9d06ac9e9400 Mon Sep 17 00:00:00 2001 From: Sanjay Date: Mon, 4 Dec 2023 10:28:57 -0800 Subject: [PATCH] feat: Add more information in the limits response (#1569) * feat: Add more information in the limits response * changeset * Fix flaky test --- .changeset/rotten-files-poke.md | 8 + apps/hubble/src/rpc/test/server.test.ts | 88 ++++++-- apps/hubble/src/storage/db/message.test.ts | 8 + apps/hubble/src/storage/db/message.ts | 19 +- apps/hubble/src/storage/engine/index.ts | 24 ++- .../storage/stores/storeEventHandler.test.ts | 35 +++- .../src/storage/stores/storeEventHandler.ts | 56 ++++- .../protobufs/generated/request_response.ts | 85 +++++++- .../src/generated/request_response.ts | 85 +++++++- .../hub-web/src/generated/request_response.ts | 85 +++++++- packages/hub-web/src/generated/rpc.ts | 198 +++++++++--------- protobufs/schemas/request_response.proto | 7 +- 12 files changed, 560 insertions(+), 138 deletions(-) create mode 100644 .changeset/rotten-files-poke.md diff --git a/.changeset/rotten-files-poke.md b/.changeset/rotten-files-poke.md new file mode 100644 index 0000000000..b38b526c5f --- /dev/null +++ b/.changeset/rotten-files-poke.md @@ -0,0 +1,8 @@ +--- +"@farcaster/hub-nodejs": patch +"@farcaster/hub-web": patch +"@farcaster/core": patch +"@farcaster/hubble": patch +--- + +feat: Add usage information to getCurrentStorageLimitsByFid rpc call diff --git a/apps/hubble/src/rpc/test/server.test.ts b/apps/hubble/src/rpc/test/server.test.ts index b214cc5806..e449b3b70a 100644 --- a/apps/hubble/src/rpc/test/server.test.ts +++ b/apps/hubble/src/rpc/test/server.test.ts @@ -20,6 +20,7 @@ import { MockHub } from "../../test/mocks.js"; import Server from "../server.js"; import SyncEngine from "../../network/sync/syncEngine.js"; import { Ok } from "neverthrow"; +import { sleep } from "../../utils/crypto.js"; const db = jestRocksDB("protobufs.rpc.server.test"); const network = FarcasterNetwork.TESTNET; @@ -44,7 +45,7 @@ afterAll(async () => { await engine.stop(); }); -const fid = Factories.Fid.build(); +let fid: number; const signer = Factories.Ed25519Signer.build(); const custodySigner = Factories.Eip712Signer.build(); @@ -52,7 +53,8 @@ let custodyEvent: OnChainEvent; let signerEvent: OnChainEvent; let storageEvent: OnChainEvent; -beforeAll(async () => { +beforeEach(async () => { + fid = Factories.Fid.build(); const signerKey = (await signer.getSignerKey())._unsafeUnwrap(); const custodySignerKey = (await custodySigner.getSignerKey())._unsafeUnwrap(); custodyEvent = Factories.IdRegistryOnChainEvent.build({ fid }, { transient: { to: custodySignerKey } }); @@ -105,34 +107,92 @@ describe("server rpc tests", () => { test("succeeds for user with no storage", async () => { const result = await client.getCurrentStorageLimitsByFid(FidRequest.create({ fid: fid - 1 })); // zero storage + expect(result._unsafeUnwrap().units).toEqual(0); expect(result._unsafeUnwrap().limits.map((l) => l.limit)).toEqual([0, 0, 0, 0, 0, 0]); }); test("succeeds for user with storage", async () => { + // Add some data, so we can test usage responses + const verification = await Factories.VerificationAddEthAddressMessage.create( + { data: { fid } }, + { transient: { signer } }, + ); + const olderCast = await Factories.CastAddMessage.create({ data: { fid } }, { transient: { signer } }); + const newerCast = await Factories.CastAddMessage.create( + { data: { fid, timestamp: olderCast.data.timestamp + 10 } }, + { transient: { signer } }, + ); + + expect(await engine.mergeMessage(verification)).toBeInstanceOf(Ok); + expect(await engine.mergeMessage(olderCast)).toBeInstanceOf(Ok); + expect(await engine.mergeMessage(newerCast)).toBeInstanceOf(Ok); + + await sleep(100); // Wait for events to be processed const result = await client.getCurrentStorageLimitsByFid(FidRequest.create({ fid })); - const storageLimits = StorageLimitsResponse.fromJSON(result._unsafeUnwrap()).limits; + + expect((await client.getOnChainEvents({ fid: fid, eventType: 4 }))._unsafeUnwrap().events.length).toEqual(1); + + const limitsResponse = StorageLimitsResponse.fromJSON(result._unsafeUnwrap()); + expect(limitsResponse.units).toEqual(1); + const storageLimits = limitsResponse.limits; expect(storageLimits).toContainEqual( - StorageLimit.create({ limit: getDefaultStoreLimit(StoreType.CASTS), storeType: StoreType.CASTS }), + StorageLimit.create({ + limit: getDefaultStoreLimit(StoreType.CASTS), + storeType: StoreType.CASTS, + name: "CASTS", + used: 2, + earliestHash: olderCast.hash, + earliestTimestamp: olderCast.data.timestamp, + }), ); expect(storageLimits).toContainEqual( - StorageLimit.create({ limit: getDefaultStoreLimit(StoreType.REACTIONS), storeType: StoreType.REACTIONS }), + StorageLimit.create({ + limit: getDefaultStoreLimit(StoreType.REACTIONS), + storeType: StoreType.REACTIONS, + name: "REACTIONS", + used: 0, + earliestTimestamp: 0, + earliestHash: new Uint8Array(), + }), ); expect(storageLimits).toContainEqual( - StorageLimit.create({ limit: getDefaultStoreLimit(StoreType.LINKS), storeType: StoreType.LINKS }), + StorageLimit.create({ + limit: getDefaultStoreLimit(StoreType.LINKS), + storeType: StoreType.LINKS, + name: "LINKS", + used: 0, + earliestHash: new Uint8Array(), + earliestTimestamp: 0, + }), ); expect(storageLimits).toContainEqual( - StorageLimit.create({ limit: getDefaultStoreLimit(StoreType.USER_DATA), storeType: StoreType.USER_DATA }), + StorageLimit.create({ + limit: getDefaultStoreLimit(StoreType.USER_DATA), + storeType: StoreType.USER_DATA, + name: "USER_DATA", + used: 0, + earliestHash: new Uint8Array(), + earliestTimestamp: 0, + }), ); expect(storageLimits).toContainEqual( StorageLimit.create({ limit: getDefaultStoreLimit(StoreType.VERIFICATIONS), storeType: StoreType.VERIFICATIONS, + name: "VERIFICATIONS", + used: 1, + earliestHash: verification.hash, + earliestTimestamp: verification.data.timestamp, }), ); expect(storageLimits).toContainEqual( StorageLimit.create({ limit: getDefaultStoreLimit(StoreType.USERNAME_PROOFS), storeType: StoreType.USERNAME_PROOFS, + name: "USERNAME_PROOFS", + used: 0, + earliestHash: new Uint8Array(), + earliestTimestamp: 0, }), ); @@ -143,13 +203,13 @@ describe("server rpc tests", () => { }); await engine.mergeOnChainEvent(rentEvent2); const result2 = await client.getCurrentStorageLimitsByFid(FidRequest.create({ fid })); - const newLimits = StorageLimitsResponse.fromJSON(result2._unsafeUnwrap()).limits; - expect(newLimits).toContainEqual(StorageLimit.create({ limit: 5000 * 3, storeType: StoreType.CASTS })); - expect(newLimits).toContainEqual(StorageLimit.create({ limit: 2500 * 3, storeType: StoreType.REACTIONS })); - expect(newLimits).toContainEqual(StorageLimit.create({ limit: 2500 * 3, storeType: StoreType.LINKS })); - expect(newLimits).toContainEqual(StorageLimit.create({ limit: 50 * 3, storeType: StoreType.USER_DATA })); - expect(newLimits).toContainEqual(StorageLimit.create({ limit: 25 * 3, storeType: StoreType.VERIFICATIONS })); - expect(newLimits).toContainEqual(StorageLimit.create({ limit: 5 * 3, storeType: StoreType.USERNAME_PROOFS })); + const limitsResponse2 = StorageLimitsResponse.fromJSON(result2._unsafeUnwrap()); + expect(limitsResponse2.units).toEqual(3); + const newLimits = limitsResponse2.limits; + expect(newLimits.length).toEqual(6); + for (const limit of newLimits) { + expect(limit.limit).toEqual(getDefaultStoreLimit(limit.storeType) * 3); + } }); }); }); diff --git a/apps/hubble/src/storage/db/message.test.ts b/apps/hubble/src/storage/db/message.test.ts index 0f07bc79fd..9ad46a9607 100644 --- a/apps/hubble/src/storage/db/message.test.ts +++ b/apps/hubble/src/storage/db/message.test.ts @@ -19,6 +19,7 @@ import { makeUserKey, putMessage, typeToSetPostfix, + unpackTsHash, } from "./message.js"; const db = jestRocksDB("storage.db.message.test"); @@ -80,6 +81,13 @@ describe("makeTsHash", () => { const tsHash2 = makeTsHash(castMessage.data.timestamp, new Uint8Array([...castMessage.hash, 1])); expect(bytesCompare(tsHash1._unsafeUnwrap(), tsHash2._unsafeUnwrap())).toEqual(-1); }); + + test("unpacks tsHash", () => { + const tsHash = makeTsHash(castMessage.data.timestamp, castMessage.hash); + const [timestamp, hash] = unpackTsHash(tsHash._unsafeUnwrap())._unsafeUnwrap(); + expect(timestamp).toEqual(castMessage.data.timestamp); + expect(hash).toEqual(castMessage.hash); + }); }); describe("putMessage", () => { diff --git a/apps/hubble/src/storage/db/message.ts b/apps/hubble/src/storage/db/message.ts index 9ae9b2a6fe..dd3fbf01d1 100644 --- a/apps/hubble/src/storage/db/message.ts +++ b/apps/hubble/src/storage/db/message.ts @@ -1,7 +1,15 @@ import { bytesIncrement, CastId, HubError, HubResult, Message, MessageData, MessageType } from "@farcaster/hub-nodejs"; import { err, ok, Result, ResultAsync } from "neverthrow"; import RocksDB, { Iterator, Transaction } from "./rocksdb.js"; -import { FID_BYTES, RootPrefix, TRUE_VALUE, UserMessagePostfix, UserMessagePostfixMax, UserPostfix } from "./types.js"; +import { + FID_BYTES, + RootPrefix, + TRUE_VALUE, + TSHASH_LENGTH, + UserMessagePostfix, + UserMessagePostfixMax, + UserPostfix, +} from "./types.js"; import { MessagesPage, PAGE_SIZE_MAX, PageOptions } from "../stores/types.js"; export const makeFidKey = (fid: number): Buffer => { @@ -74,6 +82,15 @@ export const makeTsHash = (timestamp: number, hash: Uint8Array): HubResult => { + if (tsHash.length !== TSHASH_LENGTH) { + return err(new HubError("bad_request.invalid_param", "invalid tsHash length")); + } + const timestamp = tsHash.slice(0, 4); + const hash = tsHash.slice(4); + return ok([Buffer.from(timestamp).readUInt32BE(0), hash]); +}; + export const typeToSetPostfix = (type: MessageType): UserMessagePostfix => { if (type === MessageType.CAST_ADD || type === MessageType.CAST_REMOVE) { return UserPostfix.CastMessage; diff --git a/apps/hubble/src/storage/engine/index.ts b/apps/hubble/src/storage/engine/index.ts index 5ba55d02f0..255dc6ccc7 100644 --- a/apps/hubble/src/storage/engine/index.ts +++ b/apps/hubble/src/storage/engine/index.ts @@ -29,7 +29,9 @@ import { RevokeMessagesBySignerJobPayload, SignerEventType, SignerOnChainEvent, + StorageLimit, StorageLimitsResponse, + StoreType, UserDataAddMessage, UserDataType, UserNameProof, @@ -717,8 +719,28 @@ class Engine extends TypedEmitter { return err(units.error); } + const storeLimits = getStoreLimits(units.value); + const limits: StorageLimit[] = []; + for (const limit of storeLimits) { + const usageResult = await this.eventHandler.getUsage(fid, limit.storeType); + if (usageResult.isErr()) { + log.warn({ err: usageResult.error }, `error getting usage for storage limit for ${fid} and ${limit.storeType}`); + continue; + } + limits.push( + StorageLimit.create({ + limit: limit.limit, + name: StoreType[limit.storeType], + used: usageResult.value.used, + earliestTimestamp: usageResult.value.earliestTimestamp, + earliestHash: usageResult.value.earliestHash, + storeType: limit.storeType, + }), + ); + } return ok({ - limits: getStoreLimits(units.value), + units: units.value, + limits: limits, }); } diff --git a/apps/hubble/src/storage/stores/storeEventHandler.test.ts b/apps/hubble/src/storage/stores/storeEventHandler.test.ts index fa52c95d2e..567d57ca3f 100644 --- a/apps/hubble/src/storage/stores/storeEventHandler.test.ts +++ b/apps/hubble/src/storage/stores/storeEventHandler.test.ts @@ -1,12 +1,13 @@ -import { CastAddMessage, Factories, FARCASTER_EPOCH, HubEvent, HubEventType } from "@farcaster/hub-nodejs"; +import { CastAddMessage, Factories, FARCASTER_EPOCH, HubEvent, HubEventType, StoreType } from "@farcaster/hub-nodejs"; import { ok, Result } from "neverthrow"; import { jestRocksDB } from "../db/jestUtils.js"; import { getMessage, makeTsHash, putMessage, putMessageTransaction } from "../db/message.js"; import { UserPostfix } from "../db/types.js"; import StoreEventHandler, { HubEventArgs, HubEventIdGenerator } from "./storeEventHandler.js"; import { sleep } from "../../utils/crypto.js"; -import { getFarcasterTime, extractEventTimestamp } from "@farcaster/core"; +import { extractEventTimestamp, getFarcasterTime } from "@farcaster/core"; import OnChainEventStore from "./onChainEventStore.js"; +import CastStore from "./castStore.js"; const db = jestRocksDB("stores.storeEventHandler.test"); const eventHandler = new StoreEventHandler(db); @@ -206,3 +207,33 @@ describe("getCurrentStorageUnitsForFid", () => { expect(await eventHandler.getCurrentStorageUnitsForFid(fid)).toEqual(ok(storageEvent.storageRentEventBody.units)); }); }); + +describe("getUsage", () => { + test("returns 0 if no messages", async () => { + const usage = await eventHandler.getUsage(message.data.fid, StoreType.CASTS); + expect(usage.isOk()).toBeTruthy(); + expect(usage._unsafeUnwrap().used).toEqual(0); + expect(usage._unsafeUnwrap().earliestTimestamp).toEqual(0); + expect(usage._unsafeUnwrap().earliestHash.length).toEqual(0); + }); + + test("returns actual usage based on messages", async () => { + const fid = Factories.Fid.build(); + const storageEvent = Factories.StorageRentOnChainEvent.build({ fid }); + const onChainEventStore = new OnChainEventStore(db, eventHandler); + await onChainEventStore.mergeOnChainEvent(storageEvent); + + const castStore = new CastStore(db, eventHandler); + const newCast = await Factories.CastAddMessage.create({ data: { fid } }); + const olderCast = await Factories.CastAddMessage.create({ + data: { fid, timestamp: newCast.data.timestamp - 10 }, + }); + await castStore.merge(newCast); + await castStore.merge(olderCast); + + const usage = (await eventHandler.getUsage(newCast.data.fid, StoreType.CASTS))._unsafeUnwrap(); + expect(usage.used).toEqual(2); + expect(usage.earliestTimestamp).toEqual(olderCast.data.timestamp); + expect(usage.earliestHash).toEqual(olderCast.hash); + }); +}); diff --git a/apps/hubble/src/storage/stores/storeEventHandler.ts b/apps/hubble/src/storage/stores/storeEventHandler.ts index 8c21c40b76..c9ad05a6d3 100644 --- a/apps/hubble/src/storage/stores/storeEventHandler.ts +++ b/apps/hubble/src/storage/stores/storeEventHandler.ts @@ -3,28 +3,29 @@ import { FARCASTER_EPOCH, HubAsyncResult, HubError, + HubEvent, HubResult, isHubError, - HubEvent, isMergeMessageHubEvent, + isMergeOnChainHubEvent, isMergeUsernameProofHubEvent, isPruneMessageHubEvent, isRevokeMessageHubEvent, MergeMessageHubEvent, + MergeOnChainEventHubEvent, MergeUsernameProofHubEvent, PruneMessageHubEvent, RevokeMessageHubEvent, - MergeOnChainEventHubEvent, - isMergeOnChainHubEvent, + StoreType, } from "@farcaster/hub-nodejs"; import AbstractRocksDB from "@farcaster/rocksdb"; import AsyncLock from "async-lock"; import { err, ok, ResultAsync } from "neverthrow"; import { TypedEmitter } from "tiny-typed-emitter"; import RocksDB, { Transaction } from "../db/rocksdb.js"; -import { RootPrefix, UserMessagePostfix } from "../db/types.js"; +import { RootPrefix, UserMessagePostfix, UserPostfix } from "../db/types.js"; import { StorageCache } from "./storageCache.js"; -import { makeTsHash } from "../db/message.js"; +import { makeTsHash, unpackTsHash } from "../db/message.js"; import { bytesCompare, CastAddMessage, @@ -44,6 +45,16 @@ const PRUNE_TIME_LIMIT_DEFAULT = 60 * 60 * 24 * 3 * 1000; // 3 days in ms const DEFAULT_LOCK_MAX_PENDING = 1_000; const DEFAULT_LOCK_TIMEOUT = 500; // in ms +// @ts-ignore +const STORE_TO_SET: Record = { + [StoreType.CASTS]: UserPostfix.CastMessage, + [StoreType.LINKS]: UserPostfix.LinkMessage, + [StoreType.REACTIONS]: UserPostfix.ReactionMessage, + [StoreType.USER_DATA]: UserPostfix.UserDataMessage, + [StoreType.VERIFICATIONS]: UserPostfix.VerificationMessage, + [StoreType.USERNAME_PROOFS]: UserPostfix.UsernameProofMessage, +}; + type PrunableMessage = | CastAddMessage | CastRemoveMessage @@ -55,6 +66,12 @@ type PrunableMessage = | LinkAddMessage | LinkRemoveMessage; +export type StoreUsage = { + used: number; + earliestTimestamp: number; + earliestHash: Uint8Array; +}; + export type StoreEvents = { /** * mergeMessage is emitted when a message is merged into one of the stores. If @@ -191,6 +208,35 @@ class StoreEventHandler extends TypedEmitter { }); } + async getUsage(fid: number, store: StoreType): HubAsyncResult { + const set = STORE_TO_SET[store]; + if (!set) { + return err(new HubError("bad_request.invalid_param", `invalid store type ${store}`)); + } + const messageCount = await this.getCacheMessageCount(fid, set); + if (messageCount.isErr()) { + return err(messageCount.error); + } + const earliestTsHash = await this.getEarliestTsHash(fid, set); + if (earliestTsHash.isErr()) { + return err(earliestTsHash.error); + } + let earliestTimestamp = 0; + let earliestHash = new Uint8Array(); + if (earliestTsHash.value !== undefined) { + const unpackResult = unpackTsHash(earliestTsHash.value); + if (unpackResult.isOk()) { + [earliestTimestamp, earliestHash] = unpackResult.value; + } + } + + return ok({ + used: messageCount.value, + earliestTimestamp, + earliestHash, + }); + } + async getCacheMessageCount(fid: number, set: UserMessagePostfix): HubAsyncResult { return this._storageCache.getMessageCount(fid, set); } diff --git a/packages/core/src/protobufs/generated/request_response.ts b/packages/core/src/protobufs/generated/request_response.ts index 5c1aeb77c3..7595023cff 100644 --- a/packages/core/src/protobufs/generated/request_response.ts +++ b/packages/core/src/protobufs/generated/request_response.ts @@ -234,11 +234,16 @@ export interface OnChainEventResponse { export interface StorageLimitsResponse { limits: StorageLimit[]; + units: number; } export interface StorageLimit { storeType: StoreType; + name: string; limit: number; + used: number; + earliestTimestamp: number; + earliestHash: Uint8Array; } export interface UsernameProofRequest { @@ -2581,7 +2586,7 @@ export const OnChainEventResponse = { }; function createBaseStorageLimitsResponse(): StorageLimitsResponse { - return { limits: [] }; + return { limits: [], units: 0 }; } export const StorageLimitsResponse = { @@ -2589,6 +2594,9 @@ export const StorageLimitsResponse = { for (const v of message.limits) { StorageLimit.encode(v!, writer.uint32(10).fork()).ldelim(); } + if (message.units !== 0) { + writer.uint32(16).uint32(message.units); + } return writer; }, @@ -2606,6 +2614,13 @@ export const StorageLimitsResponse = { message.limits.push(StorageLimit.decode(reader, reader.uint32())); continue; + case 2: + if (tag != 16) { + break; + } + + message.units = reader.uint32(); + continue; } if ((tag & 7) == 4 || tag == 0) { break; @@ -2616,7 +2631,10 @@ export const StorageLimitsResponse = { }, fromJSON(object: any): StorageLimitsResponse { - return { limits: Array.isArray(object?.limits) ? object.limits.map((e: any) => StorageLimit.fromJSON(e)) : [] }; + return { + limits: Array.isArray(object?.limits) ? object.limits.map((e: any) => StorageLimit.fromJSON(e)) : [], + units: isSet(object.units) ? Number(object.units) : 0, + }; }, toJSON(message: StorageLimitsResponse): unknown { @@ -2626,6 +2644,7 @@ export const StorageLimitsResponse = { } else { obj.limits = []; } + message.units !== undefined && (obj.units = Math.round(message.units)); return obj; }, @@ -2636,12 +2655,13 @@ export const StorageLimitsResponse = { fromPartial, I>>(object: I): StorageLimitsResponse { const message = createBaseStorageLimitsResponse(); message.limits = object.limits?.map((e) => StorageLimit.fromPartial(e)) || []; + message.units = object.units ?? 0; return message; }, }; function createBaseStorageLimit(): StorageLimit { - return { storeType: 0, limit: 0 }; + return { storeType: 0, name: "", limit: 0, used: 0, earliestTimestamp: 0, earliestHash: new Uint8Array() }; } export const StorageLimit = { @@ -2649,8 +2669,20 @@ export const StorageLimit = { if (message.storeType !== 0) { writer.uint32(8).int32(message.storeType); } + if (message.name !== "") { + writer.uint32(18).string(message.name); + } if (message.limit !== 0) { - writer.uint32(16).uint64(message.limit); + writer.uint32(24).uint64(message.limit); + } + if (message.used !== 0) { + writer.uint32(32).uint64(message.used); + } + if (message.earliestTimestamp !== 0) { + writer.uint32(40).uint64(message.earliestTimestamp); + } + if (message.earliestHash.length !== 0) { + writer.uint32(50).bytes(message.earliestHash); } return writer; }, @@ -2670,12 +2702,40 @@ export const StorageLimit = { message.storeType = reader.int32() as any; continue; case 2: - if (tag != 16) { + if (tag != 18) { + break; + } + + message.name = reader.string(); + continue; + case 3: + if (tag != 24) { break; } message.limit = longToNumber(reader.uint64() as Long); continue; + case 4: + if (tag != 32) { + break; + } + + message.used = longToNumber(reader.uint64() as Long); + continue; + case 5: + if (tag != 40) { + break; + } + + message.earliestTimestamp = longToNumber(reader.uint64() as Long); + continue; + case 6: + if (tag != 50) { + break; + } + + message.earliestHash = reader.bytes(); + continue; } if ((tag & 7) == 4 || tag == 0) { break; @@ -2688,14 +2748,25 @@ export const StorageLimit = { fromJSON(object: any): StorageLimit { return { storeType: isSet(object.storeType) ? storeTypeFromJSON(object.storeType) : 0, + name: isSet(object.name) ? String(object.name) : "", limit: isSet(object.limit) ? Number(object.limit) : 0, + used: isSet(object.used) ? Number(object.used) : 0, + earliestTimestamp: isSet(object.earliestTimestamp) ? Number(object.earliestTimestamp) : 0, + earliestHash: isSet(object.earliestHash) ? bytesFromBase64(object.earliestHash) : new Uint8Array(), }; }, toJSON(message: StorageLimit): unknown { const obj: any = {}; message.storeType !== undefined && (obj.storeType = storeTypeToJSON(message.storeType)); + message.name !== undefined && (obj.name = message.name); message.limit !== undefined && (obj.limit = Math.round(message.limit)); + message.used !== undefined && (obj.used = Math.round(message.used)); + message.earliestTimestamp !== undefined && (obj.earliestTimestamp = Math.round(message.earliestTimestamp)); + message.earliestHash !== undefined && + (obj.earliestHash = base64FromBytes( + message.earliestHash !== undefined ? message.earliestHash : new Uint8Array(), + )); return obj; }, @@ -2706,7 +2777,11 @@ export const StorageLimit = { fromPartial, I>>(object: I): StorageLimit { const message = createBaseStorageLimit(); message.storeType = object.storeType ?? 0; + message.name = object.name ?? ""; message.limit = object.limit ?? 0; + message.used = object.used ?? 0; + message.earliestTimestamp = object.earliestTimestamp ?? 0; + message.earliestHash = object.earliestHash ?? new Uint8Array(); return message; }, }; diff --git a/packages/hub-nodejs/src/generated/request_response.ts b/packages/hub-nodejs/src/generated/request_response.ts index 5c1aeb77c3..7595023cff 100644 --- a/packages/hub-nodejs/src/generated/request_response.ts +++ b/packages/hub-nodejs/src/generated/request_response.ts @@ -234,11 +234,16 @@ export interface OnChainEventResponse { export interface StorageLimitsResponse { limits: StorageLimit[]; + units: number; } export interface StorageLimit { storeType: StoreType; + name: string; limit: number; + used: number; + earliestTimestamp: number; + earliestHash: Uint8Array; } export interface UsernameProofRequest { @@ -2581,7 +2586,7 @@ export const OnChainEventResponse = { }; function createBaseStorageLimitsResponse(): StorageLimitsResponse { - return { limits: [] }; + return { limits: [], units: 0 }; } export const StorageLimitsResponse = { @@ -2589,6 +2594,9 @@ export const StorageLimitsResponse = { for (const v of message.limits) { StorageLimit.encode(v!, writer.uint32(10).fork()).ldelim(); } + if (message.units !== 0) { + writer.uint32(16).uint32(message.units); + } return writer; }, @@ -2606,6 +2614,13 @@ export const StorageLimitsResponse = { message.limits.push(StorageLimit.decode(reader, reader.uint32())); continue; + case 2: + if (tag != 16) { + break; + } + + message.units = reader.uint32(); + continue; } if ((tag & 7) == 4 || tag == 0) { break; @@ -2616,7 +2631,10 @@ export const StorageLimitsResponse = { }, fromJSON(object: any): StorageLimitsResponse { - return { limits: Array.isArray(object?.limits) ? object.limits.map((e: any) => StorageLimit.fromJSON(e)) : [] }; + return { + limits: Array.isArray(object?.limits) ? object.limits.map((e: any) => StorageLimit.fromJSON(e)) : [], + units: isSet(object.units) ? Number(object.units) : 0, + }; }, toJSON(message: StorageLimitsResponse): unknown { @@ -2626,6 +2644,7 @@ export const StorageLimitsResponse = { } else { obj.limits = []; } + message.units !== undefined && (obj.units = Math.round(message.units)); return obj; }, @@ -2636,12 +2655,13 @@ export const StorageLimitsResponse = { fromPartial, I>>(object: I): StorageLimitsResponse { const message = createBaseStorageLimitsResponse(); message.limits = object.limits?.map((e) => StorageLimit.fromPartial(e)) || []; + message.units = object.units ?? 0; return message; }, }; function createBaseStorageLimit(): StorageLimit { - return { storeType: 0, limit: 0 }; + return { storeType: 0, name: "", limit: 0, used: 0, earliestTimestamp: 0, earliestHash: new Uint8Array() }; } export const StorageLimit = { @@ -2649,8 +2669,20 @@ export const StorageLimit = { if (message.storeType !== 0) { writer.uint32(8).int32(message.storeType); } + if (message.name !== "") { + writer.uint32(18).string(message.name); + } if (message.limit !== 0) { - writer.uint32(16).uint64(message.limit); + writer.uint32(24).uint64(message.limit); + } + if (message.used !== 0) { + writer.uint32(32).uint64(message.used); + } + if (message.earliestTimestamp !== 0) { + writer.uint32(40).uint64(message.earliestTimestamp); + } + if (message.earliestHash.length !== 0) { + writer.uint32(50).bytes(message.earliestHash); } return writer; }, @@ -2670,12 +2702,40 @@ export const StorageLimit = { message.storeType = reader.int32() as any; continue; case 2: - if (tag != 16) { + if (tag != 18) { + break; + } + + message.name = reader.string(); + continue; + case 3: + if (tag != 24) { break; } message.limit = longToNumber(reader.uint64() as Long); continue; + case 4: + if (tag != 32) { + break; + } + + message.used = longToNumber(reader.uint64() as Long); + continue; + case 5: + if (tag != 40) { + break; + } + + message.earliestTimestamp = longToNumber(reader.uint64() as Long); + continue; + case 6: + if (tag != 50) { + break; + } + + message.earliestHash = reader.bytes(); + continue; } if ((tag & 7) == 4 || tag == 0) { break; @@ -2688,14 +2748,25 @@ export const StorageLimit = { fromJSON(object: any): StorageLimit { return { storeType: isSet(object.storeType) ? storeTypeFromJSON(object.storeType) : 0, + name: isSet(object.name) ? String(object.name) : "", limit: isSet(object.limit) ? Number(object.limit) : 0, + used: isSet(object.used) ? Number(object.used) : 0, + earliestTimestamp: isSet(object.earliestTimestamp) ? Number(object.earliestTimestamp) : 0, + earliestHash: isSet(object.earliestHash) ? bytesFromBase64(object.earliestHash) : new Uint8Array(), }; }, toJSON(message: StorageLimit): unknown { const obj: any = {}; message.storeType !== undefined && (obj.storeType = storeTypeToJSON(message.storeType)); + message.name !== undefined && (obj.name = message.name); message.limit !== undefined && (obj.limit = Math.round(message.limit)); + message.used !== undefined && (obj.used = Math.round(message.used)); + message.earliestTimestamp !== undefined && (obj.earliestTimestamp = Math.round(message.earliestTimestamp)); + message.earliestHash !== undefined && + (obj.earliestHash = base64FromBytes( + message.earliestHash !== undefined ? message.earliestHash : new Uint8Array(), + )); return obj; }, @@ -2706,7 +2777,11 @@ export const StorageLimit = { fromPartial, I>>(object: I): StorageLimit { const message = createBaseStorageLimit(); message.storeType = object.storeType ?? 0; + message.name = object.name ?? ""; message.limit = object.limit ?? 0; + message.used = object.used ?? 0; + message.earliestTimestamp = object.earliestTimestamp ?? 0; + message.earliestHash = object.earliestHash ?? new Uint8Array(); return message; }, }; diff --git a/packages/hub-web/src/generated/request_response.ts b/packages/hub-web/src/generated/request_response.ts index 5c1aeb77c3..7595023cff 100644 --- a/packages/hub-web/src/generated/request_response.ts +++ b/packages/hub-web/src/generated/request_response.ts @@ -234,11 +234,16 @@ export interface OnChainEventResponse { export interface StorageLimitsResponse { limits: StorageLimit[]; + units: number; } export interface StorageLimit { storeType: StoreType; + name: string; limit: number; + used: number; + earliestTimestamp: number; + earliestHash: Uint8Array; } export interface UsernameProofRequest { @@ -2581,7 +2586,7 @@ export const OnChainEventResponse = { }; function createBaseStorageLimitsResponse(): StorageLimitsResponse { - return { limits: [] }; + return { limits: [], units: 0 }; } export const StorageLimitsResponse = { @@ -2589,6 +2594,9 @@ export const StorageLimitsResponse = { for (const v of message.limits) { StorageLimit.encode(v!, writer.uint32(10).fork()).ldelim(); } + if (message.units !== 0) { + writer.uint32(16).uint32(message.units); + } return writer; }, @@ -2606,6 +2614,13 @@ export const StorageLimitsResponse = { message.limits.push(StorageLimit.decode(reader, reader.uint32())); continue; + case 2: + if (tag != 16) { + break; + } + + message.units = reader.uint32(); + continue; } if ((tag & 7) == 4 || tag == 0) { break; @@ -2616,7 +2631,10 @@ export const StorageLimitsResponse = { }, fromJSON(object: any): StorageLimitsResponse { - return { limits: Array.isArray(object?.limits) ? object.limits.map((e: any) => StorageLimit.fromJSON(e)) : [] }; + return { + limits: Array.isArray(object?.limits) ? object.limits.map((e: any) => StorageLimit.fromJSON(e)) : [], + units: isSet(object.units) ? Number(object.units) : 0, + }; }, toJSON(message: StorageLimitsResponse): unknown { @@ -2626,6 +2644,7 @@ export const StorageLimitsResponse = { } else { obj.limits = []; } + message.units !== undefined && (obj.units = Math.round(message.units)); return obj; }, @@ -2636,12 +2655,13 @@ export const StorageLimitsResponse = { fromPartial, I>>(object: I): StorageLimitsResponse { const message = createBaseStorageLimitsResponse(); message.limits = object.limits?.map((e) => StorageLimit.fromPartial(e)) || []; + message.units = object.units ?? 0; return message; }, }; function createBaseStorageLimit(): StorageLimit { - return { storeType: 0, limit: 0 }; + return { storeType: 0, name: "", limit: 0, used: 0, earliestTimestamp: 0, earliestHash: new Uint8Array() }; } export const StorageLimit = { @@ -2649,8 +2669,20 @@ export const StorageLimit = { if (message.storeType !== 0) { writer.uint32(8).int32(message.storeType); } + if (message.name !== "") { + writer.uint32(18).string(message.name); + } if (message.limit !== 0) { - writer.uint32(16).uint64(message.limit); + writer.uint32(24).uint64(message.limit); + } + if (message.used !== 0) { + writer.uint32(32).uint64(message.used); + } + if (message.earliestTimestamp !== 0) { + writer.uint32(40).uint64(message.earliestTimestamp); + } + if (message.earliestHash.length !== 0) { + writer.uint32(50).bytes(message.earliestHash); } return writer; }, @@ -2670,12 +2702,40 @@ export const StorageLimit = { message.storeType = reader.int32() as any; continue; case 2: - if (tag != 16) { + if (tag != 18) { + break; + } + + message.name = reader.string(); + continue; + case 3: + if (tag != 24) { break; } message.limit = longToNumber(reader.uint64() as Long); continue; + case 4: + if (tag != 32) { + break; + } + + message.used = longToNumber(reader.uint64() as Long); + continue; + case 5: + if (tag != 40) { + break; + } + + message.earliestTimestamp = longToNumber(reader.uint64() as Long); + continue; + case 6: + if (tag != 50) { + break; + } + + message.earliestHash = reader.bytes(); + continue; } if ((tag & 7) == 4 || tag == 0) { break; @@ -2688,14 +2748,25 @@ export const StorageLimit = { fromJSON(object: any): StorageLimit { return { storeType: isSet(object.storeType) ? storeTypeFromJSON(object.storeType) : 0, + name: isSet(object.name) ? String(object.name) : "", limit: isSet(object.limit) ? Number(object.limit) : 0, + used: isSet(object.used) ? Number(object.used) : 0, + earliestTimestamp: isSet(object.earliestTimestamp) ? Number(object.earliestTimestamp) : 0, + earliestHash: isSet(object.earliestHash) ? bytesFromBase64(object.earliestHash) : new Uint8Array(), }; }, toJSON(message: StorageLimit): unknown { const obj: any = {}; message.storeType !== undefined && (obj.storeType = storeTypeToJSON(message.storeType)); + message.name !== undefined && (obj.name = message.name); message.limit !== undefined && (obj.limit = Math.round(message.limit)); + message.used !== undefined && (obj.used = Math.round(message.used)); + message.earliestTimestamp !== undefined && (obj.earliestTimestamp = Math.round(message.earliestTimestamp)); + message.earliestHash !== undefined && + (obj.earliestHash = base64FromBytes( + message.earliestHash !== undefined ? message.earliestHash : new Uint8Array(), + )); return obj; }, @@ -2706,7 +2777,11 @@ export const StorageLimit = { fromPartial, I>>(object: I): StorageLimit { const message = createBaseStorageLimit(); message.storeType = object.storeType ?? 0; + message.name = object.name ?? ""; message.limit = object.limit ?? 0; + message.used = object.used ?? 0; + message.earliestTimestamp = object.earliestTimestamp ?? 0; + message.earliestHash = object.earliestHash ?? new Uint8Array(); return message; }, }; diff --git a/packages/hub-web/src/generated/rpc.ts b/packages/hub-web/src/generated/rpc.ts index 2992161d39..dc0db5afec 100644 --- a/packages/hub-web/src/generated/rpc.ts +++ b/packages/hub-web/src/generated/rpc.ts @@ -1,5 +1,5 @@ /* eslint-disable */ -import { grpc } from "@improbable-eng/grpc-web"; +import grpcWeb from "@improbable-eng/grpc-web"; import { BrowserHeaders } from "browser-headers"; import { Observable } from "rxjs"; import { share } from "rxjs/operators"; @@ -43,122 +43,122 @@ import { UserNameProof } from "./username_proof"; export interface HubService { /** Submit Methods */ - submitMessage(request: DeepPartial, metadata?: grpc.Metadata): Promise; + submitMessage(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** * Event Methods * @http-api: none */ - subscribe(request: DeepPartial, metadata?: grpc.Metadata): Observable; + subscribe(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Observable; /** @http-api: events */ - getEvent(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getEvent(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** * Casts * @http-api: castById */ - getCast(request: DeepPartial, metadata?: grpc.Metadata): Promise; - getCastsByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise; - getCastsByParent(request: DeepPartial, metadata?: grpc.Metadata): Promise; - getCastsByMention(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getCast(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; + getCastsByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; + getCastsByParent(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; + getCastsByMention(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** * Reactions * @http-api: reactionById */ - getReaction(request: DeepPartial, metadata?: grpc.Metadata): Promise; - getReactionsByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getReaction(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; + getReactionsByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** To be deprecated */ getReactionsByCast( request: DeepPartial, - metadata?: grpc.Metadata, + metadata?: grpcWeb.grpc.Metadata, ): Promise; getReactionsByTarget( request: DeepPartial, - metadata?: grpc.Metadata, + metadata?: grpcWeb.grpc.Metadata, ): Promise; /** * User Data * @http-api: none */ - getUserData(request: DeepPartial, metadata?: grpc.Metadata): Promise; - getUserDataByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getUserData(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; + getUserDataByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** * Username Proof * @http-api: userNameProofByName */ - getUsernameProof(request: DeepPartial, metadata?: grpc.Metadata): Promise; - getUserNameProofsByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getUsernameProof(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; + getUserNameProofsByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** * Verifications * @http-api: none */ - getVerification(request: DeepPartial, metadata?: grpc.Metadata): Promise; - getVerificationsByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getVerification(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; + getVerificationsByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** * OnChain Events * @http-api: none */ - getOnChainSigner(request: DeepPartial, metadata?: grpc.Metadata): Promise; - getOnChainSignersByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getOnChainSigner(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; + getOnChainSignersByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** @http-api: none */ - getOnChainEvents(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getOnChainEvents(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** @http-api: none */ - getIdRegistryOnChainEvent(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getIdRegistryOnChainEvent(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** @http-api: onChainIdRegistryEventByAddress */ getIdRegistryOnChainEventByAddress( request: DeepPartial, - metadata?: grpc.Metadata, + metadata?: grpcWeb.grpc.Metadata, ): Promise; /** @http-api: storageLimitsByFid */ getCurrentStorageLimitsByFid( request: DeepPartial, - metadata?: grpc.Metadata, + metadata?: grpcWeb.grpc.Metadata, ): Promise; - getFids(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getFids(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** * Links * @http-api: linkById */ - getLink(request: DeepPartial, metadata?: grpc.Metadata): Promise; - getLinksByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getLink(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; + getLinksByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** @http-api: linksByTargetFid */ - getLinksByTarget(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getLinksByTarget(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** * Bulk Methods * The Bulk methods don't have corresponding HTTP API endpoints because the * regular endpoints can be used to get all the messages * @http-api: none */ - getAllCastMessagesByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getAllCastMessagesByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** @http-api: none */ - getAllReactionMessagesByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getAllReactionMessagesByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** @http-api: none */ getAllVerificationMessagesByFid( request: DeepPartial, - metadata?: grpc.Metadata, + metadata?: grpcWeb.grpc.Metadata, ): Promise; /** @http-api: none */ - getAllUserDataMessagesByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getAllUserDataMessagesByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** @http-api: none */ - getAllLinkMessagesByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getAllLinkMessagesByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** * Sync Methods * Outside the "info" RPC, the HTTP API doesn't implement any of the sync methods */ - getInfo(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getInfo(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** @http-api: none */ - getSyncStatus(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getSyncStatus(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** @http-api: none */ - getAllSyncIdsByPrefix(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getAllSyncIdsByPrefix(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** @http-api: none */ - getAllMessagesBySyncIds(request: DeepPartial, metadata?: grpc.Metadata): Promise; + getAllMessagesBySyncIds(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; /** @http-api: none */ getSyncMetadataByPrefix( request: DeepPartial, - metadata?: grpc.Metadata, + metadata?: grpcWeb.grpc.Metadata, ): Promise; /** @http-api: none */ getSyncSnapshotByPrefix( request: DeepPartial, - metadata?: grpc.Metadata, + metadata?: grpcWeb.grpc.Metadata, ): Promise; } @@ -207,99 +207,99 @@ export class HubServiceClientImpl implements HubService { this.getSyncSnapshotByPrefix = this.getSyncSnapshotByPrefix.bind(this); } - submitMessage(request: DeepPartial, metadata?: grpc.Metadata): Promise { + submitMessage(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceSubmitMessageDesc, Message.fromPartial(request), metadata); } - subscribe(request: DeepPartial, metadata?: grpc.Metadata): Observable { + subscribe(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Observable { return this.rpc.invoke(HubServiceSubscribeDesc, SubscribeRequest.fromPartial(request), metadata); } - getEvent(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getEvent(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetEventDesc, EventRequest.fromPartial(request), metadata); } - getCast(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getCast(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetCastDesc, CastId.fromPartial(request), metadata); } - getCastsByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getCastsByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetCastsByFidDesc, FidRequest.fromPartial(request), metadata); } - getCastsByParent(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getCastsByParent(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetCastsByParentDesc, CastsByParentRequest.fromPartial(request), metadata); } - getCastsByMention(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getCastsByMention(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetCastsByMentionDesc, FidRequest.fromPartial(request), metadata); } - getReaction(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getReaction(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetReactionDesc, ReactionRequest.fromPartial(request), metadata); } - getReactionsByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getReactionsByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetReactionsByFidDesc, ReactionsByFidRequest.fromPartial(request), metadata); } getReactionsByCast( request: DeepPartial, - metadata?: grpc.Metadata, + metadata?: grpcWeb.grpc.Metadata, ): Promise { return this.rpc.unary(HubServiceGetReactionsByCastDesc, ReactionsByTargetRequest.fromPartial(request), metadata); } getReactionsByTarget( request: DeepPartial, - metadata?: grpc.Metadata, + metadata?: grpcWeb.grpc.Metadata, ): Promise { return this.rpc.unary(HubServiceGetReactionsByTargetDesc, ReactionsByTargetRequest.fromPartial(request), metadata); } - getUserData(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getUserData(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetUserDataDesc, UserDataRequest.fromPartial(request), metadata); } - getUserDataByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getUserDataByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetUserDataByFidDesc, FidRequest.fromPartial(request), metadata); } - getUsernameProof(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getUsernameProof(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetUsernameProofDesc, UsernameProofRequest.fromPartial(request), metadata); } - getUserNameProofsByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getUserNameProofsByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetUserNameProofsByFidDesc, FidRequest.fromPartial(request), metadata); } - getVerification(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getVerification(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetVerificationDesc, VerificationRequest.fromPartial(request), metadata); } - getVerificationsByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getVerificationsByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetVerificationsByFidDesc, FidRequest.fromPartial(request), metadata); } - getOnChainSigner(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getOnChainSigner(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetOnChainSignerDesc, SignerRequest.fromPartial(request), metadata); } - getOnChainSignersByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getOnChainSignersByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetOnChainSignersByFidDesc, FidRequest.fromPartial(request), metadata); } - getOnChainEvents(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getOnChainEvents(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetOnChainEventsDesc, OnChainEventRequest.fromPartial(request), metadata); } - getIdRegistryOnChainEvent(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getIdRegistryOnChainEvent(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetIdRegistryOnChainEventDesc, FidRequest.fromPartial(request), metadata); } getIdRegistryOnChainEventByAddress( request: DeepPartial, - metadata?: grpc.Metadata, + metadata?: grpcWeb.grpc.Metadata, ): Promise { return this.rpc.unary( HubServiceGetIdRegistryOnChainEventByAddressDesc, @@ -310,76 +310,76 @@ export class HubServiceClientImpl implements HubService { getCurrentStorageLimitsByFid( request: DeepPartial, - metadata?: grpc.Metadata, + metadata?: grpcWeb.grpc.Metadata, ): Promise { return this.rpc.unary(HubServiceGetCurrentStorageLimitsByFidDesc, FidRequest.fromPartial(request), metadata); } - getFids(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getFids(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetFidsDesc, FidsRequest.fromPartial(request), metadata); } - getLink(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getLink(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetLinkDesc, LinkRequest.fromPartial(request), metadata); } - getLinksByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getLinksByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetLinksByFidDesc, LinksByFidRequest.fromPartial(request), metadata); } - getLinksByTarget(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getLinksByTarget(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetLinksByTargetDesc, LinksByTargetRequest.fromPartial(request), metadata); } - getAllCastMessagesByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getAllCastMessagesByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetAllCastMessagesByFidDesc, FidRequest.fromPartial(request), metadata); } - getAllReactionMessagesByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getAllReactionMessagesByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetAllReactionMessagesByFidDesc, FidRequest.fromPartial(request), metadata); } getAllVerificationMessagesByFid( request: DeepPartial, - metadata?: grpc.Metadata, + metadata?: grpcWeb.grpc.Metadata, ): Promise { return this.rpc.unary(HubServiceGetAllVerificationMessagesByFidDesc, FidRequest.fromPartial(request), metadata); } - getAllUserDataMessagesByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getAllUserDataMessagesByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetAllUserDataMessagesByFidDesc, FidRequest.fromPartial(request), metadata); } - getAllLinkMessagesByFid(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getAllLinkMessagesByFid(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetAllLinkMessagesByFidDesc, FidRequest.fromPartial(request), metadata); } - getInfo(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getInfo(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetInfoDesc, HubInfoRequest.fromPartial(request), metadata); } - getSyncStatus(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getSyncStatus(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetSyncStatusDesc, SyncStatusRequest.fromPartial(request), metadata); } - getAllSyncIdsByPrefix(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getAllSyncIdsByPrefix(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetAllSyncIdsByPrefixDesc, TrieNodePrefix.fromPartial(request), metadata); } - getAllMessagesBySyncIds(request: DeepPartial, metadata?: grpc.Metadata): Promise { + getAllMessagesBySyncIds(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(HubServiceGetAllMessagesBySyncIdsDesc, SyncIds.fromPartial(request), metadata); } getSyncMetadataByPrefix( request: DeepPartial, - metadata?: grpc.Metadata, + metadata?: grpcWeb.grpc.Metadata, ): Promise { return this.rpc.unary(HubServiceGetSyncMetadataByPrefixDesc, TrieNodePrefix.fromPartial(request), metadata); } getSyncSnapshotByPrefix( request: DeepPartial, - metadata?: grpc.Metadata, + metadata?: grpcWeb.grpc.Metadata, ): Promise { return this.rpc.unary(HubServiceGetSyncSnapshotByPrefixDesc, TrieNodePrefix.fromPartial(request), metadata); } @@ -1262,9 +1262,9 @@ export const HubServiceGetSyncSnapshotByPrefixDesc: UnaryMethodDefinitionish = { }; export interface AdminService { - rebuildSyncTrie(request: DeepPartial, metadata?: grpc.Metadata): Promise; - deleteAllMessagesFromDb(request: DeepPartial, metadata?: grpc.Metadata): Promise; - submitOnChainEvent(request: DeepPartial, metadata?: grpc.Metadata): Promise; + rebuildSyncTrie(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; + deleteAllMessagesFromDb(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; + submitOnChainEvent(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise; } export class AdminServiceClientImpl implements AdminService { @@ -1277,15 +1277,15 @@ export class AdminServiceClientImpl implements AdminService { this.submitOnChainEvent = this.submitOnChainEvent.bind(this); } - rebuildSyncTrie(request: DeepPartial, metadata?: grpc.Metadata): Promise { + rebuildSyncTrie(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(AdminServiceRebuildSyncTrieDesc, Empty.fromPartial(request), metadata); } - deleteAllMessagesFromDb(request: DeepPartial, metadata?: grpc.Metadata): Promise { + deleteAllMessagesFromDb(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(AdminServiceDeleteAllMessagesFromDbDesc, Empty.fromPartial(request), metadata); } - submitOnChainEvent(request: DeepPartial, metadata?: grpc.Metadata): Promise { + submitOnChainEvent(request: DeepPartial, metadata?: grpcWeb.grpc.Metadata): Promise { return this.rpc.unary(AdminServiceSubmitOnChainEventDesc, OnChainEvent.fromPartial(request), metadata); } } @@ -1361,7 +1361,7 @@ export const AdminServiceSubmitOnChainEventDesc: UnaryMethodDefinitionish = { } as any, }; -interface UnaryMethodDefinitionishR extends grpc.UnaryMethodDefinition { +interface UnaryMethodDefinitionishR extends grpcWeb.grpc.UnaryMethodDefinition { requestStream: any; responseStream: any; } @@ -1372,32 +1372,32 @@ interface Rpc { unary( methodDesc: T, request: any, - metadata: grpc.Metadata | undefined, + metadata: grpcWeb.grpc.Metadata | undefined, ): Promise; invoke( methodDesc: T, request: any, - metadata: grpc.Metadata | undefined, + metadata: grpcWeb.grpc.Metadata | undefined, ): Observable; } export class GrpcWebImpl { private host: string; private options: { - transport?: grpc.TransportFactory; - streamingTransport?: grpc.TransportFactory; + transport?: grpcWeb.grpc.TransportFactory; + streamingTransport?: grpcWeb.grpc.TransportFactory; debug?: boolean; - metadata?: grpc.Metadata; + metadata?: grpcWeb.grpc.Metadata; upStreamRetryCodes?: number[]; }; constructor( host: string, options: { - transport?: grpc.TransportFactory; - streamingTransport?: grpc.TransportFactory; + transport?: grpcWeb.grpc.TransportFactory; + streamingTransport?: grpcWeb.grpc.TransportFactory; debug?: boolean; - metadata?: grpc.Metadata; + metadata?: grpcWeb.grpc.Metadata; upStreamRetryCodes?: number[]; }, ) { @@ -1408,21 +1408,21 @@ export class GrpcWebImpl { unary( methodDesc: T, _request: any, - metadata: grpc.Metadata | undefined, + metadata: grpcWeb.grpc.Metadata | undefined, ): Promise { const request = { ..._request, ...methodDesc.requestType }; const maybeCombinedMetadata = metadata && this.options.metadata ? new BrowserHeaders({ ...this.options?.metadata.headersMap, ...metadata?.headersMap }) : metadata || this.options.metadata; return new Promise((resolve, reject) => { - grpc.unary(methodDesc, { + grpcWeb.grpc.unary(methodDesc, { request, host: this.host, metadata: maybeCombinedMetadata, transport: this.options.transport, debug: this.options.debug, onEnd: function (response) { - if (response.status === grpc.Code.OK) { + if (response.status === grpcWeb.grpc.Code.OK) { resolve(response.message!.toObject()); } else { const err = new GrpcWebError(response.statusMessage, response.status, response.trailers); @@ -1436,7 +1436,7 @@ export class GrpcWebImpl { invoke( methodDesc: T, _request: any, - metadata: grpc.Metadata | undefined, + metadata: grpcWeb.grpc.Metadata | undefined, ): Observable { const upStreamCodes = this.options.upStreamRetryCodes || []; const DEFAULT_TIMEOUT_TIME: number = 3_000; @@ -1446,14 +1446,14 @@ export class GrpcWebImpl { : metadata || this.options.metadata; return new Observable((observer) => { const upStream = (() => { - const client = grpc.invoke(methodDesc, { + const client = grpcWeb.grpc.invoke(methodDesc, { host: this.host, request, transport: this.options.streamingTransport || this.options.transport, metadata: maybeCombinedMetadata, debug: this.options.debug, onMessage: (next) => observer.next(next), - onEnd: (code: grpc.Code, message: string, trailers: grpc.Metadata) => { + onEnd: (code: grpcWeb.grpc.Code, message: string, trailers: grpcWeb.grpc.Metadata) => { if (code === 0) { observer.complete(); } else if (upStreamCodes.includes(code)) { @@ -1504,7 +1504,7 @@ type DeepPartial = T extends Builtin ? T : Partial; export class GrpcWebError extends tsProtoGlobalThis.Error { - constructor(message: string, public code: grpc.Code, public metadata: grpc.Metadata) { + constructor(message: string, public code: grpcWeb.grpc.Code, public metadata: grpcWeb.grpc.Metadata) { super(message); } } diff --git a/protobufs/schemas/request_response.proto b/protobufs/schemas/request_response.proto index bde5fb3ec4..b241eb4479 100644 --- a/protobufs/schemas/request_response.proto +++ b/protobufs/schemas/request_response.proto @@ -170,6 +170,7 @@ message OnChainEventResponse { message StorageLimitsResponse { repeated StorageLimit limits = 1; + uint32 units = 2; } enum StoreType { @@ -184,7 +185,11 @@ enum StoreType { message StorageLimit { StoreType store_type = 1; - uint64 limit = 2; + string name = 2; + uint64 limit = 3; + uint64 used = 4; + uint64 earliestTimestamp = 5; + bytes earliestHash = 6; } message UsernameProofRequest {