@latticexyz/services 2.0.0-snapshot-test-32d38619 → 2.0.0

package/README.md

@@ -1,241 +1 @@
-# Services
-
-This package contains MUD services -- complimentary software components for enhanced interactions with on-chain state when building with MUD. Services work out-of-the-box with any project built with MUD.
-
-## V2 Services
-
-### [📄 Docs](#)
-
-The following services are available for use with MUD V2. For more details on each service, see the linked docs page.
-
-| Service | Description                                                                           | Proto / Spec                     | Default Port |
-| ------- | :------------------------------------------------------------------------------------ | :------------------------------- | -----------: |
-| mode    | A node for MUD. PostgresDB-based indexer of MUD V2 events across chains + MUD worlds. | [mode.proto](./proto/mode.proto) |        50091 |
-
-### 🏃 Quickstart
-
-#### Running MODE with Docker Compose
-
-(Only tested on MacOS for now.)
-
-1. Install Docker for Mac (https://docs.docker.com/docker-for-mac/install/)
-2. Install Docker Compose (https://docs.docker.com/compose/install/)
-3. Run `docker-compose -f docker-compose.mode.yaml up`. This will start services for both MODE and PostgresDB.
-4. By default it will connect to a local anvil node at `localhost:8545`. If you want to connect to a different node, you can change the `rpc.http` and `rpc.ws` fields in the `config.mode-docker.yaml` file.
-
-#### Running the MODE service
-
-1. Install Go
-2. Install Postgres
-3. Deside which database you want to use, e.g. `mode` and create the database
-4. Set up logical replication on the database of your choice, e.g. `mode`. Logical replication is used to enable fast MUD state change streaming using the WAL (Write-Ahead Log) of the database. For more infromation on logical replication, see the [Postgres documentation](https://www.postgresql.org/docs/current/logical-replication.html). For this you need to
-   1. Modify the DB config to use logical replication. This is done by adding the following to the `postgresql.conf` file:
-      ```
-      wal_level = logical
-      max_replication_slots = 1
-      max_wal_senders = 1
-      ```
-      alternatively you can use the following SQL commands:
-      ```sql
-      ALTER SYSTEM SET wal_level = logical;
-      ALTER SYSTEM SET max_replication_slots = 1;
-      ALTER SYSTEM SET max_wal_senders = 1;
-      ```
-   2. Restart the DB
-5. Build the source. This will build the MODE service
-
-```bash
-make mode
-```
-
-6. Modify `config.mode.yaml` MODE config file to match your preferences. MODE can be configured either with a config file or via command line arguments (both will do the same thing). In this step you should probably change the `dsn` section to match your database name created in step (3): this is what MODE uses to connect to Postgres. Additionally change the `chains` section in case you'd like to connect and have MODE index a different chain other than a local node. You can also change the `port`s to match your preferences. Example config file:
-
-```yaml
-chains:
-  - name: "localhost"
-    id: "31337"
-    rpc:
-      http: "http://localhost:8545"
-      ws: "ws://localhost:8545"
-db:
-  dsn: "postgresql://localhost:5432/mode_ephemeral?sslmode=disable&replication=database"
-  wipe: false
-sync:
-  enabled: true
-  startBlock: 0
-  blockBatchCount: 10000
-ql:
-  port: 50091
-metrics:
-  port: 6060
-```
-
-7. If you're running with the default localhost / `31337` chain, make sure there is a local node running for the chain you want to connect to. For example, a hardhat node or an anvil node.
-8. Run the MODE service
-
-```bash
-./bin/mode -config config.mode.yaml
-```
-
-or
-
-```bash
-make run-mode
-```
-
-9. Optionally, install `grpcurl` to interact with the MODE service API from the command line. For example, on MacOS you can use `brew` to install `grpcurl`:
-
-```bash
-brew install grpcurl
-```
-
-10. MODE exposes a `QueryLayer` gRPC server on port `50091` by default. You can use a gRPC client to interact with the service API. For example, to query for the current state of an indexed MUD world deployed at address `0xff738496c8cd898dC31b670D067162200C5c20A1` and on local chain with ID `31337`, you can use the `GetState` RPC endpoint:
-
-```bash
-grpcurl -plaintext -d '{"chainTables": [], "worldTables": [], "namespace": {"chainId":"31337", "worldAddress": "0xff738496c8cd898dC31b670D067162200C5c20A1"}}' localhost:50091 mode.QueryLayer/GetState
-```
-
-After the initial setup, to quickly re-build and run the MODE service, you can use
-
-```bash
-make mode run-mode
-```
-
-#### MODE and MUD
-
-Certain parts of MODE depend on MUD, specifically the `storecore` package of MODE which allows us to work with data coming from MUD and perfom encoding/decodings between MUD SchemaTypes, Go types, and Postgres types when the data is store in the DB. If modifications are made to MUD StoreCore, MODE `storecore.go` needs to be re-generated. To do this, perform these steps:
-
-1. Get the latest MUD StoreCore abi and save it to a file, e.g. `storecore.json` or `storecore.abi`. It should look something like this
-
-```json
-[
-  {
-    "anonymous": false,
-    "inputs": [
-      {
-        "indexed": false,
-        "internalType": "bytes32",
-        "name": "tableId",
-        "type": "bytes32"
-      },
-      {
-        "indexed": false,
-        "internalType": "bytes32[]",
-        "name": "key",
-        "type": "bytes32[]"
-      }
-    ],
-    "name": "StoreDeleteRecord",
-    "type": "event"
-  },
-  {
-    "anonymous": false,
-    "inputs": [
-      {
-        "indexed": false,
-        "internalType": "bytes32",
-        "name": "tableId",
-        "type": "bytes32"
-      },
-      {
-        "indexed": false,
-        "internalType": "bytes32[]",
-        "name": "key",
-        "type": "bytes32[]"
-      },
-      {
-        "indexed": false,
-        "internalType": "uint8",
-        "name": "schemaIndex",
-        "type": "uint8"
-      },
-      {
-        "indexed": false,
-        "internalType": "bytes",
-        "name": "data",
-        "type": "bytes"
-      }
-    ],
-    "name": "StoreSetField",
-    "type": "event"
-  },
-  {
-    "anonymous": false,
-    "inputs": [
-      {
-        "indexed": false,
-        "internalType": "bytes32",
-        "name": "tableId",
-        "type": "bytes32"
-      },
-      {
-        "indexed": false,
-        "internalType": "bytes32[]",
-        "name": "key",
-        "type": "bytes32[]"
-      },
-      {
-        "indexed": false,
-        "internalType": "bytes",
-        "name": "data",
-        "type": "bytes"
-      }
-    ],
-    "name": "StoreSetRecord",
-    "type": "event"
-  }
-]
-```
-
-2. Run the following command to generate the MODE `storecore.go` file:
-
-```bash
-abigen --abi storecore.abi --pkg storecore --out storecore.go
-```
-
-3. Copy the generated `storecore.go` file to the MODE `storecore` package. Alternatively, run the command in the storecore package directory and the file will overwrite the existing one.
-
-## V1 Services
-
-### [📄 Docs](./README.v1.md)
-
-The following services are available for use with MUD V1. For more details on each service, see the linked docs page.
-
-| Service      | Description                                                                                                                              | Proto / Spec                                     | Default Port |
-| ------------ | :--------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------- | -----------: |
-| ecs-snapshot | Indexer reducing ECS events into a single "current" state for fast snapshot client syncs                                                 | [ecs-snapshot.proto](./proto/ecs-snapshot.proto) |        50061 |
-| ecs-stream   | Multiplexer for subscriptions to receive current block data, ECS events per block, and transaction origination data                      | [ecs-stream.proto](./proto/ecs-stream.proto)     |        50051 |
-| ecs-relay    | Generic message relayer, supporting signed messages, service-side signature verification, relay conditions for DDoS prevention, and more | [ecs-relay.proto](./proto/ecs-relay.proto)       |        50071 |
-| faucet       | Faucet supporting custom drip amounts, global limits, twitter verification, and integrations with MUD components                         | [faucet.proto](./proto/faucet.proto)             |        50081 |
-
-### 🏃 Quickstart
-
-#### Running the ECS Snapshot, Stream, Relay, and Faucet services
-
-1. Install Go
-2. Build the source. This will build all the services
-
-```bash
-make build
-```
-
-or to build only specific services
-
-```bash
-make ecs-snapshot ecs-stream ecs-relay faucet
-```
-
-3. If you're running with the default chain, make sure there is a local node running for the chain you want to connect to. For example, a hardhat node or an anvil node.
-4. Run whichever binary via [`Makefile`](./Makefile). For example, to run the snapshot service
-
-```bash
-make run-ecs-snapshot
-```
-
-## Protobuf
-
-MUD services use [Protocol Buffers](https://developers.google.com/protocol-buffers) to define the data structures and message schemas. The `.proto` files are available in the `/proto` directory at the root of this repo. For more details about `.proto` files and a language guide, see the [Language Guide (proto3)](https://developers.google.com/protocol-buffers/docs/proto3). The package has the protobuf files checked in, but in case you want to regenerate those (based on an updated `.proto` file for instance), run
-
-```bash
-make protoc
-```
+# DEPRECATED

package/dist/faucet.d.ts

@@ -0,0 +1,369 @@
+import { CallContext, CallOptions } from 'nice-grpc-common';
+import _m0 from 'protobufjs/minimal.js';
+import { RawClient } from 'nice-grpc-web';
+import { FromTsProtoServiceDefinition } from 'nice-grpc-web/lib/service-definitions/ts-proto';
+
+declare const protobufPackage = "faucet";
+interface LinkedTwitterPair {
+    username: string;
+    address: string;
+}
+declare const LinkedTwitterPair: {
+    encode(message: LinkedTwitterPair, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): LinkedTwitterPair;
+    create(base?: DeepPartial<LinkedTwitterPair>): LinkedTwitterPair;
+    fromPartial(object: DeepPartial<LinkedTwitterPair>): LinkedTwitterPair;
+};
+interface FaucetStore {
+    addressToUsername: {
+        [key: string]: string;
+    };
+    usernameToAddress: {
+        [key: string]: string;
+    };
+    /** User id/name/address to timestamp of latest drip. */
+    latestDrip: {
+        [key: string]: number;
+    };
+    /** Global drip counter. */
+    totalDripCount: number;
+}
+declare const FaucetStore: {
+    encode(message: FaucetStore, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): FaucetStore;
+    create(base?: DeepPartial<FaucetStore>): FaucetStore;
+    fromPartial(object: DeepPartial<FaucetStore>): FaucetStore;
+};
+interface FaucetStore_AddressToUsernameEntry {
+    key: string;
+    value: string;
+}
+declare const FaucetStore_AddressToUsernameEntry: {
+    encode(message: FaucetStore_AddressToUsernameEntry, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): FaucetStore_AddressToUsernameEntry;
+    create(base?: DeepPartial<FaucetStore_AddressToUsernameEntry>): FaucetStore_AddressToUsernameEntry;
+    fromPartial(object: DeepPartial<FaucetStore_AddressToUsernameEntry>): FaucetStore_AddressToUsernameEntry;
+};
+interface FaucetStore_UsernameToAddressEntry {
+    key: string;
+    value: string;
+}
+declare const FaucetStore_UsernameToAddressEntry: {
+    encode(message: FaucetStore_UsernameToAddressEntry, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): FaucetStore_UsernameToAddressEntry;
+    create(base?: DeepPartial<FaucetStore_UsernameToAddressEntry>): FaucetStore_UsernameToAddressEntry;
+    fromPartial(object: DeepPartial<FaucetStore_UsernameToAddressEntry>): FaucetStore_UsernameToAddressEntry;
+};
+interface FaucetStore_LatestDripEntry {
+    key: string;
+    value: number;
+}
+declare const FaucetStore_LatestDripEntry: {
+    encode(message: FaucetStore_LatestDripEntry, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): FaucetStore_LatestDripEntry;
+    create(base?: DeepPartial<FaucetStore_LatestDripEntry>): FaucetStore_LatestDripEntry;
+    fromPartial(object: DeepPartial<FaucetStore_LatestDripEntry>): FaucetStore_LatestDripEntry;
+};
+/** Request for drip. */
+interface DripRequest {
+    username: string;
+    address: string;
+}
+declare const DripRequest: {
+    encode(message: DripRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): DripRequest;
+    create(base?: DeepPartial<DripRequest>): DripRequest;
+    fromPartial(object: DeepPartial<DripRequest>): DripRequest;
+};
+/** Request for drip to any address when running in dev mode. */
+interface DripDevRequest {
+    address: string;
+}
+declare const DripDevRequest: {
+    encode(message: DripDevRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): DripDevRequest;
+    create(base?: DeepPartial<DripDevRequest>): DripDevRequest;
+    fromPartial(object: DeepPartial<DripDevRequest>): DripDevRequest;
+};
+/** Response for drip request that contains the transaction hash of the drip tx and the ECS component set hash (if any). */
+interface DripResponse {
+    dripTxHash: string;
+    ecsTxHash: string;
+}
+declare const DripResponse: {
+    encode(message: DripResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): DripResponse;
+    create(base?: DeepPartial<DripResponse>): DripResponse;
+    fromPartial(object: DeepPartial<DripResponse>): DripResponse;
+};
+/** Response for the time until next drip request. */
+interface TimeUntilDripResponse {
+    timeUntilDripMinutes: number;
+    timeUntilDripSeconds: number;
+}
+declare const TimeUntilDripResponse: {
+    encode(message: TimeUntilDripResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): TimeUntilDripResponse;
+    create(base?: DeepPartial<TimeUntilDripResponse>): TimeUntilDripResponse;
+    fromPartial(object: DeepPartial<TimeUntilDripResponse>): TimeUntilDripResponse;
+};
+interface GetLinkedTwittersRequest {
+}
+declare const GetLinkedTwittersRequest: {
+    encode(_: GetLinkedTwittersRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GetLinkedTwittersRequest;
+    create(base?: DeepPartial<GetLinkedTwittersRequest>): GetLinkedTwittersRequest;
+    fromPartial(_: DeepPartial<GetLinkedTwittersRequest>): GetLinkedTwittersRequest;
+};
+interface GetLinkedTwittersResponse {
+    linkedTwitters: LinkedTwitterPair[];
+}
+declare const GetLinkedTwittersResponse: {
+    encode(message: GetLinkedTwittersResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): GetLinkedTwittersResponse;
+    create(base?: DeepPartial<GetLinkedTwittersResponse>): GetLinkedTwittersResponse;
+    fromPartial(object: DeepPartial<GetLinkedTwittersResponse>): GetLinkedTwittersResponse;
+};
+interface LinkedTwitterForAddressRequest {
+    address: string;
+}
+declare const LinkedTwitterForAddressRequest: {
+    encode(message: LinkedTwitterForAddressRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): LinkedTwitterForAddressRequest;
+    create(base?: DeepPartial<LinkedTwitterForAddressRequest>): LinkedTwitterForAddressRequest;
+    fromPartial(object: DeepPartial<LinkedTwitterForAddressRequest>): LinkedTwitterForAddressRequest;
+};
+interface LinkedTwitterForAddressResponse {
+    username: string;
+}
+declare const LinkedTwitterForAddressResponse: {
+    encode(message: LinkedTwitterForAddressResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): LinkedTwitterForAddressResponse;
+    create(base?: DeepPartial<LinkedTwitterForAddressResponse>): LinkedTwitterForAddressResponse;
+    fromPartial(object: DeepPartial<LinkedTwitterForAddressResponse>): LinkedTwitterForAddressResponse;
+};
+interface LinkedAddressForTwitterRequest {
+    username: string;
+}
+declare const LinkedAddressForTwitterRequest: {
+    encode(message: LinkedAddressForTwitterRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): LinkedAddressForTwitterRequest;
+    create(base?: DeepPartial<LinkedAddressForTwitterRequest>): LinkedAddressForTwitterRequest;
+    fromPartial(object: DeepPartial<LinkedAddressForTwitterRequest>): LinkedAddressForTwitterRequest;
+};
+interface LinkedAddressForTwitterResponse {
+    address: string;
+}
+declare const LinkedAddressForTwitterResponse: {
+    encode(message: LinkedAddressForTwitterResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): LinkedAddressForTwitterResponse;
+    create(base?: DeepPartial<LinkedAddressForTwitterResponse>): LinkedAddressForTwitterResponse;
+    fromPartial(object: DeepPartial<LinkedAddressForTwitterResponse>): LinkedAddressForTwitterResponse;
+};
+interface SetLinkedTwitterRequest {
+    address: string;
+    username: string;
+    signature: string;
+}
+declare const SetLinkedTwitterRequest: {
+    encode(message: SetLinkedTwitterRequest, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SetLinkedTwitterRequest;
+    create(base?: DeepPartial<SetLinkedTwitterRequest>): SetLinkedTwitterRequest;
+    fromPartial(object: DeepPartial<SetLinkedTwitterRequest>): SetLinkedTwitterRequest;
+};
+interface SetLinkedTwitterResponse {
+}
+declare const SetLinkedTwitterResponse: {
+    encode(_: SetLinkedTwitterResponse, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): SetLinkedTwitterResponse;
+    create(base?: DeepPartial<SetLinkedTwitterResponse>): SetLinkedTwitterResponse;
+    fromPartial(_: DeepPartial<SetLinkedTwitterResponse>): SetLinkedTwitterResponse;
+};
+/** The Faucet Service definition. */
+type FaucetServiceDefinition = typeof FaucetServiceDefinition;
+declare const FaucetServiceDefinition: {
+    readonly name: "FaucetService";
+    readonly fullName: "faucet.FaucetService";
+    readonly methods: {
+        readonly drip: {
+            readonly name: "Drip";
+            readonly requestType: {
+                encode(message: DripRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): DripRequest;
+                create(base?: DeepPartial<DripRequest>): DripRequest;
+                fromPartial(object: DeepPartial<DripRequest>): DripRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: DripResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): DripResponse;
+                create(base?: DeepPartial<DripResponse>): DripResponse;
+                fromPartial(object: DeepPartial<DripResponse>): DripResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly dripDev: {
+            readonly name: "DripDev";
+            readonly requestType: {
+                encode(message: DripDevRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): DripDevRequest;
+                create(base?: DeepPartial<DripDevRequest>): DripDevRequest;
+                fromPartial(object: DeepPartial<DripDevRequest>): DripDevRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: DripResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): DripResponse;
+                create(base?: DeepPartial<DripResponse>): DripResponse;
+                fromPartial(object: DeepPartial<DripResponse>): DripResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly dripVerifyTweet: {
+            readonly name: "DripVerifyTweet";
+            readonly requestType: {
+                encode(message: DripRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): DripRequest;
+                create(base?: DeepPartial<DripRequest>): DripRequest;
+                fromPartial(object: DeepPartial<DripRequest>): DripRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: DripResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): DripResponse;
+                create(base?: DeepPartial<DripResponse>): DripResponse;
+                fromPartial(object: DeepPartial<DripResponse>): DripResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly timeUntilDrip: {
+            readonly name: "TimeUntilDrip";
+            readonly requestType: {
+                encode(message: DripRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): DripRequest;
+                create(base?: DeepPartial<DripRequest>): DripRequest;
+                fromPartial(object: DeepPartial<DripRequest>): DripRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: TimeUntilDripResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): TimeUntilDripResponse;
+                create(base?: DeepPartial<TimeUntilDripResponse>): TimeUntilDripResponse;
+                fromPartial(object: DeepPartial<TimeUntilDripResponse>): TimeUntilDripResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly getLinkedTwitters: {
+            readonly name: "GetLinkedTwitters";
+            readonly requestType: {
+                encode(_: GetLinkedTwittersRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): GetLinkedTwittersRequest;
+                create(base?: DeepPartial<GetLinkedTwittersRequest>): GetLinkedTwittersRequest;
+                fromPartial(_: DeepPartial<GetLinkedTwittersRequest>): GetLinkedTwittersRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: GetLinkedTwittersResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): GetLinkedTwittersResponse;
+                create(base?: DeepPartial<GetLinkedTwittersResponse>): GetLinkedTwittersResponse;
+                fromPartial(object: DeepPartial<GetLinkedTwittersResponse>): GetLinkedTwittersResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly getLinkedTwitterForAddress: {
+            readonly name: "GetLinkedTwitterForAddress";
+            readonly requestType: {
+                encode(message: LinkedTwitterForAddressRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): LinkedTwitterForAddressRequest;
+                create(base?: DeepPartial<LinkedTwitterForAddressRequest>): LinkedTwitterForAddressRequest;
+                fromPartial(object: DeepPartial<LinkedTwitterForAddressRequest>): LinkedTwitterForAddressRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: LinkedTwitterForAddressResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): LinkedTwitterForAddressResponse;
+                create(base?: DeepPartial<LinkedTwitterForAddressResponse>): LinkedTwitterForAddressResponse;
+                fromPartial(object: DeepPartial<LinkedTwitterForAddressResponse>): LinkedTwitterForAddressResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly getLinkedAddressForTwitter: {
+            readonly name: "GetLinkedAddressForTwitter";
+            readonly requestType: {
+                encode(message: LinkedAddressForTwitterRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): LinkedAddressForTwitterRequest;
+                create(base?: DeepPartial<LinkedAddressForTwitterRequest>): LinkedAddressForTwitterRequest;
+                fromPartial(object: DeepPartial<LinkedAddressForTwitterRequest>): LinkedAddressForTwitterRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(message: LinkedAddressForTwitterResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): LinkedAddressForTwitterResponse;
+                create(base?: DeepPartial<LinkedAddressForTwitterResponse>): LinkedAddressForTwitterResponse;
+                fromPartial(object: DeepPartial<LinkedAddressForTwitterResponse>): LinkedAddressForTwitterResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Admin utility endpoints for modifying state. Requires a signature with faucet private key. */
+        readonly setLinkedTwitter: {
+            readonly name: "SetLinkedTwitter";
+            readonly requestType: {
+                encode(message: SetLinkedTwitterRequest, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): SetLinkedTwitterRequest;
+                create(base?: DeepPartial<SetLinkedTwitterRequest>): SetLinkedTwitterRequest;
+                fromPartial(object: DeepPartial<SetLinkedTwitterRequest>): SetLinkedTwitterRequest;
+            };
+            readonly requestStream: false;
+            readonly responseType: {
+                encode(_: SetLinkedTwitterResponse, writer?: _m0.Writer): _m0.Writer;
+                decode(input: _m0.Reader | Uint8Array, length?: number): SetLinkedTwitterResponse;
+                create(base?: DeepPartial<SetLinkedTwitterResponse>): SetLinkedTwitterResponse;
+                fromPartial(_: DeepPartial<SetLinkedTwitterResponse>): SetLinkedTwitterResponse;
+            };
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+interface FaucetServiceImplementation<CallContextExt = {}> {
+    drip(request: DripRequest, context: CallContext & CallContextExt): Promise<DeepPartial<DripResponse>>;
+    dripDev(request: DripDevRequest, context: CallContext & CallContextExt): Promise<DeepPartial<DripResponse>>;
+    dripVerifyTweet(request: DripRequest, context: CallContext & CallContextExt): Promise<DeepPartial<DripResponse>>;
+    timeUntilDrip(request: DripRequest, context: CallContext & CallContextExt): Promise<DeepPartial<TimeUntilDripResponse>>;
+    getLinkedTwitters(request: GetLinkedTwittersRequest, context: CallContext & CallContextExt): Promise<DeepPartial<GetLinkedTwittersResponse>>;
+    getLinkedTwitterForAddress(request: LinkedTwitterForAddressRequest, context: CallContext & CallContextExt): Promise<DeepPartial<LinkedTwitterForAddressResponse>>;
+    getLinkedAddressForTwitter(request: LinkedAddressForTwitterRequest, context: CallContext & CallContextExt): Promise<DeepPartial<LinkedAddressForTwitterResponse>>;
+    /** Admin utility endpoints for modifying state. Requires a signature with faucet private key. */
+    setLinkedTwitter(request: SetLinkedTwitterRequest, context: CallContext & CallContextExt): Promise<DeepPartial<SetLinkedTwitterResponse>>;
+}
+interface FaucetServiceClient<CallOptionsExt = {}> {
+    drip(request: DeepPartial<DripRequest>, options?: CallOptions & CallOptionsExt): Promise<DripResponse>;
+    dripDev(request: DeepPartial<DripDevRequest>, options?: CallOptions & CallOptionsExt): Promise<DripResponse>;
+    dripVerifyTweet(request: DeepPartial<DripRequest>, options?: CallOptions & CallOptionsExt): Promise<DripResponse>;
+    timeUntilDrip(request: DeepPartial<DripRequest>, options?: CallOptions & CallOptionsExt): Promise<TimeUntilDripResponse>;
+    getLinkedTwitters(request: DeepPartial<GetLinkedTwittersRequest>, options?: CallOptions & CallOptionsExt): Promise<GetLinkedTwittersResponse>;
+    getLinkedTwitterForAddress(request: DeepPartial<LinkedTwitterForAddressRequest>, options?: CallOptions & CallOptionsExt): Promise<LinkedTwitterForAddressResponse>;
+    getLinkedAddressForTwitter(request: DeepPartial<LinkedAddressForTwitterRequest>, options?: CallOptions & CallOptionsExt): Promise<LinkedAddressForTwitterResponse>;
+    /** Admin utility endpoints for modifying state. Requires a signature with faucet private key. */
+    setLinkedTwitter(request: DeepPartial<SetLinkedTwitterRequest>, options?: CallOptions & CallOptionsExt): Promise<SetLinkedTwitterResponse>;
+}
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial<T> = T extends Builtin ? T : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+
+/**
+ * Create a FaucetServiceClient
+ * @param url FaucetService URL
+ * @returns FaucetServiceClient
+ */
+declare function createFaucetService(url: string): RawClient<FromTsProtoServiceDefinition<typeof FaucetServiceDefinition>>;
+
+export { DeepPartial, DripDevRequest, DripRequest, DripResponse, FaucetServiceClient, FaucetServiceDefinition, FaucetServiceImplementation, FaucetStore, FaucetStore_AddressToUsernameEntry, FaucetStore_LatestDripEntry, FaucetStore_UsernameToAddressEntry, GetLinkedTwittersRequest, GetLinkedTwittersResponse, LinkedAddressForTwitterRequest, LinkedAddressForTwitterResponse, LinkedTwitterForAddressRequest, LinkedTwitterForAddressResponse, LinkedTwitterPair, SetLinkedTwitterRequest, SetLinkedTwitterResponse, TimeUntilDripResponse, createFaucetService, protobufPackage };