@dashevo/dapi-grpc 3.1.0-dev.1 → 3.1.0-dev.3

package/clients/platform/v0/web/platform_pb.d.ts

@@ -2250,6 +2250,11 @@ export class GetDocumentsRequest extends jspb.Message {
   getV0(): GetDocumentsRequest.GetDocumentsRequestV0 | undefined;
   setV0(value?: GetDocumentsRequest.GetDocumentsRequestV0): void;
 
+  hasV1(): boolean;
+  clearV1(): void;
+  getV1(): GetDocumentsRequest.GetDocumentsRequestV1 | undefined;
+  setV1(value?: GetDocumentsRequest.GetDocumentsRequestV1): void;
+
   getVersionCase(): GetDocumentsRequest.VersionCase;
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): GetDocumentsRequest.AsObject;
@@ -2264,6 +2269,305 @@ export class GetDocumentsRequest extends jspb.Message {
 export namespace GetDocumentsRequest {
   export type AsObject = {
     v0?: GetDocumentsRequest.GetDocumentsRequestV0.AsObject,
+    v1?: GetDocumentsRequest.GetDocumentsRequestV1.AsObject,
+  }
+
+  export class DocumentFieldValue extends jspb.Message {
+    hasBoolValue(): boolean;
+    clearBoolValue(): void;
+    getBoolValue(): boolean;
+    setBoolValue(value: boolean): void;
+
+    hasInt64Value(): boolean;
+    clearInt64Value(): void;
+    getInt64Value(): string;
+    setInt64Value(value: string): void;
+
+    hasUint64Value(): boolean;
+    clearUint64Value(): void;
+    getUint64Value(): string;
+    setUint64Value(value: string): void;
+
+    hasDoubleValue(): boolean;
+    clearDoubleValue(): void;
+    getDoubleValue(): number;
+    setDoubleValue(value: number): void;
+
+    hasText(): boolean;
+    clearText(): void;
+    getText(): string;
+    setText(value: string): void;
+
+    hasBytesValue(): boolean;
+    clearBytesValue(): void;
+    getBytesValue(): Uint8Array | string;
+    getBytesValue_asU8(): Uint8Array;
+    getBytesValue_asB64(): string;
+    setBytesValue(value: Uint8Array | string): void;
+
+    hasList(): boolean;
+    clearList(): void;
+    getList(): GetDocumentsRequest.DocumentFieldValue.ValueList | undefined;
+    setList(value?: GetDocumentsRequest.DocumentFieldValue.ValueList): void;
+
+    hasNullValue(): boolean;
+    clearNullValue(): void;
+    getNullValue(): boolean;
+    setNullValue(value: boolean): void;
+
+    getVariantCase(): DocumentFieldValue.VariantCase;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): DocumentFieldValue.AsObject;
+    static toObject(includeInstance: boolean, msg: DocumentFieldValue): DocumentFieldValue.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: DocumentFieldValue, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): DocumentFieldValue;
+    static deserializeBinaryFromReader(message: DocumentFieldValue, reader: jspb.BinaryReader): DocumentFieldValue;
+  }
+
+  export namespace DocumentFieldValue {
+    export type AsObject = {
+      boolValue: boolean,
+      int64Value: string,
+      uint64Value: string,
+      doubleValue: number,
+      text: string,
+      bytesValue: Uint8Array | string,
+      list?: GetDocumentsRequest.DocumentFieldValue.ValueList.AsObject,
+      nullValue: boolean,
+    }
+
+    export class ValueList extends jspb.Message {
+      clearValuesList(): void;
+      getValuesList(): Array<GetDocumentsRequest.DocumentFieldValue>;
+      setValuesList(value: Array<GetDocumentsRequest.DocumentFieldValue>): void;
+      addValues(value?: GetDocumentsRequest.DocumentFieldValue, index?: number): GetDocumentsRequest.DocumentFieldValue;
+
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): ValueList.AsObject;
+      static toObject(includeInstance: boolean, msg: ValueList): ValueList.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: ValueList, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): ValueList;
+      static deserializeBinaryFromReader(message: ValueList, reader: jspb.BinaryReader): ValueList;
+    }
+
+    export namespace ValueList {
+      export type AsObject = {
+        valuesList: Array<GetDocumentsRequest.DocumentFieldValue.AsObject>,
+      }
+    }
+
+    export enum VariantCase {
+      VARIANT_NOT_SET = 0,
+      BOOL_VALUE = 1,
+      INT64_VALUE = 2,
+      UINT64_VALUE = 3,
+      DOUBLE_VALUE = 4,
+      TEXT = 5,
+      BYTES_VALUE = 6,
+      LIST = 7,
+      NULL_VALUE = 8,
+    }
+  }
+
+  export class WhereClause extends jspb.Message {
+    getField(): string;
+    setField(value: string): void;
+
+    getOperator(): GetDocumentsRequest.WhereOperatorMap[keyof GetDocumentsRequest.WhereOperatorMap];
+    setOperator(value: GetDocumentsRequest.WhereOperatorMap[keyof GetDocumentsRequest.WhereOperatorMap]): void;
+
+    hasValue(): boolean;
+    clearValue(): void;
+    getValue(): GetDocumentsRequest.DocumentFieldValue | undefined;
+    setValue(value?: GetDocumentsRequest.DocumentFieldValue): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): WhereClause.AsObject;
+    static toObject(includeInstance: boolean, msg: WhereClause): WhereClause.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: WhereClause, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): WhereClause;
+    static deserializeBinaryFromReader(message: WhereClause, reader: jspb.BinaryReader): WhereClause;
+  }
+
+  export namespace WhereClause {
+    export type AsObject = {
+      field: string,
+      operator: GetDocumentsRequest.WhereOperatorMap[keyof GetDocumentsRequest.WhereOperatorMap],
+      value?: GetDocumentsRequest.DocumentFieldValue.AsObject,
+    }
+  }
+
+  export class HavingAggregate extends jspb.Message {
+    getFunction(): GetDocumentsRequest.HavingAggregate.FunctionMap[keyof GetDocumentsRequest.HavingAggregate.FunctionMap];
+    setFunction(value: GetDocumentsRequest.HavingAggregate.FunctionMap[keyof GetDocumentsRequest.HavingAggregate.FunctionMap]): void;
+
+    getField(): string;
+    setField(value: string): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): HavingAggregate.AsObject;
+    static toObject(includeInstance: boolean, msg: HavingAggregate): HavingAggregate.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: HavingAggregate, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): HavingAggregate;
+    static deserializeBinaryFromReader(message: HavingAggregate, reader: jspb.BinaryReader): HavingAggregate;
+  }
+
+  export namespace HavingAggregate {
+    export type AsObject = {
+      pb_function: GetDocumentsRequest.HavingAggregate.FunctionMap[keyof GetDocumentsRequest.HavingAggregate.FunctionMap],
+      field: string,
+    }
+
+    export interface FunctionMap {
+      COUNT: 0;
+      SUM: 1;
+      AVG: 2;
+    }
+
+    export const Function: FunctionMap;
+  }
+
+  export class HavingRanking extends jspb.Message {
+    getKind(): GetDocumentsRequest.HavingRanking.KindMap[keyof GetDocumentsRequest.HavingRanking.KindMap];
+    setKind(value: GetDocumentsRequest.HavingRanking.KindMap[keyof GetDocumentsRequest.HavingRanking.KindMap]): void;
+
+    hasN(): boolean;
+    clearN(): void;
+    getN(): string;
+    setN(value: string): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): HavingRanking.AsObject;
+    static toObject(includeInstance: boolean, msg: HavingRanking): HavingRanking.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: HavingRanking, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): HavingRanking;
+    static deserializeBinaryFromReader(message: HavingRanking, reader: jspb.BinaryReader): HavingRanking;
+  }
+
+  export namespace HavingRanking {
+    export type AsObject = {
+      kind: GetDocumentsRequest.HavingRanking.KindMap[keyof GetDocumentsRequest.HavingRanking.KindMap],
+      n: string,
+    }
+
+    export interface KindMap {
+      MIN: 0;
+      MAX: 1;
+      TOP: 2;
+      BOTTOM: 3;
+    }
+
+    export const Kind: KindMap;
+  }
+
+  export class HavingClause extends jspb.Message {
+    hasAggregate(): boolean;
+    clearAggregate(): void;
+    getAggregate(): GetDocumentsRequest.HavingAggregate | undefined;
+    setAggregate(value?: GetDocumentsRequest.HavingAggregate): void;
+
+    getOperator(): GetDocumentsRequest.HavingClause.OperatorMap[keyof GetDocumentsRequest.HavingClause.OperatorMap];
+    setOperator(value: GetDocumentsRequest.HavingClause.OperatorMap[keyof GetDocumentsRequest.HavingClause.OperatorMap]): void;
+
+    hasValue(): boolean;
+    clearValue(): void;
+    getValue(): GetDocumentsRequest.DocumentFieldValue | undefined;
+    setValue(value?: GetDocumentsRequest.DocumentFieldValue): void;
+
+    hasRanking(): boolean;
+    clearRanking(): void;
+    getRanking(): GetDocumentsRequest.HavingRanking | undefined;
+    setRanking(value?: GetDocumentsRequest.HavingRanking): void;
+
+    getRightCase(): HavingClause.RightCase;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): HavingClause.AsObject;
+    static toObject(includeInstance: boolean, msg: HavingClause): HavingClause.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: HavingClause, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): HavingClause;
+    static deserializeBinaryFromReader(message: HavingClause, reader: jspb.BinaryReader): HavingClause;
+  }
+
+  export namespace HavingClause {
+    export type AsObject = {
+      aggregate?: GetDocumentsRequest.HavingAggregate.AsObject,
+      operator: GetDocumentsRequest.HavingClause.OperatorMap[keyof GetDocumentsRequest.HavingClause.OperatorMap],
+      value?: GetDocumentsRequest.DocumentFieldValue.AsObject,
+      ranking?: GetDocumentsRequest.HavingRanking.AsObject,
+    }
+
+    export interface OperatorMap {
+      EQUAL: 0;
+      NOT_EQUAL: 1;
+      GREATER_THAN: 2;
+      GREATER_THAN_OR_EQUALS: 3;
+      LESS_THAN: 4;
+      LESS_THAN_OR_EQUALS: 5;
+      BETWEEN: 6;
+      BETWEEN_EXCLUDE_BOUNDS: 7;
+      BETWEEN_EXCLUDE_LEFT: 8;
+      BETWEEN_EXCLUDE_RIGHT: 9;
+      IN: 10;
+    }
+
+    export const Operator: OperatorMap;
+
+    export enum RightCase {
+      RIGHT_NOT_SET = 0,
+      VALUE = 3,
+      RANKING = 4,
+    }
+  }
+
+  export class OrderClause extends jspb.Message {
+    hasField(): boolean;
+    clearField(): void;
+    getField(): string;
+    setField(value: string): void;
+
+    hasAggregate(): boolean;
+    clearAggregate(): void;
+    getAggregate(): GetDocumentsRequest.HavingAggregate | undefined;
+    setAggregate(value?: GetDocumentsRequest.HavingAggregate): void;
+
+    getAscending(): boolean;
+    setAscending(value: boolean): void;
+
+    getTargetCase(): OrderClause.TargetCase;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): OrderClause.AsObject;
+    static toObject(includeInstance: boolean, msg: OrderClause): OrderClause.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: OrderClause, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): OrderClause;
+    static deserializeBinaryFromReader(message: OrderClause, reader: jspb.BinaryReader): OrderClause;
+  }
+
+  export namespace OrderClause {
+    export type AsObject = {
+      field: string,
+      aggregate?: GetDocumentsRequest.HavingAggregate.AsObject,
+      ascending: boolean,
+    }
+
+    export enum TargetCase {
+      TARGET_NOT_SET = 0,
+      FIELD = 1,
+      AGGREGATE = 3,
+    }
   }
 
   export class GetDocumentsRequestV0 extends jspb.Message {
@@ -2335,9 +2639,156 @@ export namespace GetDocumentsRequest {
     }
   }
 
+  export class GetDocumentsRequestV1 extends jspb.Message {
+    getDataContractId(): Uint8Array | string;
+    getDataContractId_asU8(): Uint8Array;
+    getDataContractId_asB64(): string;
+    setDataContractId(value: Uint8Array | string): void;
+
+    getDocumentType(): string;
+    setDocumentType(value: string): void;
+
+    clearWhereClausesList(): void;
+    getWhereClausesList(): Array<GetDocumentsRequest.WhereClause>;
+    setWhereClausesList(value: Array<GetDocumentsRequest.WhereClause>): void;
+    addWhereClauses(value?: GetDocumentsRequest.WhereClause, index?: number): GetDocumentsRequest.WhereClause;
+
+    clearOrderByList(): void;
+    getOrderByList(): Array<GetDocumentsRequest.OrderClause>;
+    setOrderByList(value: Array<GetDocumentsRequest.OrderClause>): void;
+    addOrderBy(value?: GetDocumentsRequest.OrderClause, index?: number): GetDocumentsRequest.OrderClause;
+
+    hasLimit(): boolean;
+    clearLimit(): void;
+    getLimit(): number;
+    setLimit(value: number): void;
+
+    hasStartAfter(): boolean;
+    clearStartAfter(): void;
+    getStartAfter(): Uint8Array | string;
+    getStartAfter_asU8(): Uint8Array;
+    getStartAfter_asB64(): string;
+    setStartAfter(value: Uint8Array | string): void;
+
+    hasStartAt(): boolean;
+    clearStartAt(): void;
+    getStartAt(): Uint8Array | string;
+    getStartAt_asU8(): Uint8Array;
+    getStartAt_asB64(): string;
+    setStartAt(value: Uint8Array | string): void;
+
+    getProve(): boolean;
+    setProve(value: boolean): void;
+
+    clearSelectsList(): void;
+    getSelectsList(): Array<GetDocumentsRequest.GetDocumentsRequestV1.Select>;
+    setSelectsList(value: Array<GetDocumentsRequest.GetDocumentsRequestV1.Select>): void;
+    addSelects(value?: GetDocumentsRequest.GetDocumentsRequestV1.Select, index?: number): GetDocumentsRequest.GetDocumentsRequestV1.Select;
+
+    clearGroupByList(): void;
+    getGroupByList(): Array<string>;
+    setGroupByList(value: Array<string>): void;
+    addGroupBy(value: string, index?: number): string;
+
+    clearHavingList(): void;
+    getHavingList(): Array<GetDocumentsRequest.HavingClause>;
+    setHavingList(value: Array<GetDocumentsRequest.HavingClause>): void;
+    addHaving(value?: GetDocumentsRequest.HavingClause, index?: number): GetDocumentsRequest.HavingClause;
+
+    hasOffset(): boolean;
+    clearOffset(): void;
+    getOffset(): number;
+    setOffset(value: number): void;
+
+    getStartCase(): GetDocumentsRequestV1.StartCase;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetDocumentsRequestV1.AsObject;
+    static toObject(includeInstance: boolean, msg: GetDocumentsRequestV1): GetDocumentsRequestV1.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetDocumentsRequestV1, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetDocumentsRequestV1;
+    static deserializeBinaryFromReader(message: GetDocumentsRequestV1, reader: jspb.BinaryReader): GetDocumentsRequestV1;
+  }
+
+  export namespace GetDocumentsRequestV1 {
+    export type AsObject = {
+      dataContractId: Uint8Array | string,
+      documentType: string,
+      whereClausesList: Array<GetDocumentsRequest.WhereClause.AsObject>,
+      orderByList: Array<GetDocumentsRequest.OrderClause.AsObject>,
+      limit: number,
+      startAfter: Uint8Array | string,
+      startAt: Uint8Array | string,
+      prove: boolean,
+      selectsList: Array<GetDocumentsRequest.GetDocumentsRequestV1.Select.AsObject>,
+      groupByList: Array<string>,
+      havingList: Array<GetDocumentsRequest.HavingClause.AsObject>,
+      offset: number,
+    }
+
+    export class Select extends jspb.Message {
+      getFunction(): GetDocumentsRequest.GetDocumentsRequestV1.Select.FunctionMap[keyof GetDocumentsRequest.GetDocumentsRequestV1.Select.FunctionMap];
+      setFunction(value: GetDocumentsRequest.GetDocumentsRequestV1.Select.FunctionMap[keyof GetDocumentsRequest.GetDocumentsRequestV1.Select.FunctionMap]): void;
+
+      getField(): string;
+      setField(value: string): void;
+
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): Select.AsObject;
+      static toObject(includeInstance: boolean, msg: Select): Select.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: Select, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): Select;
+      static deserializeBinaryFromReader(message: Select, reader: jspb.BinaryReader): Select;
+    }
+
+    export namespace Select {
+      export type AsObject = {
+        pb_function: GetDocumentsRequest.GetDocumentsRequestV1.Select.FunctionMap[keyof GetDocumentsRequest.GetDocumentsRequestV1.Select.FunctionMap],
+        field: string,
+      }
+
+      export interface FunctionMap {
+        DOCUMENTS: 0;
+        COUNT: 1;
+        SUM: 2;
+        AVG: 3;
+        MIN: 4;
+        MAX: 5;
+      }
+
+      export const Function: FunctionMap;
+    }
+
+    export enum StartCase {
+      START_NOT_SET = 0,
+      START_AFTER = 6,
+      START_AT = 7,
+    }
+  }
+
+  export interface WhereOperatorMap {
+    EQUAL: 0;
+    GREATER_THAN: 1;
+    GREATER_THAN_OR_EQUALS: 2;
+    LESS_THAN: 3;
+    LESS_THAN_OR_EQUALS: 4;
+    BETWEEN: 5;
+    BETWEEN_EXCLUDE_BOUNDS: 6;
+    BETWEEN_EXCLUDE_LEFT: 7;
+    BETWEEN_EXCLUDE_RIGHT: 8;
+    IN: 9;
+    STARTS_WITH: 10;
+  }
+
+  export const WhereOperator: WhereOperatorMap;
+
   export enum VersionCase {
     VERSION_NOT_SET = 0,
     V0 = 1,
+    V1 = 2,
   }
 }
 
@@ -2347,6 +2798,11 @@ export class GetDocumentsResponse extends jspb.Message {
   getV0(): GetDocumentsResponse.GetDocumentsResponseV0 | undefined;
   setV0(value?: GetDocumentsResponse.GetDocumentsResponseV0): void;
 
+  hasV1(): boolean;
+  clearV1(): void;
+  getV1(): GetDocumentsResponse.GetDocumentsResponseV1 | undefined;
+  setV1(value?: GetDocumentsResponse.GetDocumentsResponseV1): void;
+
   getVersionCase(): GetDocumentsResponse.VersionCase;
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): GetDocumentsResponse.AsObject;
@@ -2361,6 +2817,7 @@ export class GetDocumentsResponse extends jspb.Message {
 export namespace GetDocumentsResponse {
   export type AsObject = {
     v0?: GetDocumentsResponse.GetDocumentsResponseV0.AsObject,
+    v1?: GetDocumentsResponse.GetDocumentsResponseV1.AsObject,
   }
 
   export class GetDocumentsResponseV0 extends jspb.Message {
@@ -2428,74 +2885,490 @@ export namespace GetDocumentsResponse {
     }
   }
 
-  export enum VersionCase {
-    VERSION_NOT_SET = 0,
-    V0 = 1,
-  }
-}
-
-export class GetIdentityByPublicKeyHashRequest extends jspb.Message {
-  hasV0(): boolean;
-  clearV0(): void;
-  getV0(): GetIdentityByPublicKeyHashRequest.GetIdentityByPublicKeyHashRequestV0 | undefined;
-  setV0(value?: GetIdentityByPublicKeyHashRequest.GetIdentityByPublicKeyHashRequestV0): void;
-
-  getVersionCase(): GetIdentityByPublicKeyHashRequest.VersionCase;
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): GetIdentityByPublicKeyHashRequest.AsObject;
-  static toObject(includeInstance: boolean, msg: GetIdentityByPublicKeyHashRequest): GetIdentityByPublicKeyHashRequest.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: GetIdentityByPublicKeyHashRequest, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): GetIdentityByPublicKeyHashRequest;
-  static deserializeBinaryFromReader(message: GetIdentityByPublicKeyHashRequest, reader: jspb.BinaryReader): GetIdentityByPublicKeyHashRequest;
-}
-
-export namespace GetIdentityByPublicKeyHashRequest {
-  export type AsObject = {
-    v0?: GetIdentityByPublicKeyHashRequest.GetIdentityByPublicKeyHashRequestV0.AsObject,
-  }
+  export class GetDocumentsResponseV1 extends jspb.Message {
+    hasData(): boolean;
+    clearData(): void;
+    getData(): GetDocumentsResponse.GetDocumentsResponseV1.ResultData | undefined;
+    setData(value?: GetDocumentsResponse.GetDocumentsResponseV1.ResultData): void;
 
-  export class GetIdentityByPublicKeyHashRequestV0 extends jspb.Message {
-    getPublicKeyHash(): Uint8Array | string;
-    getPublicKeyHash_asU8(): Uint8Array;
-    getPublicKeyHash_asB64(): string;
-    setPublicKeyHash(value: Uint8Array | string): void;
+    hasProof(): boolean;
+    clearProof(): void;
+    getProof(): Proof | undefined;
+    setProof(value?: Proof): void;
 
-    getProve(): boolean;
-    setProve(value: boolean): void;
+    hasMetadata(): boolean;
+    clearMetadata(): void;
+    getMetadata(): ResponseMetadata | undefined;
+    setMetadata(value?: ResponseMetadata): void;
 
+    getResultCase(): GetDocumentsResponseV1.ResultCase;
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): GetIdentityByPublicKeyHashRequestV0.AsObject;
-    static toObject(includeInstance: boolean, msg: GetIdentityByPublicKeyHashRequestV0): GetIdentityByPublicKeyHashRequestV0.AsObject;
+    toObject(includeInstance?: boolean): GetDocumentsResponseV1.AsObject;
+    static toObject(includeInstance: boolean, msg: GetDocumentsResponseV1): GetDocumentsResponseV1.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: GetIdentityByPublicKeyHashRequestV0, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): GetIdentityByPublicKeyHashRequestV0;
-    static deserializeBinaryFromReader(message: GetIdentityByPublicKeyHashRequestV0, reader: jspb.BinaryReader): GetIdentityByPublicKeyHashRequestV0;
+    static serializeBinaryToWriter(message: GetDocumentsResponseV1, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetDocumentsResponseV1;
+    static deserializeBinaryFromReader(message: GetDocumentsResponseV1, reader: jspb.BinaryReader): GetDocumentsResponseV1;
   }
 
-  export namespace GetIdentityByPublicKeyHashRequestV0 {
+  export namespace GetDocumentsResponseV1 {
     export type AsObject = {
-      publicKeyHash: Uint8Array | string,
-      prove: boolean,
+      data?: GetDocumentsResponse.GetDocumentsResponseV1.ResultData.AsObject,
+      proof?: Proof.AsObject,
+      metadata?: ResponseMetadata.AsObject,
     }
-  }
 
-  export enum VersionCase {
-    VERSION_NOT_SET = 0,
-    V0 = 1,
-  }
-}
+    export class Documents extends jspb.Message {
+      clearDocumentsList(): void;
+      getDocumentsList(): Array<Uint8Array | string>;
+      getDocumentsList_asU8(): Array<Uint8Array>;
+      getDocumentsList_asB64(): Array<string>;
+      setDocumentsList(value: Array<Uint8Array | string>): void;
+      addDocuments(value: Uint8Array | string, index?: number): Uint8Array | string;
 
-export class GetIdentityByPublicKeyHashResponse extends jspb.Message {
-  hasV0(): boolean;
-  clearV0(): void;
-  getV0(): GetIdentityByPublicKeyHashResponse.GetIdentityByPublicKeyHashResponseV0 | undefined;
-  setV0(value?: GetIdentityByPublicKeyHashResponse.GetIdentityByPublicKeyHashResponseV0): void;
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): Documents.AsObject;
+      static toObject(includeInstance: boolean, msg: Documents): Documents.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: Documents, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): Documents;
+      static deserializeBinaryFromReader(message: Documents, reader: jspb.BinaryReader): Documents;
+    }
 
-  getVersionCase(): GetIdentityByPublicKeyHashResponse.VersionCase;
-  serializeBinary(): Uint8Array;
+    export namespace Documents {
+      export type AsObject = {
+        documentsList: Array<Uint8Array | string>,
+      }
+    }
+
+    export class CountEntry extends jspb.Message {
+      hasInKey(): boolean;
+      clearInKey(): void;
+      getInKey(): Uint8Array | string;
+      getInKey_asU8(): Uint8Array;
+      getInKey_asB64(): string;
+      setInKey(value: Uint8Array | string): void;
+
+      getKey(): Uint8Array | string;
+      getKey_asU8(): Uint8Array;
+      getKey_asB64(): string;
+      setKey(value: Uint8Array | string): void;
+
+      getCount(): string;
+      setCount(value: string): void;
+
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): CountEntry.AsObject;
+      static toObject(includeInstance: boolean, msg: CountEntry): CountEntry.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: CountEntry, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): CountEntry;
+      static deserializeBinaryFromReader(message: CountEntry, reader: jspb.BinaryReader): CountEntry;
+    }
+
+    export namespace CountEntry {
+      export type AsObject = {
+        inKey: Uint8Array | string,
+        key: Uint8Array | string,
+        count: string,
+      }
+    }
+
+    export class CountEntries extends jspb.Message {
+      clearEntriesList(): void;
+      getEntriesList(): Array<GetDocumentsResponse.GetDocumentsResponseV1.CountEntry>;
+      setEntriesList(value: Array<GetDocumentsResponse.GetDocumentsResponseV1.CountEntry>): void;
+      addEntries(value?: GetDocumentsResponse.GetDocumentsResponseV1.CountEntry, index?: number): GetDocumentsResponse.GetDocumentsResponseV1.CountEntry;
+
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): CountEntries.AsObject;
+      static toObject(includeInstance: boolean, msg: CountEntries): CountEntries.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: CountEntries, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): CountEntries;
+      static deserializeBinaryFromReader(message: CountEntries, reader: jspb.BinaryReader): CountEntries;
+    }
+
+    export namespace CountEntries {
+      export type AsObject = {
+        entriesList: Array<GetDocumentsResponse.GetDocumentsResponseV1.CountEntry.AsObject>,
+      }
+    }
+
+    export class CountResults extends jspb.Message {
+      hasAggregateCount(): boolean;
+      clearAggregateCount(): void;
+      getAggregateCount(): string;
+      setAggregateCount(value: string): void;
+
+      hasEntries(): boolean;
+      clearEntries(): void;
+      getEntries(): GetDocumentsResponse.GetDocumentsResponseV1.CountEntries | undefined;
+      setEntries(value?: GetDocumentsResponse.GetDocumentsResponseV1.CountEntries): void;
+
+      getVariantCase(): CountResults.VariantCase;
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): CountResults.AsObject;
+      static toObject(includeInstance: boolean, msg: CountResults): CountResults.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: CountResults, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): CountResults;
+      static deserializeBinaryFromReader(message: CountResults, reader: jspb.BinaryReader): CountResults;
+    }
+
+    export namespace CountResults {
+      export type AsObject = {
+        aggregateCount: string,
+        entries?: GetDocumentsResponse.GetDocumentsResponseV1.CountEntries.AsObject,
+      }
+
+      export enum VariantCase {
+        VARIANT_NOT_SET = 0,
+        AGGREGATE_COUNT = 1,
+        ENTRIES = 2,
+      }
+    }
+
+    export class SumEntry extends jspb.Message {
+      hasInKey(): boolean;
+      clearInKey(): void;
+      getInKey(): Uint8Array | string;
+      getInKey_asU8(): Uint8Array;
+      getInKey_asB64(): string;
+      setInKey(value: Uint8Array | string): void;
+
+      getKey(): Uint8Array | string;
+      getKey_asU8(): Uint8Array;
+      getKey_asB64(): string;
+      setKey(value: Uint8Array | string): void;
+
+      getSum(): string;
+      setSum(value: string): void;
+
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): SumEntry.AsObject;
+      static toObject(includeInstance: boolean, msg: SumEntry): SumEntry.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: SumEntry, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): SumEntry;
+      static deserializeBinaryFromReader(message: SumEntry, reader: jspb.BinaryReader): SumEntry;
+    }
+
+    export namespace SumEntry {
+      export type AsObject = {
+        inKey: Uint8Array | string,
+        key: Uint8Array | string,
+        sum: string,
+      }
+    }
+
+    export class SumEntries extends jspb.Message {
+      clearEntriesList(): void;
+      getEntriesList(): Array<GetDocumentsResponse.GetDocumentsResponseV1.SumEntry>;
+      setEntriesList(value: Array<GetDocumentsResponse.GetDocumentsResponseV1.SumEntry>): void;
+      addEntries(value?: GetDocumentsResponse.GetDocumentsResponseV1.SumEntry, index?: number): GetDocumentsResponse.GetDocumentsResponseV1.SumEntry;
+
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): SumEntries.AsObject;
+      static toObject(includeInstance: boolean, msg: SumEntries): SumEntries.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: SumEntries, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): SumEntries;
+      static deserializeBinaryFromReader(message: SumEntries, reader: jspb.BinaryReader): SumEntries;
+    }
+
+    export namespace SumEntries {
+      export type AsObject = {
+        entriesList: Array<GetDocumentsResponse.GetDocumentsResponseV1.SumEntry.AsObject>,
+      }
+    }
+
+    export class SumResults extends jspb.Message {
+      hasAggregateSum(): boolean;
+      clearAggregateSum(): void;
+      getAggregateSum(): string;
+      setAggregateSum(value: string): void;
+
+      hasEntries(): boolean;
+      clearEntries(): void;
+      getEntries(): GetDocumentsResponse.GetDocumentsResponseV1.SumEntries | undefined;
+      setEntries(value?: GetDocumentsResponse.GetDocumentsResponseV1.SumEntries): void;
+
+      getVariantCase(): SumResults.VariantCase;
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): SumResults.AsObject;
+      static toObject(includeInstance: boolean, msg: SumResults): SumResults.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: SumResults, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): SumResults;
+      static deserializeBinaryFromReader(message: SumResults, reader: jspb.BinaryReader): SumResults;
+    }
+
+    export namespace SumResults {
+      export type AsObject = {
+        aggregateSum: string,
+        entries?: GetDocumentsResponse.GetDocumentsResponseV1.SumEntries.AsObject,
+      }
+
+      export enum VariantCase {
+        VARIANT_NOT_SET = 0,
+        AGGREGATE_SUM = 1,
+        ENTRIES = 2,
+      }
+    }
+
+    export class AverageEntry extends jspb.Message {
+      hasInKey(): boolean;
+      clearInKey(): void;
+      getInKey(): Uint8Array | string;
+      getInKey_asU8(): Uint8Array;
+      getInKey_asB64(): string;
+      setInKey(value: Uint8Array | string): void;
+
+      getKey(): Uint8Array | string;
+      getKey_asU8(): Uint8Array;
+      getKey_asB64(): string;
+      setKey(value: Uint8Array | string): void;
+
+      getCount(): string;
+      setCount(value: string): void;
+
+      getSum(): string;
+      setSum(value: string): void;
+
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): AverageEntry.AsObject;
+      static toObject(includeInstance: boolean, msg: AverageEntry): AverageEntry.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: AverageEntry, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): AverageEntry;
+      static deserializeBinaryFromReader(message: AverageEntry, reader: jspb.BinaryReader): AverageEntry;
+    }
+
+    export namespace AverageEntry {
+      export type AsObject = {
+        inKey: Uint8Array | string,
+        key: Uint8Array | string,
+        count: string,
+        sum: string,
+      }
+    }
+
+    export class AverageEntries extends jspb.Message {
+      clearEntriesList(): void;
+      getEntriesList(): Array<GetDocumentsResponse.GetDocumentsResponseV1.AverageEntry>;
+      setEntriesList(value: Array<GetDocumentsResponse.GetDocumentsResponseV1.AverageEntry>): void;
+      addEntries(value?: GetDocumentsResponse.GetDocumentsResponseV1.AverageEntry, index?: number): GetDocumentsResponse.GetDocumentsResponseV1.AverageEntry;
+
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): AverageEntries.AsObject;
+      static toObject(includeInstance: boolean, msg: AverageEntries): AverageEntries.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: AverageEntries, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): AverageEntries;
+      static deserializeBinaryFromReader(message: AverageEntries, reader: jspb.BinaryReader): AverageEntries;
+    }
+
+    export namespace AverageEntries {
+      export type AsObject = {
+        entriesList: Array<GetDocumentsResponse.GetDocumentsResponseV1.AverageEntry.AsObject>,
+      }
+    }
+
+    export class AverageAggregate extends jspb.Message {
+      getCount(): string;
+      setCount(value: string): void;
+
+      getSum(): string;
+      setSum(value: string): void;
+
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): AverageAggregate.AsObject;
+      static toObject(includeInstance: boolean, msg: AverageAggregate): AverageAggregate.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: AverageAggregate, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): AverageAggregate;
+      static deserializeBinaryFromReader(message: AverageAggregate, reader: jspb.BinaryReader): AverageAggregate;
+    }
+
+    export namespace AverageAggregate {
+      export type AsObject = {
+        count: string,
+        sum: string,
+      }
+    }
+
+    export class AverageResults extends jspb.Message {
+      hasAggregateAverage(): boolean;
+      clearAggregateAverage(): void;
+      getAggregateAverage(): GetDocumentsResponse.GetDocumentsResponseV1.AverageAggregate | undefined;
+      setAggregateAverage(value?: GetDocumentsResponse.GetDocumentsResponseV1.AverageAggregate): void;
+
+      hasEntries(): boolean;
+      clearEntries(): void;
+      getEntries(): GetDocumentsResponse.GetDocumentsResponseV1.AverageEntries | undefined;
+      setEntries(value?: GetDocumentsResponse.GetDocumentsResponseV1.AverageEntries): void;
+
+      getVariantCase(): AverageResults.VariantCase;
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): AverageResults.AsObject;
+      static toObject(includeInstance: boolean, msg: AverageResults): AverageResults.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: AverageResults, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): AverageResults;
+      static deserializeBinaryFromReader(message: AverageResults, reader: jspb.BinaryReader): AverageResults;
+    }
+
+    export namespace AverageResults {
+      export type AsObject = {
+        aggregateAverage?: GetDocumentsResponse.GetDocumentsResponseV1.AverageAggregate.AsObject,
+        entries?: GetDocumentsResponse.GetDocumentsResponseV1.AverageEntries.AsObject,
+      }
+
+      export enum VariantCase {
+        VARIANT_NOT_SET = 0,
+        AGGREGATE_AVERAGE = 1,
+        ENTRIES = 2,
+      }
+    }
+
+    export class ResultData extends jspb.Message {
+      hasDocuments(): boolean;
+      clearDocuments(): void;
+      getDocuments(): GetDocumentsResponse.GetDocumentsResponseV1.Documents | undefined;
+      setDocuments(value?: GetDocumentsResponse.GetDocumentsResponseV1.Documents): void;
+
+      hasCounts(): boolean;
+      clearCounts(): void;
+      getCounts(): GetDocumentsResponse.GetDocumentsResponseV1.CountResults | undefined;
+      setCounts(value?: GetDocumentsResponse.GetDocumentsResponseV1.CountResults): void;
+
+      hasSums(): boolean;
+      clearSums(): void;
+      getSums(): GetDocumentsResponse.GetDocumentsResponseV1.SumResults | undefined;
+      setSums(value?: GetDocumentsResponse.GetDocumentsResponseV1.SumResults): void;
+
+      hasAverages(): boolean;
+      clearAverages(): void;
+      getAverages(): GetDocumentsResponse.GetDocumentsResponseV1.AverageResults | undefined;
+      setAverages(value?: GetDocumentsResponse.GetDocumentsResponseV1.AverageResults): void;
+
+      getVariantCase(): ResultData.VariantCase;
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): ResultData.AsObject;
+      static toObject(includeInstance: boolean, msg: ResultData): ResultData.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: ResultData, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): ResultData;
+      static deserializeBinaryFromReader(message: ResultData, reader: jspb.BinaryReader): ResultData;
+    }
+
+    export namespace ResultData {
+      export type AsObject = {
+        documents?: GetDocumentsResponse.GetDocumentsResponseV1.Documents.AsObject,
+        counts?: GetDocumentsResponse.GetDocumentsResponseV1.CountResults.AsObject,
+        sums?: GetDocumentsResponse.GetDocumentsResponseV1.SumResults.AsObject,
+        averages?: GetDocumentsResponse.GetDocumentsResponseV1.AverageResults.AsObject,
+      }
+
+      export enum VariantCase {
+        VARIANT_NOT_SET = 0,
+        DOCUMENTS = 1,
+        COUNTS = 2,
+        SUMS = 3,
+        AVERAGES = 4,
+      }
+    }
+
+    export enum ResultCase {
+      RESULT_NOT_SET = 0,
+      DATA = 1,
+      PROOF = 2,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+    V1 = 2,
+  }
+}
+
+export class GetIdentityByPublicKeyHashRequest extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetIdentityByPublicKeyHashRequest.GetIdentityByPublicKeyHashRequestV0 | undefined;
+  setV0(value?: GetIdentityByPublicKeyHashRequest.GetIdentityByPublicKeyHashRequestV0): void;
+
+  getVersionCase(): GetIdentityByPublicKeyHashRequest.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetIdentityByPublicKeyHashRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetIdentityByPublicKeyHashRequest): GetIdentityByPublicKeyHashRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetIdentityByPublicKeyHashRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetIdentityByPublicKeyHashRequest;
+  static deserializeBinaryFromReader(message: GetIdentityByPublicKeyHashRequest, reader: jspb.BinaryReader): GetIdentityByPublicKeyHashRequest;
+}
+
+export namespace GetIdentityByPublicKeyHashRequest {
+  export type AsObject = {
+    v0?: GetIdentityByPublicKeyHashRequest.GetIdentityByPublicKeyHashRequestV0.AsObject,
+  }
+
+  export class GetIdentityByPublicKeyHashRequestV0 extends jspb.Message {
+    getPublicKeyHash(): Uint8Array | string;
+    getPublicKeyHash_asU8(): Uint8Array;
+    getPublicKeyHash_asB64(): string;
+    setPublicKeyHash(value: Uint8Array | string): void;
+
+    getProve(): boolean;
+    setProve(value: boolean): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetIdentityByPublicKeyHashRequestV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetIdentityByPublicKeyHashRequestV0): GetIdentityByPublicKeyHashRequestV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetIdentityByPublicKeyHashRequestV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetIdentityByPublicKeyHashRequestV0;
+    static deserializeBinaryFromReader(message: GetIdentityByPublicKeyHashRequestV0, reader: jspb.BinaryReader): GetIdentityByPublicKeyHashRequestV0;
+  }
+
+  export namespace GetIdentityByPublicKeyHashRequestV0 {
+    export type AsObject = {
+      publicKeyHash: Uint8Array | string,
+      prove: boolean,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetIdentityByPublicKeyHashResponse extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetIdentityByPublicKeyHashResponse.GetIdentityByPublicKeyHashResponseV0 | undefined;
+  setV0(value?: GetIdentityByPublicKeyHashResponse.GetIdentityByPublicKeyHashResponseV0): void;
+
+  getVersionCase(): GetIdentityByPublicKeyHashResponse.VersionCase;
+  serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): GetIdentityByPublicKeyHashResponse.AsObject;
   static toObject(includeInstance: boolean, msg: GetIdentityByPublicKeyHashResponse): GetIdentityByPublicKeyHashResponse.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
@@ -9641,111 +10514,1387 @@ export class AddressBalanceChange extends jspb.Message {
   getSetBalance(): string;
   setSetBalance(value: string): void;
 
-  hasAddToBalance(): boolean;
-  clearAddToBalance(): void;
-  getAddToBalance(): string;
-  setAddToBalance(value: string): void;
+  hasAddToBalance(): boolean;
+  clearAddToBalance(): void;
+  getAddToBalance(): string;
+  setAddToBalance(value: string): void;
+
+  getOperationCase(): AddressBalanceChange.OperationCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AddressBalanceChange.AsObject;
+  static toObject(includeInstance: boolean, msg: AddressBalanceChange): AddressBalanceChange.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: AddressBalanceChange, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AddressBalanceChange;
+  static deserializeBinaryFromReader(message: AddressBalanceChange, reader: jspb.BinaryReader): AddressBalanceChange;
+}
+
+export namespace AddressBalanceChange {
+  export type AsObject = {
+    address: Uint8Array | string,
+    setBalance: string,
+    addToBalance: string,
+  }
+
+  export enum OperationCase {
+    OPERATION_NOT_SET = 0,
+    SET_BALANCE = 2,
+    ADD_TO_BALANCE = 3,
+  }
+}
+
+export class BlockAddressBalanceChanges extends jspb.Message {
+  getBlockHeight(): string;
+  setBlockHeight(value: string): void;
+
+  clearChangesList(): void;
+  getChangesList(): Array<AddressBalanceChange>;
+  setChangesList(value: Array<AddressBalanceChange>): void;
+  addChanges(value?: AddressBalanceChange, index?: number): AddressBalanceChange;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): BlockAddressBalanceChanges.AsObject;
+  static toObject(includeInstance: boolean, msg: BlockAddressBalanceChanges): BlockAddressBalanceChanges.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: BlockAddressBalanceChanges, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): BlockAddressBalanceChanges;
+  static deserializeBinaryFromReader(message: BlockAddressBalanceChanges, reader: jspb.BinaryReader): BlockAddressBalanceChanges;
+}
+
+export namespace BlockAddressBalanceChanges {
+  export type AsObject = {
+    blockHeight: string,
+    changesList: Array<AddressBalanceChange.AsObject>,
+  }
+}
+
+export class AddressBalanceUpdateEntries extends jspb.Message {
+  clearBlockChangesList(): void;
+  getBlockChangesList(): Array<BlockAddressBalanceChanges>;
+  setBlockChangesList(value: Array<BlockAddressBalanceChanges>): void;
+  addBlockChanges(value?: BlockAddressBalanceChanges, index?: number): BlockAddressBalanceChanges;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AddressBalanceUpdateEntries.AsObject;
+  static toObject(includeInstance: boolean, msg: AddressBalanceUpdateEntries): AddressBalanceUpdateEntries.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: AddressBalanceUpdateEntries, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AddressBalanceUpdateEntries;
+  static deserializeBinaryFromReader(message: AddressBalanceUpdateEntries, reader: jspb.BinaryReader): AddressBalanceUpdateEntries;
+}
+
+export namespace AddressBalanceUpdateEntries {
+  export type AsObject = {
+    blockChangesList: Array<BlockAddressBalanceChanges.AsObject>,
+  }
+}
+
+export class GetAddressInfoResponse extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetAddressInfoResponse.GetAddressInfoResponseV0 | undefined;
+  setV0(value?: GetAddressInfoResponse.GetAddressInfoResponseV0): void;
+
+  getVersionCase(): GetAddressInfoResponse.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetAddressInfoResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetAddressInfoResponse): GetAddressInfoResponse.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetAddressInfoResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetAddressInfoResponse;
+  static deserializeBinaryFromReader(message: GetAddressInfoResponse, reader: jspb.BinaryReader): GetAddressInfoResponse;
+}
+
+export namespace GetAddressInfoResponse {
+  export type AsObject = {
+    v0?: GetAddressInfoResponse.GetAddressInfoResponseV0.AsObject,
+  }
+
+  export class GetAddressInfoResponseV0 extends jspb.Message {
+    hasAddressInfoEntry(): boolean;
+    clearAddressInfoEntry(): void;
+    getAddressInfoEntry(): AddressInfoEntry | undefined;
+    setAddressInfoEntry(value?: AddressInfoEntry): void;
+
+    hasProof(): boolean;
+    clearProof(): void;
+    getProof(): Proof | undefined;
+    setProof(value?: Proof): void;
+
+    hasMetadata(): boolean;
+    clearMetadata(): void;
+    getMetadata(): ResponseMetadata | undefined;
+    setMetadata(value?: ResponseMetadata): void;
+
+    getResultCase(): GetAddressInfoResponseV0.ResultCase;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetAddressInfoResponseV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetAddressInfoResponseV0): GetAddressInfoResponseV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetAddressInfoResponseV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetAddressInfoResponseV0;
+    static deserializeBinaryFromReader(message: GetAddressInfoResponseV0, reader: jspb.BinaryReader): GetAddressInfoResponseV0;
+  }
+
+  export namespace GetAddressInfoResponseV0 {
+    export type AsObject = {
+      addressInfoEntry?: AddressInfoEntry.AsObject,
+      proof?: Proof.AsObject,
+      metadata?: ResponseMetadata.AsObject,
+    }
+
+    export enum ResultCase {
+      RESULT_NOT_SET = 0,
+      ADDRESS_INFO_ENTRY = 1,
+      PROOF = 2,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetAddressesInfosRequest extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetAddressesInfosRequest.GetAddressesInfosRequestV0 | undefined;
+  setV0(value?: GetAddressesInfosRequest.GetAddressesInfosRequestV0): void;
+
+  getVersionCase(): GetAddressesInfosRequest.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetAddressesInfosRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetAddressesInfosRequest): GetAddressesInfosRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetAddressesInfosRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetAddressesInfosRequest;
+  static deserializeBinaryFromReader(message: GetAddressesInfosRequest, reader: jspb.BinaryReader): GetAddressesInfosRequest;
+}
+
+export namespace GetAddressesInfosRequest {
+  export type AsObject = {
+    v0?: GetAddressesInfosRequest.GetAddressesInfosRequestV0.AsObject,
+  }
+
+  export class GetAddressesInfosRequestV0 extends jspb.Message {
+    clearAddressesList(): void;
+    getAddressesList(): Array<Uint8Array | string>;
+    getAddressesList_asU8(): Array<Uint8Array>;
+    getAddressesList_asB64(): Array<string>;
+    setAddressesList(value: Array<Uint8Array | string>): void;
+    addAddresses(value: Uint8Array | string, index?: number): Uint8Array | string;
+
+    getProve(): boolean;
+    setProve(value: boolean): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetAddressesInfosRequestV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetAddressesInfosRequestV0): GetAddressesInfosRequestV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetAddressesInfosRequestV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetAddressesInfosRequestV0;
+    static deserializeBinaryFromReader(message: GetAddressesInfosRequestV0, reader: jspb.BinaryReader): GetAddressesInfosRequestV0;
+  }
+
+  export namespace GetAddressesInfosRequestV0 {
+    export type AsObject = {
+      addressesList: Array<Uint8Array | string>,
+      prove: boolean,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetAddressesInfosResponse extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetAddressesInfosResponse.GetAddressesInfosResponseV0 | undefined;
+  setV0(value?: GetAddressesInfosResponse.GetAddressesInfosResponseV0): void;
+
+  getVersionCase(): GetAddressesInfosResponse.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetAddressesInfosResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetAddressesInfosResponse): GetAddressesInfosResponse.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetAddressesInfosResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetAddressesInfosResponse;
+  static deserializeBinaryFromReader(message: GetAddressesInfosResponse, reader: jspb.BinaryReader): GetAddressesInfosResponse;
+}
+
+export namespace GetAddressesInfosResponse {
+  export type AsObject = {
+    v0?: GetAddressesInfosResponse.GetAddressesInfosResponseV0.AsObject,
+  }
+
+  export class GetAddressesInfosResponseV0 extends jspb.Message {
+    hasAddressInfoEntries(): boolean;
+    clearAddressInfoEntries(): void;
+    getAddressInfoEntries(): AddressInfoEntries | undefined;
+    setAddressInfoEntries(value?: AddressInfoEntries): void;
+
+    hasProof(): boolean;
+    clearProof(): void;
+    getProof(): Proof | undefined;
+    setProof(value?: Proof): void;
+
+    hasMetadata(): boolean;
+    clearMetadata(): void;
+    getMetadata(): ResponseMetadata | undefined;
+    setMetadata(value?: ResponseMetadata): void;
+
+    getResultCase(): GetAddressesInfosResponseV0.ResultCase;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetAddressesInfosResponseV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetAddressesInfosResponseV0): GetAddressesInfosResponseV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetAddressesInfosResponseV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetAddressesInfosResponseV0;
+    static deserializeBinaryFromReader(message: GetAddressesInfosResponseV0, reader: jspb.BinaryReader): GetAddressesInfosResponseV0;
+  }
+
+  export namespace GetAddressesInfosResponseV0 {
+    export type AsObject = {
+      addressInfoEntries?: AddressInfoEntries.AsObject,
+      proof?: Proof.AsObject,
+      metadata?: ResponseMetadata.AsObject,
+    }
+
+    export enum ResultCase {
+      RESULT_NOT_SET = 0,
+      ADDRESS_INFO_ENTRIES = 1,
+      PROOF = 2,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetAddressesTrunkStateRequest extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetAddressesTrunkStateRequest.GetAddressesTrunkStateRequestV0 | undefined;
+  setV0(value?: GetAddressesTrunkStateRequest.GetAddressesTrunkStateRequestV0): void;
+
+  getVersionCase(): GetAddressesTrunkStateRequest.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetAddressesTrunkStateRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetAddressesTrunkStateRequest): GetAddressesTrunkStateRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetAddressesTrunkStateRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetAddressesTrunkStateRequest;
+  static deserializeBinaryFromReader(message: GetAddressesTrunkStateRequest, reader: jspb.BinaryReader): GetAddressesTrunkStateRequest;
+}
+
+export namespace GetAddressesTrunkStateRequest {
+  export type AsObject = {
+    v0?: GetAddressesTrunkStateRequest.GetAddressesTrunkStateRequestV0.AsObject,
+  }
+
+  export class GetAddressesTrunkStateRequestV0 extends jspb.Message {
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetAddressesTrunkStateRequestV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetAddressesTrunkStateRequestV0): GetAddressesTrunkStateRequestV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetAddressesTrunkStateRequestV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetAddressesTrunkStateRequestV0;
+    static deserializeBinaryFromReader(message: GetAddressesTrunkStateRequestV0, reader: jspb.BinaryReader): GetAddressesTrunkStateRequestV0;
+  }
+
+  export namespace GetAddressesTrunkStateRequestV0 {
+    export type AsObject = {
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetAddressesTrunkStateResponse extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetAddressesTrunkStateResponse.GetAddressesTrunkStateResponseV0 | undefined;
+  setV0(value?: GetAddressesTrunkStateResponse.GetAddressesTrunkStateResponseV0): void;
+
+  getVersionCase(): GetAddressesTrunkStateResponse.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetAddressesTrunkStateResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetAddressesTrunkStateResponse): GetAddressesTrunkStateResponse.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetAddressesTrunkStateResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetAddressesTrunkStateResponse;
+  static deserializeBinaryFromReader(message: GetAddressesTrunkStateResponse, reader: jspb.BinaryReader): GetAddressesTrunkStateResponse;
+}
+
+export namespace GetAddressesTrunkStateResponse {
+  export type AsObject = {
+    v0?: GetAddressesTrunkStateResponse.GetAddressesTrunkStateResponseV0.AsObject,
+  }
+
+  export class GetAddressesTrunkStateResponseV0 extends jspb.Message {
+    hasProof(): boolean;
+    clearProof(): void;
+    getProof(): Proof | undefined;
+    setProof(value?: Proof): void;
+
+    hasMetadata(): boolean;
+    clearMetadata(): void;
+    getMetadata(): ResponseMetadata | undefined;
+    setMetadata(value?: ResponseMetadata): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetAddressesTrunkStateResponseV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetAddressesTrunkStateResponseV0): GetAddressesTrunkStateResponseV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetAddressesTrunkStateResponseV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetAddressesTrunkStateResponseV0;
+    static deserializeBinaryFromReader(message: GetAddressesTrunkStateResponseV0, reader: jspb.BinaryReader): GetAddressesTrunkStateResponseV0;
+  }
+
+  export namespace GetAddressesTrunkStateResponseV0 {
+    export type AsObject = {
+      proof?: Proof.AsObject,
+      metadata?: ResponseMetadata.AsObject,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetAddressesBranchStateRequest extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetAddressesBranchStateRequest.GetAddressesBranchStateRequestV0 | undefined;
+  setV0(value?: GetAddressesBranchStateRequest.GetAddressesBranchStateRequestV0): void;
+
+  getVersionCase(): GetAddressesBranchStateRequest.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetAddressesBranchStateRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetAddressesBranchStateRequest): GetAddressesBranchStateRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetAddressesBranchStateRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetAddressesBranchStateRequest;
+  static deserializeBinaryFromReader(message: GetAddressesBranchStateRequest, reader: jspb.BinaryReader): GetAddressesBranchStateRequest;
+}
+
+export namespace GetAddressesBranchStateRequest {
+  export type AsObject = {
+    v0?: GetAddressesBranchStateRequest.GetAddressesBranchStateRequestV0.AsObject,
+  }
+
+  export class GetAddressesBranchStateRequestV0 extends jspb.Message {
+    getKey(): Uint8Array | string;
+    getKey_asU8(): Uint8Array;
+    getKey_asB64(): string;
+    setKey(value: Uint8Array | string): void;
+
+    getDepth(): number;
+    setDepth(value: number): void;
+
+    getCheckpointHeight(): number;
+    setCheckpointHeight(value: number): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetAddressesBranchStateRequestV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetAddressesBranchStateRequestV0): GetAddressesBranchStateRequestV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetAddressesBranchStateRequestV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetAddressesBranchStateRequestV0;
+    static deserializeBinaryFromReader(message: GetAddressesBranchStateRequestV0, reader: jspb.BinaryReader): GetAddressesBranchStateRequestV0;
+  }
+
+  export namespace GetAddressesBranchStateRequestV0 {
+    export type AsObject = {
+      key: Uint8Array | string,
+      depth: number,
+      checkpointHeight: number,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetAddressesBranchStateResponse extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetAddressesBranchStateResponse.GetAddressesBranchStateResponseV0 | undefined;
+  setV0(value?: GetAddressesBranchStateResponse.GetAddressesBranchStateResponseV0): void;
+
+  getVersionCase(): GetAddressesBranchStateResponse.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetAddressesBranchStateResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetAddressesBranchStateResponse): GetAddressesBranchStateResponse.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetAddressesBranchStateResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetAddressesBranchStateResponse;
+  static deserializeBinaryFromReader(message: GetAddressesBranchStateResponse, reader: jspb.BinaryReader): GetAddressesBranchStateResponse;
+}
+
+export namespace GetAddressesBranchStateResponse {
+  export type AsObject = {
+    v0?: GetAddressesBranchStateResponse.GetAddressesBranchStateResponseV0.AsObject,
+  }
+
+  export class GetAddressesBranchStateResponseV0 extends jspb.Message {
+    getMerkProof(): Uint8Array | string;
+    getMerkProof_asU8(): Uint8Array;
+    getMerkProof_asB64(): string;
+    setMerkProof(value: Uint8Array | string): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetAddressesBranchStateResponseV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetAddressesBranchStateResponseV0): GetAddressesBranchStateResponseV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetAddressesBranchStateResponseV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetAddressesBranchStateResponseV0;
+    static deserializeBinaryFromReader(message: GetAddressesBranchStateResponseV0, reader: jspb.BinaryReader): GetAddressesBranchStateResponseV0;
+  }
+
+  export namespace GetAddressesBranchStateResponseV0 {
+    export type AsObject = {
+      merkProof: Uint8Array | string,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetRecentAddressBalanceChangesRequest extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetRecentAddressBalanceChangesRequest.GetRecentAddressBalanceChangesRequestV0 | undefined;
+  setV0(value?: GetRecentAddressBalanceChangesRequest.GetRecentAddressBalanceChangesRequestV0): void;
+
+  getVersionCase(): GetRecentAddressBalanceChangesRequest.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetRecentAddressBalanceChangesRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetRecentAddressBalanceChangesRequest): GetRecentAddressBalanceChangesRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetRecentAddressBalanceChangesRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetRecentAddressBalanceChangesRequest;
+  static deserializeBinaryFromReader(message: GetRecentAddressBalanceChangesRequest, reader: jspb.BinaryReader): GetRecentAddressBalanceChangesRequest;
+}
+
+export namespace GetRecentAddressBalanceChangesRequest {
+  export type AsObject = {
+    v0?: GetRecentAddressBalanceChangesRequest.GetRecentAddressBalanceChangesRequestV0.AsObject,
+  }
+
+  export class GetRecentAddressBalanceChangesRequestV0 extends jspb.Message {
+    getStartHeight(): string;
+    setStartHeight(value: string): void;
+
+    getProve(): boolean;
+    setProve(value: boolean): void;
+
+    getStartHeightExclusive(): boolean;
+    setStartHeightExclusive(value: boolean): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetRecentAddressBalanceChangesRequestV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetRecentAddressBalanceChangesRequestV0): GetRecentAddressBalanceChangesRequestV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetRecentAddressBalanceChangesRequestV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetRecentAddressBalanceChangesRequestV0;
+    static deserializeBinaryFromReader(message: GetRecentAddressBalanceChangesRequestV0, reader: jspb.BinaryReader): GetRecentAddressBalanceChangesRequestV0;
+  }
+
+  export namespace GetRecentAddressBalanceChangesRequestV0 {
+    export type AsObject = {
+      startHeight: string,
+      prove: boolean,
+      startHeightExclusive: boolean,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetRecentAddressBalanceChangesResponse extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetRecentAddressBalanceChangesResponse.GetRecentAddressBalanceChangesResponseV0 | undefined;
+  setV0(value?: GetRecentAddressBalanceChangesResponse.GetRecentAddressBalanceChangesResponseV0): void;
+
+  getVersionCase(): GetRecentAddressBalanceChangesResponse.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetRecentAddressBalanceChangesResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetRecentAddressBalanceChangesResponse): GetRecentAddressBalanceChangesResponse.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetRecentAddressBalanceChangesResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetRecentAddressBalanceChangesResponse;
+  static deserializeBinaryFromReader(message: GetRecentAddressBalanceChangesResponse, reader: jspb.BinaryReader): GetRecentAddressBalanceChangesResponse;
+}
+
+export namespace GetRecentAddressBalanceChangesResponse {
+  export type AsObject = {
+    v0?: GetRecentAddressBalanceChangesResponse.GetRecentAddressBalanceChangesResponseV0.AsObject,
+  }
+
+  export class GetRecentAddressBalanceChangesResponseV0 extends jspb.Message {
+    hasAddressBalanceUpdateEntries(): boolean;
+    clearAddressBalanceUpdateEntries(): void;
+    getAddressBalanceUpdateEntries(): AddressBalanceUpdateEntries | undefined;
+    setAddressBalanceUpdateEntries(value?: AddressBalanceUpdateEntries): void;
+
+    hasProof(): boolean;
+    clearProof(): void;
+    getProof(): Proof | undefined;
+    setProof(value?: Proof): void;
+
+    hasMetadata(): boolean;
+    clearMetadata(): void;
+    getMetadata(): ResponseMetadata | undefined;
+    setMetadata(value?: ResponseMetadata): void;
+
+    getResultCase(): GetRecentAddressBalanceChangesResponseV0.ResultCase;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetRecentAddressBalanceChangesResponseV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetRecentAddressBalanceChangesResponseV0): GetRecentAddressBalanceChangesResponseV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetRecentAddressBalanceChangesResponseV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetRecentAddressBalanceChangesResponseV0;
+    static deserializeBinaryFromReader(message: GetRecentAddressBalanceChangesResponseV0, reader: jspb.BinaryReader): GetRecentAddressBalanceChangesResponseV0;
+  }
+
+  export namespace GetRecentAddressBalanceChangesResponseV0 {
+    export type AsObject = {
+      addressBalanceUpdateEntries?: AddressBalanceUpdateEntries.AsObject,
+      proof?: Proof.AsObject,
+      metadata?: ResponseMetadata.AsObject,
+    }
+
+    export enum ResultCase {
+      RESULT_NOT_SET = 0,
+      ADDRESS_BALANCE_UPDATE_ENTRIES = 1,
+      PROOF = 2,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class BlockHeightCreditEntry extends jspb.Message {
+  getBlockHeight(): string;
+  setBlockHeight(value: string): void;
+
+  getCredits(): string;
+  setCredits(value: string): void;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): BlockHeightCreditEntry.AsObject;
+  static toObject(includeInstance: boolean, msg: BlockHeightCreditEntry): BlockHeightCreditEntry.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: BlockHeightCreditEntry, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): BlockHeightCreditEntry;
+  static deserializeBinaryFromReader(message: BlockHeightCreditEntry, reader: jspb.BinaryReader): BlockHeightCreditEntry;
+}
+
+export namespace BlockHeightCreditEntry {
+  export type AsObject = {
+    blockHeight: string,
+    credits: string,
+  }
+}
+
+export class CompactedAddressBalanceChange extends jspb.Message {
+  getAddress(): Uint8Array | string;
+  getAddress_asU8(): Uint8Array;
+  getAddress_asB64(): string;
+  setAddress(value: Uint8Array | string): void;
+
+  hasSetCredits(): boolean;
+  clearSetCredits(): void;
+  getSetCredits(): string;
+  setSetCredits(value: string): void;
+
+  hasAddToCreditsOperations(): boolean;
+  clearAddToCreditsOperations(): void;
+  getAddToCreditsOperations(): AddToCreditsOperations | undefined;
+  setAddToCreditsOperations(value?: AddToCreditsOperations): void;
+
+  getOperationCase(): CompactedAddressBalanceChange.OperationCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CompactedAddressBalanceChange.AsObject;
+  static toObject(includeInstance: boolean, msg: CompactedAddressBalanceChange): CompactedAddressBalanceChange.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: CompactedAddressBalanceChange, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CompactedAddressBalanceChange;
+  static deserializeBinaryFromReader(message: CompactedAddressBalanceChange, reader: jspb.BinaryReader): CompactedAddressBalanceChange;
+}
+
+export namespace CompactedAddressBalanceChange {
+  export type AsObject = {
+    address: Uint8Array | string,
+    setCredits: string,
+    addToCreditsOperations?: AddToCreditsOperations.AsObject,
+  }
+
+  export enum OperationCase {
+    OPERATION_NOT_SET = 0,
+    SET_CREDITS = 2,
+    ADD_TO_CREDITS_OPERATIONS = 3,
+  }
+}
+
+export class AddToCreditsOperations extends jspb.Message {
+  clearEntriesList(): void;
+  getEntriesList(): Array<BlockHeightCreditEntry>;
+  setEntriesList(value: Array<BlockHeightCreditEntry>): void;
+  addEntries(value?: BlockHeightCreditEntry, index?: number): BlockHeightCreditEntry;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): AddToCreditsOperations.AsObject;
+  static toObject(includeInstance: boolean, msg: AddToCreditsOperations): AddToCreditsOperations.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: AddToCreditsOperations, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): AddToCreditsOperations;
+  static deserializeBinaryFromReader(message: AddToCreditsOperations, reader: jspb.BinaryReader): AddToCreditsOperations;
+}
+
+export namespace AddToCreditsOperations {
+  export type AsObject = {
+    entriesList: Array<BlockHeightCreditEntry.AsObject>,
+  }
+}
+
+export class CompactedBlockAddressBalanceChanges extends jspb.Message {
+  getStartBlockHeight(): string;
+  setStartBlockHeight(value: string): void;
+
+  getEndBlockHeight(): string;
+  setEndBlockHeight(value: string): void;
+
+  clearChangesList(): void;
+  getChangesList(): Array<CompactedAddressBalanceChange>;
+  setChangesList(value: Array<CompactedAddressBalanceChange>): void;
+  addChanges(value?: CompactedAddressBalanceChange, index?: number): CompactedAddressBalanceChange;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CompactedBlockAddressBalanceChanges.AsObject;
+  static toObject(includeInstance: boolean, msg: CompactedBlockAddressBalanceChanges): CompactedBlockAddressBalanceChanges.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: CompactedBlockAddressBalanceChanges, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CompactedBlockAddressBalanceChanges;
+  static deserializeBinaryFromReader(message: CompactedBlockAddressBalanceChanges, reader: jspb.BinaryReader): CompactedBlockAddressBalanceChanges;
+}
+
+export namespace CompactedBlockAddressBalanceChanges {
+  export type AsObject = {
+    startBlockHeight: string,
+    endBlockHeight: string,
+    changesList: Array<CompactedAddressBalanceChange.AsObject>,
+  }
+}
+
+export class CompactedAddressBalanceUpdateEntries extends jspb.Message {
+  clearCompactedBlockChangesList(): void;
+  getCompactedBlockChangesList(): Array<CompactedBlockAddressBalanceChanges>;
+  setCompactedBlockChangesList(value: Array<CompactedBlockAddressBalanceChanges>): void;
+  addCompactedBlockChanges(value?: CompactedBlockAddressBalanceChanges, index?: number): CompactedBlockAddressBalanceChanges;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): CompactedAddressBalanceUpdateEntries.AsObject;
+  static toObject(includeInstance: boolean, msg: CompactedAddressBalanceUpdateEntries): CompactedAddressBalanceUpdateEntries.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: CompactedAddressBalanceUpdateEntries, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CompactedAddressBalanceUpdateEntries;
+  static deserializeBinaryFromReader(message: CompactedAddressBalanceUpdateEntries, reader: jspb.BinaryReader): CompactedAddressBalanceUpdateEntries;
+}
+
+export namespace CompactedAddressBalanceUpdateEntries {
+  export type AsObject = {
+    compactedBlockChangesList: Array<CompactedBlockAddressBalanceChanges.AsObject>,
+  }
+}
+
+export class GetRecentCompactedAddressBalanceChangesRequest extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetRecentCompactedAddressBalanceChangesRequest.GetRecentCompactedAddressBalanceChangesRequestV0 | undefined;
+  setV0(value?: GetRecentCompactedAddressBalanceChangesRequest.GetRecentCompactedAddressBalanceChangesRequestV0): void;
+
+  getVersionCase(): GetRecentCompactedAddressBalanceChangesRequest.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetRecentCompactedAddressBalanceChangesRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetRecentCompactedAddressBalanceChangesRequest): GetRecentCompactedAddressBalanceChangesRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetRecentCompactedAddressBalanceChangesRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetRecentCompactedAddressBalanceChangesRequest;
+  static deserializeBinaryFromReader(message: GetRecentCompactedAddressBalanceChangesRequest, reader: jspb.BinaryReader): GetRecentCompactedAddressBalanceChangesRequest;
+}
+
+export namespace GetRecentCompactedAddressBalanceChangesRequest {
+  export type AsObject = {
+    v0?: GetRecentCompactedAddressBalanceChangesRequest.GetRecentCompactedAddressBalanceChangesRequestV0.AsObject,
+  }
+
+  export class GetRecentCompactedAddressBalanceChangesRequestV0 extends jspb.Message {
+    getStartBlockHeight(): string;
+    setStartBlockHeight(value: string): void;
+
+    getProve(): boolean;
+    setProve(value: boolean): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetRecentCompactedAddressBalanceChangesRequestV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetRecentCompactedAddressBalanceChangesRequestV0): GetRecentCompactedAddressBalanceChangesRequestV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetRecentCompactedAddressBalanceChangesRequestV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetRecentCompactedAddressBalanceChangesRequestV0;
+    static deserializeBinaryFromReader(message: GetRecentCompactedAddressBalanceChangesRequestV0, reader: jspb.BinaryReader): GetRecentCompactedAddressBalanceChangesRequestV0;
+  }
+
+  export namespace GetRecentCompactedAddressBalanceChangesRequestV0 {
+    export type AsObject = {
+      startBlockHeight: string,
+      prove: boolean,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetRecentCompactedAddressBalanceChangesResponse extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetRecentCompactedAddressBalanceChangesResponse.GetRecentCompactedAddressBalanceChangesResponseV0 | undefined;
+  setV0(value?: GetRecentCompactedAddressBalanceChangesResponse.GetRecentCompactedAddressBalanceChangesResponseV0): void;
+
+  getVersionCase(): GetRecentCompactedAddressBalanceChangesResponse.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetRecentCompactedAddressBalanceChangesResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetRecentCompactedAddressBalanceChangesResponse): GetRecentCompactedAddressBalanceChangesResponse.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetRecentCompactedAddressBalanceChangesResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetRecentCompactedAddressBalanceChangesResponse;
+  static deserializeBinaryFromReader(message: GetRecentCompactedAddressBalanceChangesResponse, reader: jspb.BinaryReader): GetRecentCompactedAddressBalanceChangesResponse;
+}
+
+export namespace GetRecentCompactedAddressBalanceChangesResponse {
+  export type AsObject = {
+    v0?: GetRecentCompactedAddressBalanceChangesResponse.GetRecentCompactedAddressBalanceChangesResponseV0.AsObject,
+  }
+
+  export class GetRecentCompactedAddressBalanceChangesResponseV0 extends jspb.Message {
+    hasCompactedAddressBalanceUpdateEntries(): boolean;
+    clearCompactedAddressBalanceUpdateEntries(): void;
+    getCompactedAddressBalanceUpdateEntries(): CompactedAddressBalanceUpdateEntries | undefined;
+    setCompactedAddressBalanceUpdateEntries(value?: CompactedAddressBalanceUpdateEntries): void;
+
+    hasProof(): boolean;
+    clearProof(): void;
+    getProof(): Proof | undefined;
+    setProof(value?: Proof): void;
+
+    hasMetadata(): boolean;
+    clearMetadata(): void;
+    getMetadata(): ResponseMetadata | undefined;
+    setMetadata(value?: ResponseMetadata): void;
+
+    getResultCase(): GetRecentCompactedAddressBalanceChangesResponseV0.ResultCase;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetRecentCompactedAddressBalanceChangesResponseV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetRecentCompactedAddressBalanceChangesResponseV0): GetRecentCompactedAddressBalanceChangesResponseV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetRecentCompactedAddressBalanceChangesResponseV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetRecentCompactedAddressBalanceChangesResponseV0;
+    static deserializeBinaryFromReader(message: GetRecentCompactedAddressBalanceChangesResponseV0, reader: jspb.BinaryReader): GetRecentCompactedAddressBalanceChangesResponseV0;
+  }
+
+  export namespace GetRecentCompactedAddressBalanceChangesResponseV0 {
+    export type AsObject = {
+      compactedAddressBalanceUpdateEntries?: CompactedAddressBalanceUpdateEntries.AsObject,
+      proof?: Proof.AsObject,
+      metadata?: ResponseMetadata.AsObject,
+    }
+
+    export enum ResultCase {
+      RESULT_NOT_SET = 0,
+      COMPACTED_ADDRESS_BALANCE_UPDATE_ENTRIES = 1,
+      PROOF = 2,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetShieldedEncryptedNotesRequest extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetShieldedEncryptedNotesRequest.GetShieldedEncryptedNotesRequestV0 | undefined;
+  setV0(value?: GetShieldedEncryptedNotesRequest.GetShieldedEncryptedNotesRequestV0): void;
+
+  getVersionCase(): GetShieldedEncryptedNotesRequest.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetShieldedEncryptedNotesRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetShieldedEncryptedNotesRequest): GetShieldedEncryptedNotesRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetShieldedEncryptedNotesRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetShieldedEncryptedNotesRequest;
+  static deserializeBinaryFromReader(message: GetShieldedEncryptedNotesRequest, reader: jspb.BinaryReader): GetShieldedEncryptedNotesRequest;
+}
+
+export namespace GetShieldedEncryptedNotesRequest {
+  export type AsObject = {
+    v0?: GetShieldedEncryptedNotesRequest.GetShieldedEncryptedNotesRequestV0.AsObject,
+  }
+
+  export class GetShieldedEncryptedNotesRequestV0 extends jspb.Message {
+    getStartIndex(): number;
+    setStartIndex(value: number): void;
+
+    getCount(): number;
+    setCount(value: number): void;
+
+    getProve(): boolean;
+    setProve(value: boolean): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetShieldedEncryptedNotesRequestV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetShieldedEncryptedNotesRequestV0): GetShieldedEncryptedNotesRequestV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetShieldedEncryptedNotesRequestV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetShieldedEncryptedNotesRequestV0;
+    static deserializeBinaryFromReader(message: GetShieldedEncryptedNotesRequestV0, reader: jspb.BinaryReader): GetShieldedEncryptedNotesRequestV0;
+  }
+
+  export namespace GetShieldedEncryptedNotesRequestV0 {
+    export type AsObject = {
+      startIndex: number,
+      count: number,
+      prove: boolean,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetShieldedEncryptedNotesResponse extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0 | undefined;
+  setV0(value?: GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0): void;
+
+  getVersionCase(): GetShieldedEncryptedNotesResponse.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetShieldedEncryptedNotesResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetShieldedEncryptedNotesResponse): GetShieldedEncryptedNotesResponse.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetShieldedEncryptedNotesResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetShieldedEncryptedNotesResponse;
+  static deserializeBinaryFromReader(message: GetShieldedEncryptedNotesResponse, reader: jspb.BinaryReader): GetShieldedEncryptedNotesResponse;
+}
+
+export namespace GetShieldedEncryptedNotesResponse {
+  export type AsObject = {
+    v0?: GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.AsObject,
+  }
+
+  export class GetShieldedEncryptedNotesResponseV0 extends jspb.Message {
+    hasEncryptedNotes(): boolean;
+    clearEncryptedNotes(): void;
+    getEncryptedNotes(): GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNotes | undefined;
+    setEncryptedNotes(value?: GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNotes): void;
+
+    hasProof(): boolean;
+    clearProof(): void;
+    getProof(): Proof | undefined;
+    setProof(value?: Proof): void;
+
+    hasMetadata(): boolean;
+    clearMetadata(): void;
+    getMetadata(): ResponseMetadata | undefined;
+    setMetadata(value?: ResponseMetadata): void;
+
+    getResultCase(): GetShieldedEncryptedNotesResponseV0.ResultCase;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetShieldedEncryptedNotesResponseV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetShieldedEncryptedNotesResponseV0): GetShieldedEncryptedNotesResponseV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetShieldedEncryptedNotesResponseV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetShieldedEncryptedNotesResponseV0;
+    static deserializeBinaryFromReader(message: GetShieldedEncryptedNotesResponseV0, reader: jspb.BinaryReader): GetShieldedEncryptedNotesResponseV0;
+  }
+
+  export namespace GetShieldedEncryptedNotesResponseV0 {
+    export type AsObject = {
+      encryptedNotes?: GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNotes.AsObject,
+      proof?: Proof.AsObject,
+      metadata?: ResponseMetadata.AsObject,
+    }
+
+    export class EncryptedNote extends jspb.Message {
+      getNullifier(): Uint8Array | string;
+      getNullifier_asU8(): Uint8Array;
+      getNullifier_asB64(): string;
+      setNullifier(value: Uint8Array | string): void;
+
+      getCmx(): Uint8Array | string;
+      getCmx_asU8(): Uint8Array;
+      getCmx_asB64(): string;
+      setCmx(value: Uint8Array | string): void;
+
+      getEncryptedNote(): Uint8Array | string;
+      getEncryptedNote_asU8(): Uint8Array;
+      getEncryptedNote_asB64(): string;
+      setEncryptedNote(value: Uint8Array | string): void;
+
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): EncryptedNote.AsObject;
+      static toObject(includeInstance: boolean, msg: EncryptedNote): EncryptedNote.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: EncryptedNote, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): EncryptedNote;
+      static deserializeBinaryFromReader(message: EncryptedNote, reader: jspb.BinaryReader): EncryptedNote;
+    }
+
+    export namespace EncryptedNote {
+      export type AsObject = {
+        nullifier: Uint8Array | string,
+        cmx: Uint8Array | string,
+        encryptedNote: Uint8Array | string,
+      }
+    }
+
+    export class EncryptedNotes extends jspb.Message {
+      clearEntriesList(): void;
+      getEntriesList(): Array<GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNote>;
+      setEntriesList(value: Array<GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNote>): void;
+      addEntries(value?: GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNote, index?: number): GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNote;
+
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): EncryptedNotes.AsObject;
+      static toObject(includeInstance: boolean, msg: EncryptedNotes): EncryptedNotes.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: EncryptedNotes, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): EncryptedNotes;
+      static deserializeBinaryFromReader(message: EncryptedNotes, reader: jspb.BinaryReader): EncryptedNotes;
+    }
+
+    export namespace EncryptedNotes {
+      export type AsObject = {
+        entriesList: Array<GetShieldedEncryptedNotesResponse.GetShieldedEncryptedNotesResponseV0.EncryptedNote.AsObject>,
+      }
+    }
+
+    export enum ResultCase {
+      RESULT_NOT_SET = 0,
+      ENCRYPTED_NOTES = 1,
+      PROOF = 2,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetShieldedAnchorsRequest extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetShieldedAnchorsRequest.GetShieldedAnchorsRequestV0 | undefined;
+  setV0(value?: GetShieldedAnchorsRequest.GetShieldedAnchorsRequestV0): void;
+
+  getVersionCase(): GetShieldedAnchorsRequest.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetShieldedAnchorsRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetShieldedAnchorsRequest): GetShieldedAnchorsRequest.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetShieldedAnchorsRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetShieldedAnchorsRequest;
+  static deserializeBinaryFromReader(message: GetShieldedAnchorsRequest, reader: jspb.BinaryReader): GetShieldedAnchorsRequest;
+}
+
+export namespace GetShieldedAnchorsRequest {
+  export type AsObject = {
+    v0?: GetShieldedAnchorsRequest.GetShieldedAnchorsRequestV0.AsObject,
+  }
+
+  export class GetShieldedAnchorsRequestV0 extends jspb.Message {
+    getProve(): boolean;
+    setProve(value: boolean): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetShieldedAnchorsRequestV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetShieldedAnchorsRequestV0): GetShieldedAnchorsRequestV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetShieldedAnchorsRequestV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetShieldedAnchorsRequestV0;
+    static deserializeBinaryFromReader(message: GetShieldedAnchorsRequestV0, reader: jspb.BinaryReader): GetShieldedAnchorsRequestV0;
+  }
+
+  export namespace GetShieldedAnchorsRequestV0 {
+    export type AsObject = {
+      prove: boolean,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetShieldedAnchorsResponse extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0 | undefined;
+  setV0(value?: GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0): void;
+
+  getVersionCase(): GetShieldedAnchorsResponse.VersionCase;
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): GetShieldedAnchorsResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetShieldedAnchorsResponse): GetShieldedAnchorsResponse.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: GetShieldedAnchorsResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetShieldedAnchorsResponse;
+  static deserializeBinaryFromReader(message: GetShieldedAnchorsResponse, reader: jspb.BinaryReader): GetShieldedAnchorsResponse;
+}
+
+export namespace GetShieldedAnchorsResponse {
+  export type AsObject = {
+    v0?: GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0.AsObject,
+  }
+
+  export class GetShieldedAnchorsResponseV0 extends jspb.Message {
+    hasAnchors(): boolean;
+    clearAnchors(): void;
+    getAnchors(): GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0.Anchors | undefined;
+    setAnchors(value?: GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0.Anchors): void;
+
+    hasProof(): boolean;
+    clearProof(): void;
+    getProof(): Proof | undefined;
+    setProof(value?: Proof): void;
+
+    hasMetadata(): boolean;
+    clearMetadata(): void;
+    getMetadata(): ResponseMetadata | undefined;
+    setMetadata(value?: ResponseMetadata): void;
+
+    getResultCase(): GetShieldedAnchorsResponseV0.ResultCase;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetShieldedAnchorsResponseV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetShieldedAnchorsResponseV0): GetShieldedAnchorsResponseV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetShieldedAnchorsResponseV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetShieldedAnchorsResponseV0;
+    static deserializeBinaryFromReader(message: GetShieldedAnchorsResponseV0, reader: jspb.BinaryReader): GetShieldedAnchorsResponseV0;
+  }
+
+  export namespace GetShieldedAnchorsResponseV0 {
+    export type AsObject = {
+      anchors?: GetShieldedAnchorsResponse.GetShieldedAnchorsResponseV0.Anchors.AsObject,
+      proof?: Proof.AsObject,
+      metadata?: ResponseMetadata.AsObject,
+    }
+
+    export class Anchors extends jspb.Message {
+      clearAnchorsList(): void;
+      getAnchorsList(): Array<Uint8Array | string>;
+      getAnchorsList_asU8(): Array<Uint8Array>;
+      getAnchorsList_asB64(): Array<string>;
+      setAnchorsList(value: Array<Uint8Array | string>): void;
+      addAnchors(value: Uint8Array | string, index?: number): Uint8Array | string;
+
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): Anchors.AsObject;
+      static toObject(includeInstance: boolean, msg: Anchors): Anchors.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: Anchors, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): Anchors;
+      static deserializeBinaryFromReader(message: Anchors, reader: jspb.BinaryReader): Anchors;
+    }
+
+    export namespace Anchors {
+      export type AsObject = {
+        anchorsList: Array<Uint8Array | string>,
+      }
+    }
+
+    export enum ResultCase {
+      RESULT_NOT_SET = 0,
+      ANCHORS = 1,
+      PROOF = 2,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetMostRecentShieldedAnchorRequest extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetMostRecentShieldedAnchorRequest.GetMostRecentShieldedAnchorRequestV0 | undefined;
+  setV0(value?: GetMostRecentShieldedAnchorRequest.GetMostRecentShieldedAnchorRequestV0): void;
 
-  getOperationCase(): AddressBalanceChange.OperationCase;
+  getVersionCase(): GetMostRecentShieldedAnchorRequest.VersionCase;
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): AddressBalanceChange.AsObject;
-  static toObject(includeInstance: boolean, msg: AddressBalanceChange): AddressBalanceChange.AsObject;
+  toObject(includeInstance?: boolean): GetMostRecentShieldedAnchorRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetMostRecentShieldedAnchorRequest): GetMostRecentShieldedAnchorRequest.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: AddressBalanceChange, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): AddressBalanceChange;
-  static deserializeBinaryFromReader(message: AddressBalanceChange, reader: jspb.BinaryReader): AddressBalanceChange;
+  static serializeBinaryToWriter(message: GetMostRecentShieldedAnchorRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetMostRecentShieldedAnchorRequest;
+  static deserializeBinaryFromReader(message: GetMostRecentShieldedAnchorRequest, reader: jspb.BinaryReader): GetMostRecentShieldedAnchorRequest;
 }
 
-export namespace AddressBalanceChange {
+export namespace GetMostRecentShieldedAnchorRequest {
   export type AsObject = {
-    address: Uint8Array | string,
-    setBalance: string,
-    addToBalance: string,
+    v0?: GetMostRecentShieldedAnchorRequest.GetMostRecentShieldedAnchorRequestV0.AsObject,
   }
 
-  export enum OperationCase {
-    OPERATION_NOT_SET = 0,
-    SET_BALANCE = 2,
-    ADD_TO_BALANCE = 3,
+  export class GetMostRecentShieldedAnchorRequestV0 extends jspb.Message {
+    getProve(): boolean;
+    setProve(value: boolean): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetMostRecentShieldedAnchorRequestV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetMostRecentShieldedAnchorRequestV0): GetMostRecentShieldedAnchorRequestV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetMostRecentShieldedAnchorRequestV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetMostRecentShieldedAnchorRequestV0;
+    static deserializeBinaryFromReader(message: GetMostRecentShieldedAnchorRequestV0, reader: jspb.BinaryReader): GetMostRecentShieldedAnchorRequestV0;
   }
-}
 
-export class BlockAddressBalanceChanges extends jspb.Message {
-  getBlockHeight(): string;
-  setBlockHeight(value: string): void;
+  export namespace GetMostRecentShieldedAnchorRequestV0 {
+    export type AsObject = {
+      prove: boolean,
+    }
+  }
 
-  clearChangesList(): void;
-  getChangesList(): Array<AddressBalanceChange>;
-  setChangesList(value: Array<AddressBalanceChange>): void;
-  addChanges(value?: AddressBalanceChange, index?: number): AddressBalanceChange;
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
+  }
+}
+
+export class GetMostRecentShieldedAnchorResponse extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetMostRecentShieldedAnchorResponse.GetMostRecentShieldedAnchorResponseV0 | undefined;
+  setV0(value?: GetMostRecentShieldedAnchorResponse.GetMostRecentShieldedAnchorResponseV0): void;
 
+  getVersionCase(): GetMostRecentShieldedAnchorResponse.VersionCase;
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): BlockAddressBalanceChanges.AsObject;
-  static toObject(includeInstance: boolean, msg: BlockAddressBalanceChanges): BlockAddressBalanceChanges.AsObject;
+  toObject(includeInstance?: boolean): GetMostRecentShieldedAnchorResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetMostRecentShieldedAnchorResponse): GetMostRecentShieldedAnchorResponse.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: BlockAddressBalanceChanges, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): BlockAddressBalanceChanges;
-  static deserializeBinaryFromReader(message: BlockAddressBalanceChanges, reader: jspb.BinaryReader): BlockAddressBalanceChanges;
+  static serializeBinaryToWriter(message: GetMostRecentShieldedAnchorResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetMostRecentShieldedAnchorResponse;
+  static deserializeBinaryFromReader(message: GetMostRecentShieldedAnchorResponse, reader: jspb.BinaryReader): GetMostRecentShieldedAnchorResponse;
 }
 
-export namespace BlockAddressBalanceChanges {
+export namespace GetMostRecentShieldedAnchorResponse {
   export type AsObject = {
-    blockHeight: string,
-    changesList: Array<AddressBalanceChange.AsObject>,
+    v0?: GetMostRecentShieldedAnchorResponse.GetMostRecentShieldedAnchorResponseV0.AsObject,
+  }
+
+  export class GetMostRecentShieldedAnchorResponseV0 extends jspb.Message {
+    hasAnchor(): boolean;
+    clearAnchor(): void;
+    getAnchor(): Uint8Array | string;
+    getAnchor_asU8(): Uint8Array;
+    getAnchor_asB64(): string;
+    setAnchor(value: Uint8Array | string): void;
+
+    hasProof(): boolean;
+    clearProof(): void;
+    getProof(): Proof | undefined;
+    setProof(value?: Proof): void;
+
+    hasMetadata(): boolean;
+    clearMetadata(): void;
+    getMetadata(): ResponseMetadata | undefined;
+    setMetadata(value?: ResponseMetadata): void;
+
+    getResultCase(): GetMostRecentShieldedAnchorResponseV0.ResultCase;
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetMostRecentShieldedAnchorResponseV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetMostRecentShieldedAnchorResponseV0): GetMostRecentShieldedAnchorResponseV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetMostRecentShieldedAnchorResponseV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetMostRecentShieldedAnchorResponseV0;
+    static deserializeBinaryFromReader(message: GetMostRecentShieldedAnchorResponseV0, reader: jspb.BinaryReader): GetMostRecentShieldedAnchorResponseV0;
+  }
+
+  export namespace GetMostRecentShieldedAnchorResponseV0 {
+    export type AsObject = {
+      anchor: Uint8Array | string,
+      proof?: Proof.AsObject,
+      metadata?: ResponseMetadata.AsObject,
+    }
+
+    export enum ResultCase {
+      RESULT_NOT_SET = 0,
+      ANCHOR = 1,
+      PROOF = 2,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
   }
 }
 
-export class AddressBalanceUpdateEntries extends jspb.Message {
-  clearBlockChangesList(): void;
-  getBlockChangesList(): Array<BlockAddressBalanceChanges>;
-  setBlockChangesList(value: Array<BlockAddressBalanceChanges>): void;
-  addBlockChanges(value?: BlockAddressBalanceChanges, index?: number): BlockAddressBalanceChanges;
+export class GetShieldedPoolStateRequest extends jspb.Message {
+  hasV0(): boolean;
+  clearV0(): void;
+  getV0(): GetShieldedPoolStateRequest.GetShieldedPoolStateRequestV0 | undefined;
+  setV0(value?: GetShieldedPoolStateRequest.GetShieldedPoolStateRequestV0): void;
 
+  getVersionCase(): GetShieldedPoolStateRequest.VersionCase;
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): AddressBalanceUpdateEntries.AsObject;
-  static toObject(includeInstance: boolean, msg: AddressBalanceUpdateEntries): AddressBalanceUpdateEntries.AsObject;
+  toObject(includeInstance?: boolean): GetShieldedPoolStateRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetShieldedPoolStateRequest): GetShieldedPoolStateRequest.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: AddressBalanceUpdateEntries, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): AddressBalanceUpdateEntries;
-  static deserializeBinaryFromReader(message: AddressBalanceUpdateEntries, reader: jspb.BinaryReader): AddressBalanceUpdateEntries;
+  static serializeBinaryToWriter(message: GetShieldedPoolStateRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetShieldedPoolStateRequest;
+  static deserializeBinaryFromReader(message: GetShieldedPoolStateRequest, reader: jspb.BinaryReader): GetShieldedPoolStateRequest;
 }
 
-export namespace AddressBalanceUpdateEntries {
+export namespace GetShieldedPoolStateRequest {
   export type AsObject = {
-    blockChangesList: Array<BlockAddressBalanceChanges.AsObject>,
+    v0?: GetShieldedPoolStateRequest.GetShieldedPoolStateRequestV0.AsObject,
+  }
+
+  export class GetShieldedPoolStateRequestV0 extends jspb.Message {
+    getProve(): boolean;
+    setProve(value: boolean): void;
+
+    serializeBinary(): Uint8Array;
+    toObject(includeInstance?: boolean): GetShieldedPoolStateRequestV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetShieldedPoolStateRequestV0): GetShieldedPoolStateRequestV0.AsObject;
+    static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+    static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+    static serializeBinaryToWriter(message: GetShieldedPoolStateRequestV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetShieldedPoolStateRequestV0;
+    static deserializeBinaryFromReader(message: GetShieldedPoolStateRequestV0, reader: jspb.BinaryReader): GetShieldedPoolStateRequestV0;
+  }
+
+  export namespace GetShieldedPoolStateRequestV0 {
+    export type AsObject = {
+      prove: boolean,
+    }
+  }
+
+  export enum VersionCase {
+    VERSION_NOT_SET = 0,
+    V0 = 1,
   }
 }
 
-export class GetAddressInfoResponse extends jspb.Message {
+export class GetShieldedPoolStateResponse extends jspb.Message {
   hasV0(): boolean;
   clearV0(): void;
-  getV0(): GetAddressInfoResponse.GetAddressInfoResponseV0 | undefined;
-  setV0(value?: GetAddressInfoResponse.GetAddressInfoResponseV0): void;
+  getV0(): GetShieldedPoolStateResponse.GetShieldedPoolStateResponseV0 | undefined;
+  setV0(value?: GetShieldedPoolStateResponse.GetShieldedPoolStateResponseV0): void;
 
-  getVersionCase(): GetAddressInfoResponse.VersionCase;
+  getVersionCase(): GetShieldedPoolStateResponse.VersionCase;
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): GetAddressInfoResponse.AsObject;
-  static toObject(includeInstance: boolean, msg: GetAddressInfoResponse): GetAddressInfoResponse.AsObject;
+  toObject(includeInstance?: boolean): GetShieldedPoolStateResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetShieldedPoolStateResponse): GetShieldedPoolStateResponse.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: GetAddressInfoResponse, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): GetAddressInfoResponse;
-  static deserializeBinaryFromReader(message: GetAddressInfoResponse, reader: jspb.BinaryReader): GetAddressInfoResponse;
+  static serializeBinaryToWriter(message: GetShieldedPoolStateResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetShieldedPoolStateResponse;
+  static deserializeBinaryFromReader(message: GetShieldedPoolStateResponse, reader: jspb.BinaryReader): GetShieldedPoolStateResponse;
 }
 
-export namespace GetAddressInfoResponse {
+export namespace GetShieldedPoolStateResponse {
   export type AsObject = {
-    v0?: GetAddressInfoResponse.GetAddressInfoResponseV0.AsObject,
+    v0?: GetShieldedPoolStateResponse.GetShieldedPoolStateResponseV0.AsObject,
   }
 
-  export class GetAddressInfoResponseV0 extends jspb.Message {
-    hasAddressInfoEntry(): boolean;
-    clearAddressInfoEntry(): void;
-    getAddressInfoEntry(): AddressInfoEntry | undefined;
-    setAddressInfoEntry(value?: AddressInfoEntry): void;
+  export class GetShieldedPoolStateResponseV0 extends jspb.Message {
+    hasTotalBalance(): boolean;
+    clearTotalBalance(): void;
+    getTotalBalance(): string;
+    setTotalBalance(value: string): void;
 
     hasProof(): boolean;
     clearProof(): void;
@@ -9757,27 +11906,27 @@ export namespace GetAddressInfoResponse {
     getMetadata(): ResponseMetadata | undefined;
     setMetadata(value?: ResponseMetadata): void;
 
-    getResultCase(): GetAddressInfoResponseV0.ResultCase;
+    getResultCase(): GetShieldedPoolStateResponseV0.ResultCase;
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): GetAddressInfoResponseV0.AsObject;
-    static toObject(includeInstance: boolean, msg: GetAddressInfoResponseV0): GetAddressInfoResponseV0.AsObject;
+    toObject(includeInstance?: boolean): GetShieldedPoolStateResponseV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetShieldedPoolStateResponseV0): GetShieldedPoolStateResponseV0.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: GetAddressInfoResponseV0, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): GetAddressInfoResponseV0;
-    static deserializeBinaryFromReader(message: GetAddressInfoResponseV0, reader: jspb.BinaryReader): GetAddressInfoResponseV0;
+    static serializeBinaryToWriter(message: GetShieldedPoolStateResponseV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetShieldedPoolStateResponseV0;
+    static deserializeBinaryFromReader(message: GetShieldedPoolStateResponseV0, reader: jspb.BinaryReader): GetShieldedPoolStateResponseV0;
   }
 
-  export namespace GetAddressInfoResponseV0 {
+  export namespace GetShieldedPoolStateResponseV0 {
     export type AsObject = {
-      addressInfoEntry?: AddressInfoEntry.AsObject,
+      totalBalance: string,
       proof?: Proof.AsObject,
       metadata?: ResponseMetadata.AsObject,
     }
 
     export enum ResultCase {
       RESULT_NOT_SET = 0,
-      ADDRESS_INFO_ENTRY = 1,
+      TOTAL_BALANCE = 1,
       PROOF = 2,
     }
   }
@@ -9788,52 +11937,52 @@ export namespace GetAddressInfoResponse {
   }
 }
 
-export class GetAddressesInfosRequest extends jspb.Message {
+export class GetShieldedNullifiersRequest extends jspb.Message {
   hasV0(): boolean;
   clearV0(): void;
-  getV0(): GetAddressesInfosRequest.GetAddressesInfosRequestV0 | undefined;
-  setV0(value?: GetAddressesInfosRequest.GetAddressesInfosRequestV0): void;
+  getV0(): GetShieldedNullifiersRequest.GetShieldedNullifiersRequestV0 | undefined;
+  setV0(value?: GetShieldedNullifiersRequest.GetShieldedNullifiersRequestV0): void;
 
-  getVersionCase(): GetAddressesInfosRequest.VersionCase;
+  getVersionCase(): GetShieldedNullifiersRequest.VersionCase;
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): GetAddressesInfosRequest.AsObject;
-  static toObject(includeInstance: boolean, msg: GetAddressesInfosRequest): GetAddressesInfosRequest.AsObject;
+  toObject(includeInstance?: boolean): GetShieldedNullifiersRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetShieldedNullifiersRequest): GetShieldedNullifiersRequest.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: GetAddressesInfosRequest, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): GetAddressesInfosRequest;
-  static deserializeBinaryFromReader(message: GetAddressesInfosRequest, reader: jspb.BinaryReader): GetAddressesInfosRequest;
+  static serializeBinaryToWriter(message: GetShieldedNullifiersRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetShieldedNullifiersRequest;
+  static deserializeBinaryFromReader(message: GetShieldedNullifiersRequest, reader: jspb.BinaryReader): GetShieldedNullifiersRequest;
 }
 
-export namespace GetAddressesInfosRequest {
+export namespace GetShieldedNullifiersRequest {
   export type AsObject = {
-    v0?: GetAddressesInfosRequest.GetAddressesInfosRequestV0.AsObject,
+    v0?: GetShieldedNullifiersRequest.GetShieldedNullifiersRequestV0.AsObject,
   }
 
-  export class GetAddressesInfosRequestV0 extends jspb.Message {
-    clearAddressesList(): void;
-    getAddressesList(): Array<Uint8Array | string>;
-    getAddressesList_asU8(): Array<Uint8Array>;
-    getAddressesList_asB64(): Array<string>;
-    setAddressesList(value: Array<Uint8Array | string>): void;
-    addAddresses(value: Uint8Array | string, index?: number): Uint8Array | string;
+  export class GetShieldedNullifiersRequestV0 extends jspb.Message {
+    clearNullifiersList(): void;
+    getNullifiersList(): Array<Uint8Array | string>;
+    getNullifiersList_asU8(): Array<Uint8Array>;
+    getNullifiersList_asB64(): Array<string>;
+    setNullifiersList(value: Array<Uint8Array | string>): void;
+    addNullifiers(value: Uint8Array | string, index?: number): Uint8Array | string;
 
     getProve(): boolean;
     setProve(value: boolean): void;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): GetAddressesInfosRequestV0.AsObject;
-    static toObject(includeInstance: boolean, msg: GetAddressesInfosRequestV0): GetAddressesInfosRequestV0.AsObject;
+    toObject(includeInstance?: boolean): GetShieldedNullifiersRequestV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetShieldedNullifiersRequestV0): GetShieldedNullifiersRequestV0.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: GetAddressesInfosRequestV0, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): GetAddressesInfosRequestV0;
-    static deserializeBinaryFromReader(message: GetAddressesInfosRequestV0, reader: jspb.BinaryReader): GetAddressesInfosRequestV0;
+    static serializeBinaryToWriter(message: GetShieldedNullifiersRequestV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetShieldedNullifiersRequestV0;
+    static deserializeBinaryFromReader(message: GetShieldedNullifiersRequestV0, reader: jspb.BinaryReader): GetShieldedNullifiersRequestV0;
   }
 
-  export namespace GetAddressesInfosRequestV0 {
+  export namespace GetShieldedNullifiersRequestV0 {
     export type AsObject = {
-      addressesList: Array<Uint8Array | string>,
+      nullifiersList: Array<Uint8Array | string>,
       prove: boolean,
     }
   }
@@ -9844,33 +11993,33 @@ export namespace GetAddressesInfosRequest {
   }
 }
 
-export class GetAddressesInfosResponse extends jspb.Message {
+export class GetShieldedNullifiersResponse extends jspb.Message {
   hasV0(): boolean;
   clearV0(): void;
-  getV0(): GetAddressesInfosResponse.GetAddressesInfosResponseV0 | undefined;
-  setV0(value?: GetAddressesInfosResponse.GetAddressesInfosResponseV0): void;
+  getV0(): GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0 | undefined;
+  setV0(value?: GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0): void;
 
-  getVersionCase(): GetAddressesInfosResponse.VersionCase;
+  getVersionCase(): GetShieldedNullifiersResponse.VersionCase;
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): GetAddressesInfosResponse.AsObject;
-  static toObject(includeInstance: boolean, msg: GetAddressesInfosResponse): GetAddressesInfosResponse.AsObject;
+  toObject(includeInstance?: boolean): GetShieldedNullifiersResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetShieldedNullifiersResponse): GetShieldedNullifiersResponse.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: GetAddressesInfosResponse, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): GetAddressesInfosResponse;
-  static deserializeBinaryFromReader(message: GetAddressesInfosResponse, reader: jspb.BinaryReader): GetAddressesInfosResponse;
+  static serializeBinaryToWriter(message: GetShieldedNullifiersResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetShieldedNullifiersResponse;
+  static deserializeBinaryFromReader(message: GetShieldedNullifiersResponse, reader: jspb.BinaryReader): GetShieldedNullifiersResponse;
 }
 
-export namespace GetAddressesInfosResponse {
+export namespace GetShieldedNullifiersResponse {
   export type AsObject = {
-    v0?: GetAddressesInfosResponse.GetAddressesInfosResponseV0.AsObject,
+    v0?: GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.AsObject,
   }
 
-  export class GetAddressesInfosResponseV0 extends jspb.Message {
-    hasAddressInfoEntries(): boolean;
-    clearAddressInfoEntries(): void;
-    getAddressInfoEntries(): AddressInfoEntries | undefined;
-    setAddressInfoEntries(value?: AddressInfoEntries): void;
+  export class GetShieldedNullifiersResponseV0 extends jspb.Message {
+    hasNullifierStatuses(): boolean;
+    clearNullifierStatuses(): void;
+    getNullifierStatuses(): GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatuses | undefined;
+    setNullifierStatuses(value?: GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatuses): void;
 
     hasProof(): boolean;
     clearProof(): void;
@@ -9882,27 +12031,75 @@ export namespace GetAddressesInfosResponse {
     getMetadata(): ResponseMetadata | undefined;
     setMetadata(value?: ResponseMetadata): void;
 
-    getResultCase(): GetAddressesInfosResponseV0.ResultCase;
+    getResultCase(): GetShieldedNullifiersResponseV0.ResultCase;
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): GetAddressesInfosResponseV0.AsObject;
-    static toObject(includeInstance: boolean, msg: GetAddressesInfosResponseV0): GetAddressesInfosResponseV0.AsObject;
+    toObject(includeInstance?: boolean): GetShieldedNullifiersResponseV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetShieldedNullifiersResponseV0): GetShieldedNullifiersResponseV0.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: GetAddressesInfosResponseV0, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): GetAddressesInfosResponseV0;
-    static deserializeBinaryFromReader(message: GetAddressesInfosResponseV0, reader: jspb.BinaryReader): GetAddressesInfosResponseV0;
+    static serializeBinaryToWriter(message: GetShieldedNullifiersResponseV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetShieldedNullifiersResponseV0;
+    static deserializeBinaryFromReader(message: GetShieldedNullifiersResponseV0, reader: jspb.BinaryReader): GetShieldedNullifiersResponseV0;
   }
 
-  export namespace GetAddressesInfosResponseV0 {
+  export namespace GetShieldedNullifiersResponseV0 {
     export type AsObject = {
-      addressInfoEntries?: AddressInfoEntries.AsObject,
+      nullifierStatuses?: GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatuses.AsObject,
       proof?: Proof.AsObject,
       metadata?: ResponseMetadata.AsObject,
     }
 
+    export class NullifierStatus extends jspb.Message {
+      getNullifier(): Uint8Array | string;
+      getNullifier_asU8(): Uint8Array;
+      getNullifier_asB64(): string;
+      setNullifier(value: Uint8Array | string): void;
+
+      getIsSpent(): boolean;
+      setIsSpent(value: boolean): void;
+
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): NullifierStatus.AsObject;
+      static toObject(includeInstance: boolean, msg: NullifierStatus): NullifierStatus.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: NullifierStatus, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): NullifierStatus;
+      static deserializeBinaryFromReader(message: NullifierStatus, reader: jspb.BinaryReader): NullifierStatus;
+    }
+
+    export namespace NullifierStatus {
+      export type AsObject = {
+        nullifier: Uint8Array | string,
+        isSpent: boolean,
+      }
+    }
+
+    export class NullifierStatuses extends jspb.Message {
+      clearEntriesList(): void;
+      getEntriesList(): Array<GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatus>;
+      setEntriesList(value: Array<GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatus>): void;
+      addEntries(value?: GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatus, index?: number): GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatus;
+
+      serializeBinary(): Uint8Array;
+      toObject(includeInstance?: boolean): NullifierStatuses.AsObject;
+      static toObject(includeInstance: boolean, msg: NullifierStatuses): NullifierStatuses.AsObject;
+      static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+      static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+      static serializeBinaryToWriter(message: NullifierStatuses, writer: jspb.BinaryWriter): void;
+      static deserializeBinary(bytes: Uint8Array): NullifierStatuses;
+      static deserializeBinaryFromReader(message: NullifierStatuses, reader: jspb.BinaryReader): NullifierStatuses;
+    }
+
+    export namespace NullifierStatuses {
+      export type AsObject = {
+        entriesList: Array<GetShieldedNullifiersResponse.GetShieldedNullifiersResponseV0.NullifierStatus.AsObject>,
+      }
+    }
+
     export enum ResultCase {
       RESULT_NOT_SET = 0,
-      ADDRESS_INFO_ENTRIES = 1,
+      NULLIFIER_STATUSES = 1,
       PROOF = 2,
     }
   }
@@ -9913,41 +12110,51 @@ export namespace GetAddressesInfosResponse {
   }
 }
 
-export class GetAddressesTrunkStateRequest extends jspb.Message {
+export class GetNullifiersTrunkStateRequest extends jspb.Message {
   hasV0(): boolean;
   clearV0(): void;
-  getV0(): GetAddressesTrunkStateRequest.GetAddressesTrunkStateRequestV0 | undefined;
-  setV0(value?: GetAddressesTrunkStateRequest.GetAddressesTrunkStateRequestV0): void;
+  getV0(): GetNullifiersTrunkStateRequest.GetNullifiersTrunkStateRequestV0 | undefined;
+  setV0(value?: GetNullifiersTrunkStateRequest.GetNullifiersTrunkStateRequestV0): void;
 
-  getVersionCase(): GetAddressesTrunkStateRequest.VersionCase;
+  getVersionCase(): GetNullifiersTrunkStateRequest.VersionCase;
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): GetAddressesTrunkStateRequest.AsObject;
-  static toObject(includeInstance: boolean, msg: GetAddressesTrunkStateRequest): GetAddressesTrunkStateRequest.AsObject;
+  toObject(includeInstance?: boolean): GetNullifiersTrunkStateRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetNullifiersTrunkStateRequest): GetNullifiersTrunkStateRequest.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: GetAddressesTrunkStateRequest, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): GetAddressesTrunkStateRequest;
-  static deserializeBinaryFromReader(message: GetAddressesTrunkStateRequest, reader: jspb.BinaryReader): GetAddressesTrunkStateRequest;
+  static serializeBinaryToWriter(message: GetNullifiersTrunkStateRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetNullifiersTrunkStateRequest;
+  static deserializeBinaryFromReader(message: GetNullifiersTrunkStateRequest, reader: jspb.BinaryReader): GetNullifiersTrunkStateRequest;
 }
 
-export namespace GetAddressesTrunkStateRequest {
+export namespace GetNullifiersTrunkStateRequest {
   export type AsObject = {
-    v0?: GetAddressesTrunkStateRequest.GetAddressesTrunkStateRequestV0.AsObject,
+    v0?: GetNullifiersTrunkStateRequest.GetNullifiersTrunkStateRequestV0.AsObject,
   }
 
-  export class GetAddressesTrunkStateRequestV0 extends jspb.Message {
+  export class GetNullifiersTrunkStateRequestV0 extends jspb.Message {
+    getPoolType(): number;
+    setPoolType(value: number): void;
+
+    getPoolIdentifier(): Uint8Array | string;
+    getPoolIdentifier_asU8(): Uint8Array;
+    getPoolIdentifier_asB64(): string;
+    setPoolIdentifier(value: Uint8Array | string): void;
+
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): GetAddressesTrunkStateRequestV0.AsObject;
-    static toObject(includeInstance: boolean, msg: GetAddressesTrunkStateRequestV0): GetAddressesTrunkStateRequestV0.AsObject;
+    toObject(includeInstance?: boolean): GetNullifiersTrunkStateRequestV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetNullifiersTrunkStateRequestV0): GetNullifiersTrunkStateRequestV0.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: GetAddressesTrunkStateRequestV0, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): GetAddressesTrunkStateRequestV0;
-    static deserializeBinaryFromReader(message: GetAddressesTrunkStateRequestV0, reader: jspb.BinaryReader): GetAddressesTrunkStateRequestV0;
+    static serializeBinaryToWriter(message: GetNullifiersTrunkStateRequestV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetNullifiersTrunkStateRequestV0;
+    static deserializeBinaryFromReader(message: GetNullifiersTrunkStateRequestV0, reader: jspb.BinaryReader): GetNullifiersTrunkStateRequestV0;
   }
 
-  export namespace GetAddressesTrunkStateRequestV0 {
+  export namespace GetNullifiersTrunkStateRequestV0 {
     export type AsObject = {
+      poolType: number,
+      poolIdentifier: Uint8Array | string,
     }
   }
 
@@ -9957,29 +12164,29 @@ export namespace GetAddressesTrunkStateRequest {
   }
 }
 
-export class GetAddressesTrunkStateResponse extends jspb.Message {
+export class GetNullifiersTrunkStateResponse extends jspb.Message {
   hasV0(): boolean;
   clearV0(): void;
-  getV0(): GetAddressesTrunkStateResponse.GetAddressesTrunkStateResponseV0 | undefined;
-  setV0(value?: GetAddressesTrunkStateResponse.GetAddressesTrunkStateResponseV0): void;
+  getV0(): GetNullifiersTrunkStateResponse.GetNullifiersTrunkStateResponseV0 | undefined;
+  setV0(value?: GetNullifiersTrunkStateResponse.GetNullifiersTrunkStateResponseV0): void;
 
-  getVersionCase(): GetAddressesTrunkStateResponse.VersionCase;
+  getVersionCase(): GetNullifiersTrunkStateResponse.VersionCase;
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): GetAddressesTrunkStateResponse.AsObject;
-  static toObject(includeInstance: boolean, msg: GetAddressesTrunkStateResponse): GetAddressesTrunkStateResponse.AsObject;
+  toObject(includeInstance?: boolean): GetNullifiersTrunkStateResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetNullifiersTrunkStateResponse): GetNullifiersTrunkStateResponse.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: GetAddressesTrunkStateResponse, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): GetAddressesTrunkStateResponse;
-  static deserializeBinaryFromReader(message: GetAddressesTrunkStateResponse, reader: jspb.BinaryReader): GetAddressesTrunkStateResponse;
+  static serializeBinaryToWriter(message: GetNullifiersTrunkStateResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetNullifiersTrunkStateResponse;
+  static deserializeBinaryFromReader(message: GetNullifiersTrunkStateResponse, reader: jspb.BinaryReader): GetNullifiersTrunkStateResponse;
 }
 
-export namespace GetAddressesTrunkStateResponse {
+export namespace GetNullifiersTrunkStateResponse {
   export type AsObject = {
-    v0?: GetAddressesTrunkStateResponse.GetAddressesTrunkStateResponseV0.AsObject,
+    v0?: GetNullifiersTrunkStateResponse.GetNullifiersTrunkStateResponseV0.AsObject,
   }
 
-  export class GetAddressesTrunkStateResponseV0 extends jspb.Message {
+  export class GetNullifiersTrunkStateResponseV0 extends jspb.Message {
     hasProof(): boolean;
     clearProof(): void;
     getProof(): Proof | undefined;
@@ -9991,16 +12198,16 @@ export namespace GetAddressesTrunkStateResponse {
     setMetadata(value?: ResponseMetadata): void;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): GetAddressesTrunkStateResponseV0.AsObject;
-    static toObject(includeInstance: boolean, msg: GetAddressesTrunkStateResponseV0): GetAddressesTrunkStateResponseV0.AsObject;
+    toObject(includeInstance?: boolean): GetNullifiersTrunkStateResponseV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetNullifiersTrunkStateResponseV0): GetNullifiersTrunkStateResponseV0.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: GetAddressesTrunkStateResponseV0, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): GetAddressesTrunkStateResponseV0;
-    static deserializeBinaryFromReader(message: GetAddressesTrunkStateResponseV0, reader: jspb.BinaryReader): GetAddressesTrunkStateResponseV0;
+    static serializeBinaryToWriter(message: GetNullifiersTrunkStateResponseV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetNullifiersTrunkStateResponseV0;
+    static deserializeBinaryFromReader(message: GetNullifiersTrunkStateResponseV0, reader: jspb.BinaryReader): GetNullifiersTrunkStateResponseV0;
   }
 
-  export namespace GetAddressesTrunkStateResponseV0 {
+  export namespace GetNullifiersTrunkStateResponseV0 {
     export type AsObject = {
       proof?: Proof.AsObject,
       metadata?: ResponseMetadata.AsObject,
@@ -10013,29 +12220,37 @@ export namespace GetAddressesTrunkStateResponse {
   }
 }
 
-export class GetAddressesBranchStateRequest extends jspb.Message {
+export class GetNullifiersBranchStateRequest extends jspb.Message {
   hasV0(): boolean;
   clearV0(): void;
-  getV0(): GetAddressesBranchStateRequest.GetAddressesBranchStateRequestV0 | undefined;
-  setV0(value?: GetAddressesBranchStateRequest.GetAddressesBranchStateRequestV0): void;
+  getV0(): GetNullifiersBranchStateRequest.GetNullifiersBranchStateRequestV0 | undefined;
+  setV0(value?: GetNullifiersBranchStateRequest.GetNullifiersBranchStateRequestV0): void;
 
-  getVersionCase(): GetAddressesBranchStateRequest.VersionCase;
+  getVersionCase(): GetNullifiersBranchStateRequest.VersionCase;
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): GetAddressesBranchStateRequest.AsObject;
-  static toObject(includeInstance: boolean, msg: GetAddressesBranchStateRequest): GetAddressesBranchStateRequest.AsObject;
+  toObject(includeInstance?: boolean): GetNullifiersBranchStateRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetNullifiersBranchStateRequest): GetNullifiersBranchStateRequest.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: GetAddressesBranchStateRequest, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): GetAddressesBranchStateRequest;
-  static deserializeBinaryFromReader(message: GetAddressesBranchStateRequest, reader: jspb.BinaryReader): GetAddressesBranchStateRequest;
+  static serializeBinaryToWriter(message: GetNullifiersBranchStateRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetNullifiersBranchStateRequest;
+  static deserializeBinaryFromReader(message: GetNullifiersBranchStateRequest, reader: jspb.BinaryReader): GetNullifiersBranchStateRequest;
 }
 
-export namespace GetAddressesBranchStateRequest {
+export namespace GetNullifiersBranchStateRequest {
   export type AsObject = {
-    v0?: GetAddressesBranchStateRequest.GetAddressesBranchStateRequestV0.AsObject,
+    v0?: GetNullifiersBranchStateRequest.GetNullifiersBranchStateRequestV0.AsObject,
   }
 
-  export class GetAddressesBranchStateRequestV0 extends jspb.Message {
+  export class GetNullifiersBranchStateRequestV0 extends jspb.Message {
+    getPoolType(): number;
+    setPoolType(value: number): void;
+
+    getPoolIdentifier(): Uint8Array | string;
+    getPoolIdentifier_asU8(): Uint8Array;
+    getPoolIdentifier_asB64(): string;
+    setPoolIdentifier(value: Uint8Array | string): void;
+
     getKey(): Uint8Array | string;
     getKey_asU8(): Uint8Array;
     getKey_asB64(): string;
@@ -10048,17 +12263,19 @@ export namespace GetAddressesBranchStateRequest {
     setCheckpointHeight(value: number): void;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): GetAddressesBranchStateRequestV0.AsObject;
-    static toObject(includeInstance: boolean, msg: GetAddressesBranchStateRequestV0): GetAddressesBranchStateRequestV0.AsObject;
+    toObject(includeInstance?: boolean): GetNullifiersBranchStateRequestV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetNullifiersBranchStateRequestV0): GetNullifiersBranchStateRequestV0.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: GetAddressesBranchStateRequestV0, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): GetAddressesBranchStateRequestV0;
-    static deserializeBinaryFromReader(message: GetAddressesBranchStateRequestV0, reader: jspb.BinaryReader): GetAddressesBranchStateRequestV0;
+    static serializeBinaryToWriter(message: GetNullifiersBranchStateRequestV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetNullifiersBranchStateRequestV0;
+    static deserializeBinaryFromReader(message: GetNullifiersBranchStateRequestV0, reader: jspb.BinaryReader): GetNullifiersBranchStateRequestV0;
   }
 
-  export namespace GetAddressesBranchStateRequestV0 {
+  export namespace GetNullifiersBranchStateRequestV0 {
     export type AsObject = {
+      poolType: number,
+      poolIdentifier: Uint8Array | string,
       key: Uint8Array | string,
       depth: number,
       checkpointHeight: number,
@@ -10071,45 +12288,45 @@ export namespace GetAddressesBranchStateRequest {
   }
 }
 
-export class GetAddressesBranchStateResponse extends jspb.Message {
+export class GetNullifiersBranchStateResponse extends jspb.Message {
   hasV0(): boolean;
   clearV0(): void;
-  getV0(): GetAddressesBranchStateResponse.GetAddressesBranchStateResponseV0 | undefined;
-  setV0(value?: GetAddressesBranchStateResponse.GetAddressesBranchStateResponseV0): void;
+  getV0(): GetNullifiersBranchStateResponse.GetNullifiersBranchStateResponseV0 | undefined;
+  setV0(value?: GetNullifiersBranchStateResponse.GetNullifiersBranchStateResponseV0): void;
 
-  getVersionCase(): GetAddressesBranchStateResponse.VersionCase;
+  getVersionCase(): GetNullifiersBranchStateResponse.VersionCase;
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): GetAddressesBranchStateResponse.AsObject;
-  static toObject(includeInstance: boolean, msg: GetAddressesBranchStateResponse): GetAddressesBranchStateResponse.AsObject;
+  toObject(includeInstance?: boolean): GetNullifiersBranchStateResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetNullifiersBranchStateResponse): GetNullifiersBranchStateResponse.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: GetAddressesBranchStateResponse, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): GetAddressesBranchStateResponse;
-  static deserializeBinaryFromReader(message: GetAddressesBranchStateResponse, reader: jspb.BinaryReader): GetAddressesBranchStateResponse;
+  static serializeBinaryToWriter(message: GetNullifiersBranchStateResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetNullifiersBranchStateResponse;
+  static deserializeBinaryFromReader(message: GetNullifiersBranchStateResponse, reader: jspb.BinaryReader): GetNullifiersBranchStateResponse;
 }
 
-export namespace GetAddressesBranchStateResponse {
+export namespace GetNullifiersBranchStateResponse {
   export type AsObject = {
-    v0?: GetAddressesBranchStateResponse.GetAddressesBranchStateResponseV0.AsObject,
+    v0?: GetNullifiersBranchStateResponse.GetNullifiersBranchStateResponseV0.AsObject,
   }
 
-  export class GetAddressesBranchStateResponseV0 extends jspb.Message {
+  export class GetNullifiersBranchStateResponseV0 extends jspb.Message {
     getMerkProof(): Uint8Array | string;
     getMerkProof_asU8(): Uint8Array;
     getMerkProof_asB64(): string;
     setMerkProof(value: Uint8Array | string): void;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): GetAddressesBranchStateResponseV0.AsObject;
-    static toObject(includeInstance: boolean, msg: GetAddressesBranchStateResponseV0): GetAddressesBranchStateResponseV0.AsObject;
+    toObject(includeInstance?: boolean): GetNullifiersBranchStateResponseV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetNullifiersBranchStateResponseV0): GetNullifiersBranchStateResponseV0.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: GetAddressesBranchStateResponseV0, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): GetAddressesBranchStateResponseV0;
-    static deserializeBinaryFromReader(message: GetAddressesBranchStateResponseV0, reader: jspb.BinaryReader): GetAddressesBranchStateResponseV0;
+    static serializeBinaryToWriter(message: GetNullifiersBranchStateResponseV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetNullifiersBranchStateResponseV0;
+    static deserializeBinaryFromReader(message: GetNullifiersBranchStateResponseV0, reader: jspb.BinaryReader): GetNullifiersBranchStateResponseV0;
   }
 
-  export namespace GetAddressesBranchStateResponseV0 {
+  export namespace GetNullifiersBranchStateResponseV0 {
     export type AsObject = {
       merkProof: Uint8Array | string,
     }
@@ -10121,29 +12338,79 @@ export namespace GetAddressesBranchStateResponse {
   }
 }
 
-export class GetRecentAddressBalanceChangesRequest extends jspb.Message {
+export class BlockNullifierChanges extends jspb.Message {
+  getBlockHeight(): string;
+  setBlockHeight(value: string): void;
+
+  clearNullifiersList(): void;
+  getNullifiersList(): Array<Uint8Array | string>;
+  getNullifiersList_asU8(): Array<Uint8Array>;
+  getNullifiersList_asB64(): Array<string>;
+  setNullifiersList(value: Array<Uint8Array | string>): void;
+  addNullifiers(value: Uint8Array | string, index?: number): Uint8Array | string;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): BlockNullifierChanges.AsObject;
+  static toObject(includeInstance: boolean, msg: BlockNullifierChanges): BlockNullifierChanges.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: BlockNullifierChanges, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): BlockNullifierChanges;
+  static deserializeBinaryFromReader(message: BlockNullifierChanges, reader: jspb.BinaryReader): BlockNullifierChanges;
+}
+
+export namespace BlockNullifierChanges {
+  export type AsObject = {
+    blockHeight: string,
+    nullifiersList: Array<Uint8Array | string>,
+  }
+}
+
+export class NullifierUpdateEntries extends jspb.Message {
+  clearBlockChangesList(): void;
+  getBlockChangesList(): Array<BlockNullifierChanges>;
+  setBlockChangesList(value: Array<BlockNullifierChanges>): void;
+  addBlockChanges(value?: BlockNullifierChanges, index?: number): BlockNullifierChanges;
+
+  serializeBinary(): Uint8Array;
+  toObject(includeInstance?: boolean): NullifierUpdateEntries.AsObject;
+  static toObject(includeInstance: boolean, msg: NullifierUpdateEntries): NullifierUpdateEntries.AsObject;
+  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
+  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
+  static serializeBinaryToWriter(message: NullifierUpdateEntries, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): NullifierUpdateEntries;
+  static deserializeBinaryFromReader(message: NullifierUpdateEntries, reader: jspb.BinaryReader): NullifierUpdateEntries;
+}
+
+export namespace NullifierUpdateEntries {
+  export type AsObject = {
+    blockChangesList: Array<BlockNullifierChanges.AsObject>,
+  }
+}
+
+export class GetRecentNullifierChangesRequest extends jspb.Message {
   hasV0(): boolean;
   clearV0(): void;
-  getV0(): GetRecentAddressBalanceChangesRequest.GetRecentAddressBalanceChangesRequestV0 | undefined;
-  setV0(value?: GetRecentAddressBalanceChangesRequest.GetRecentAddressBalanceChangesRequestV0): void;
+  getV0(): GetRecentNullifierChangesRequest.GetRecentNullifierChangesRequestV0 | undefined;
+  setV0(value?: GetRecentNullifierChangesRequest.GetRecentNullifierChangesRequestV0): void;
 
-  getVersionCase(): GetRecentAddressBalanceChangesRequest.VersionCase;
+  getVersionCase(): GetRecentNullifierChangesRequest.VersionCase;
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): GetRecentAddressBalanceChangesRequest.AsObject;
-  static toObject(includeInstance: boolean, msg: GetRecentAddressBalanceChangesRequest): GetRecentAddressBalanceChangesRequest.AsObject;
+  toObject(includeInstance?: boolean): GetRecentNullifierChangesRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetRecentNullifierChangesRequest): GetRecentNullifierChangesRequest.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: GetRecentAddressBalanceChangesRequest, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): GetRecentAddressBalanceChangesRequest;
-  static deserializeBinaryFromReader(message: GetRecentAddressBalanceChangesRequest, reader: jspb.BinaryReader): GetRecentAddressBalanceChangesRequest;
+  static serializeBinaryToWriter(message: GetRecentNullifierChangesRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetRecentNullifierChangesRequest;
+  static deserializeBinaryFromReader(message: GetRecentNullifierChangesRequest, reader: jspb.BinaryReader): GetRecentNullifierChangesRequest;
 }
 
-export namespace GetRecentAddressBalanceChangesRequest {
+export namespace GetRecentNullifierChangesRequest {
   export type AsObject = {
-    v0?: GetRecentAddressBalanceChangesRequest.GetRecentAddressBalanceChangesRequestV0.AsObject,
+    v0?: GetRecentNullifierChangesRequest.GetRecentNullifierChangesRequestV0.AsObject,
   }
 
-  export class GetRecentAddressBalanceChangesRequestV0 extends jspb.Message {
+  export class GetRecentNullifierChangesRequestV0 extends jspb.Message {
     getStartHeight(): string;
     setStartHeight(value: string): void;
 
@@ -10151,16 +12418,16 @@ export namespace GetRecentAddressBalanceChangesRequest {
     setProve(value: boolean): void;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): GetRecentAddressBalanceChangesRequestV0.AsObject;
-    static toObject(includeInstance: boolean, msg: GetRecentAddressBalanceChangesRequestV0): GetRecentAddressBalanceChangesRequestV0.AsObject;
+    toObject(includeInstance?: boolean): GetRecentNullifierChangesRequestV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetRecentNullifierChangesRequestV0): GetRecentNullifierChangesRequestV0.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: GetRecentAddressBalanceChangesRequestV0, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): GetRecentAddressBalanceChangesRequestV0;
-    static deserializeBinaryFromReader(message: GetRecentAddressBalanceChangesRequestV0, reader: jspb.BinaryReader): GetRecentAddressBalanceChangesRequestV0;
+    static serializeBinaryToWriter(message: GetRecentNullifierChangesRequestV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetRecentNullifierChangesRequestV0;
+    static deserializeBinaryFromReader(message: GetRecentNullifierChangesRequestV0, reader: jspb.BinaryReader): GetRecentNullifierChangesRequestV0;
   }
 
-  export namespace GetRecentAddressBalanceChangesRequestV0 {
+  export namespace GetRecentNullifierChangesRequestV0 {
     export type AsObject = {
       startHeight: string,
       prove: boolean,
@@ -10173,33 +12440,33 @@ export namespace GetRecentAddressBalanceChangesRequest {
   }
 }
 
-export class GetRecentAddressBalanceChangesResponse extends jspb.Message {
+export class GetRecentNullifierChangesResponse extends jspb.Message {
   hasV0(): boolean;
   clearV0(): void;
-  getV0(): GetRecentAddressBalanceChangesResponse.GetRecentAddressBalanceChangesResponseV0 | undefined;
-  setV0(value?: GetRecentAddressBalanceChangesResponse.GetRecentAddressBalanceChangesResponseV0): void;
+  getV0(): GetRecentNullifierChangesResponse.GetRecentNullifierChangesResponseV0 | undefined;
+  setV0(value?: GetRecentNullifierChangesResponse.GetRecentNullifierChangesResponseV0): void;
 
-  getVersionCase(): GetRecentAddressBalanceChangesResponse.VersionCase;
+  getVersionCase(): GetRecentNullifierChangesResponse.VersionCase;
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): GetRecentAddressBalanceChangesResponse.AsObject;
-  static toObject(includeInstance: boolean, msg: GetRecentAddressBalanceChangesResponse): GetRecentAddressBalanceChangesResponse.AsObject;
+  toObject(includeInstance?: boolean): GetRecentNullifierChangesResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetRecentNullifierChangesResponse): GetRecentNullifierChangesResponse.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: GetRecentAddressBalanceChangesResponse, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): GetRecentAddressBalanceChangesResponse;
-  static deserializeBinaryFromReader(message: GetRecentAddressBalanceChangesResponse, reader: jspb.BinaryReader): GetRecentAddressBalanceChangesResponse;
+  static serializeBinaryToWriter(message: GetRecentNullifierChangesResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetRecentNullifierChangesResponse;
+  static deserializeBinaryFromReader(message: GetRecentNullifierChangesResponse, reader: jspb.BinaryReader): GetRecentNullifierChangesResponse;
 }
 
-export namespace GetRecentAddressBalanceChangesResponse {
+export namespace GetRecentNullifierChangesResponse {
   export type AsObject = {
-    v0?: GetRecentAddressBalanceChangesResponse.GetRecentAddressBalanceChangesResponseV0.AsObject,
+    v0?: GetRecentNullifierChangesResponse.GetRecentNullifierChangesResponseV0.AsObject,
   }
 
-  export class GetRecentAddressBalanceChangesResponseV0 extends jspb.Message {
-    hasAddressBalanceUpdateEntries(): boolean;
-    clearAddressBalanceUpdateEntries(): void;
-    getAddressBalanceUpdateEntries(): AddressBalanceUpdateEntries | undefined;
-    setAddressBalanceUpdateEntries(value?: AddressBalanceUpdateEntries): void;
+  export class GetRecentNullifierChangesResponseV0 extends jspb.Message {
+    hasNullifierUpdateEntries(): boolean;
+    clearNullifierUpdateEntries(): void;
+    getNullifierUpdateEntries(): NullifierUpdateEntries | undefined;
+    setNullifierUpdateEntries(value?: NullifierUpdateEntries): void;
 
     hasProof(): boolean;
     clearProof(): void;
@@ -10211,27 +12478,27 @@ export namespace GetRecentAddressBalanceChangesResponse {
     getMetadata(): ResponseMetadata | undefined;
     setMetadata(value?: ResponseMetadata): void;
 
-    getResultCase(): GetRecentAddressBalanceChangesResponseV0.ResultCase;
+    getResultCase(): GetRecentNullifierChangesResponseV0.ResultCase;
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): GetRecentAddressBalanceChangesResponseV0.AsObject;
-    static toObject(includeInstance: boolean, msg: GetRecentAddressBalanceChangesResponseV0): GetRecentAddressBalanceChangesResponseV0.AsObject;
+    toObject(includeInstance?: boolean): GetRecentNullifierChangesResponseV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetRecentNullifierChangesResponseV0): GetRecentNullifierChangesResponseV0.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: GetRecentAddressBalanceChangesResponseV0, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): GetRecentAddressBalanceChangesResponseV0;
-    static deserializeBinaryFromReader(message: GetRecentAddressBalanceChangesResponseV0, reader: jspb.BinaryReader): GetRecentAddressBalanceChangesResponseV0;
+    static serializeBinaryToWriter(message: GetRecentNullifierChangesResponseV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetRecentNullifierChangesResponseV0;
+    static deserializeBinaryFromReader(message: GetRecentNullifierChangesResponseV0, reader: jspb.BinaryReader): GetRecentNullifierChangesResponseV0;
   }
 
-  export namespace GetRecentAddressBalanceChangesResponseV0 {
+  export namespace GetRecentNullifierChangesResponseV0 {
     export type AsObject = {
-      addressBalanceUpdateEntries?: AddressBalanceUpdateEntries.AsObject,
+      nullifierUpdateEntries?: NullifierUpdateEntries.AsObject,
       proof?: Proof.AsObject,
       metadata?: ResponseMetadata.AsObject,
     }
 
     export enum ResultCase {
       RESULT_NOT_SET = 0,
-      ADDRESS_BALANCE_UPDATE_ENTRIES = 1,
+      NULLIFIER_UPDATE_ENTRIES = 1,
       PROOF = 2,
     }
   }
@@ -10242,168 +12509,83 @@ export namespace GetRecentAddressBalanceChangesResponse {
   }
 }
 
-export class BlockHeightCreditEntry extends jspb.Message {
-  getBlockHeight(): string;
-  setBlockHeight(value: string): void;
-
-  getCredits(): string;
-  setCredits(value: string): void;
-
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): BlockHeightCreditEntry.AsObject;
-  static toObject(includeInstance: boolean, msg: BlockHeightCreditEntry): BlockHeightCreditEntry.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: BlockHeightCreditEntry, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): BlockHeightCreditEntry;
-  static deserializeBinaryFromReader(message: BlockHeightCreditEntry, reader: jspb.BinaryReader): BlockHeightCreditEntry;
-}
-
-export namespace BlockHeightCreditEntry {
-  export type AsObject = {
-    blockHeight: string,
-    credits: string,
-  }
-}
-
-export class CompactedAddressBalanceChange extends jspb.Message {
-  getAddress(): Uint8Array | string;
-  getAddress_asU8(): Uint8Array;
-  getAddress_asB64(): string;
-  setAddress(value: Uint8Array | string): void;
-
-  hasSetCredits(): boolean;
-  clearSetCredits(): void;
-  getSetCredits(): string;
-  setSetCredits(value: string): void;
-
-  hasAddToCreditsOperations(): boolean;
-  clearAddToCreditsOperations(): void;
-  getAddToCreditsOperations(): AddToCreditsOperations | undefined;
-  setAddToCreditsOperations(value?: AddToCreditsOperations): void;
-
-  getOperationCase(): CompactedAddressBalanceChange.OperationCase;
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): CompactedAddressBalanceChange.AsObject;
-  static toObject(includeInstance: boolean, msg: CompactedAddressBalanceChange): CompactedAddressBalanceChange.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: CompactedAddressBalanceChange, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): CompactedAddressBalanceChange;
-  static deserializeBinaryFromReader(message: CompactedAddressBalanceChange, reader: jspb.BinaryReader): CompactedAddressBalanceChange;
-}
-
-export namespace CompactedAddressBalanceChange {
-  export type AsObject = {
-    address: Uint8Array | string,
-    setCredits: string,
-    addToCreditsOperations?: AddToCreditsOperations.AsObject,
-  }
-
-  export enum OperationCase {
-    OPERATION_NOT_SET = 0,
-    SET_CREDITS = 2,
-    ADD_TO_CREDITS_OPERATIONS = 3,
-  }
-}
-
-export class AddToCreditsOperations extends jspb.Message {
-  clearEntriesList(): void;
-  getEntriesList(): Array<BlockHeightCreditEntry>;
-  setEntriesList(value: Array<BlockHeightCreditEntry>): void;
-  addEntries(value?: BlockHeightCreditEntry, index?: number): BlockHeightCreditEntry;
-
-  serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): AddToCreditsOperations.AsObject;
-  static toObject(includeInstance: boolean, msg: AddToCreditsOperations): AddToCreditsOperations.AsObject;
-  static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
-  static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: AddToCreditsOperations, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): AddToCreditsOperations;
-  static deserializeBinaryFromReader(message: AddToCreditsOperations, reader: jspb.BinaryReader): AddToCreditsOperations;
-}
-
-export namespace AddToCreditsOperations {
-  export type AsObject = {
-    entriesList: Array<BlockHeightCreditEntry.AsObject>,
-  }
-}
-
-export class CompactedBlockAddressBalanceChanges extends jspb.Message {
+export class CompactedBlockNullifierChanges extends jspb.Message {
   getStartBlockHeight(): string;
   setStartBlockHeight(value: string): void;
 
   getEndBlockHeight(): string;
   setEndBlockHeight(value: string): void;
 
-  clearChangesList(): void;
-  getChangesList(): Array<CompactedAddressBalanceChange>;
-  setChangesList(value: Array<CompactedAddressBalanceChange>): void;
-  addChanges(value?: CompactedAddressBalanceChange, index?: number): CompactedAddressBalanceChange;
+  clearNullifiersList(): void;
+  getNullifiersList(): Array<Uint8Array | string>;
+  getNullifiersList_asU8(): Array<Uint8Array>;
+  getNullifiersList_asB64(): Array<string>;
+  setNullifiersList(value: Array<Uint8Array | string>): void;
+  addNullifiers(value: Uint8Array | string, index?: number): Uint8Array | string;
 
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): CompactedBlockAddressBalanceChanges.AsObject;
-  static toObject(includeInstance: boolean, msg: CompactedBlockAddressBalanceChanges): CompactedBlockAddressBalanceChanges.AsObject;
+  toObject(includeInstance?: boolean): CompactedBlockNullifierChanges.AsObject;
+  static toObject(includeInstance: boolean, msg: CompactedBlockNullifierChanges): CompactedBlockNullifierChanges.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: CompactedBlockAddressBalanceChanges, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): CompactedBlockAddressBalanceChanges;
-  static deserializeBinaryFromReader(message: CompactedBlockAddressBalanceChanges, reader: jspb.BinaryReader): CompactedBlockAddressBalanceChanges;
+  static serializeBinaryToWriter(message: CompactedBlockNullifierChanges, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CompactedBlockNullifierChanges;
+  static deserializeBinaryFromReader(message: CompactedBlockNullifierChanges, reader: jspb.BinaryReader): CompactedBlockNullifierChanges;
 }
 
-export namespace CompactedBlockAddressBalanceChanges {
+export namespace CompactedBlockNullifierChanges {
   export type AsObject = {
     startBlockHeight: string,
     endBlockHeight: string,
-    changesList: Array<CompactedAddressBalanceChange.AsObject>,
+    nullifiersList: Array<Uint8Array | string>,
   }
 }
 
-export class CompactedAddressBalanceUpdateEntries extends jspb.Message {
+export class CompactedNullifierUpdateEntries extends jspb.Message {
   clearCompactedBlockChangesList(): void;
-  getCompactedBlockChangesList(): Array<CompactedBlockAddressBalanceChanges>;
-  setCompactedBlockChangesList(value: Array<CompactedBlockAddressBalanceChanges>): void;
-  addCompactedBlockChanges(value?: CompactedBlockAddressBalanceChanges, index?: number): CompactedBlockAddressBalanceChanges;
+  getCompactedBlockChangesList(): Array<CompactedBlockNullifierChanges>;
+  setCompactedBlockChangesList(value: Array<CompactedBlockNullifierChanges>): void;
+  addCompactedBlockChanges(value?: CompactedBlockNullifierChanges, index?: number): CompactedBlockNullifierChanges;
 
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): CompactedAddressBalanceUpdateEntries.AsObject;
-  static toObject(includeInstance: boolean, msg: CompactedAddressBalanceUpdateEntries): CompactedAddressBalanceUpdateEntries.AsObject;
+  toObject(includeInstance?: boolean): CompactedNullifierUpdateEntries.AsObject;
+  static toObject(includeInstance: boolean, msg: CompactedNullifierUpdateEntries): CompactedNullifierUpdateEntries.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: CompactedAddressBalanceUpdateEntries, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): CompactedAddressBalanceUpdateEntries;
-  static deserializeBinaryFromReader(message: CompactedAddressBalanceUpdateEntries, reader: jspb.BinaryReader): CompactedAddressBalanceUpdateEntries;
+  static serializeBinaryToWriter(message: CompactedNullifierUpdateEntries, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): CompactedNullifierUpdateEntries;
+  static deserializeBinaryFromReader(message: CompactedNullifierUpdateEntries, reader: jspb.BinaryReader): CompactedNullifierUpdateEntries;
 }
 
-export namespace CompactedAddressBalanceUpdateEntries {
+export namespace CompactedNullifierUpdateEntries {
   export type AsObject = {
-    compactedBlockChangesList: Array<CompactedBlockAddressBalanceChanges.AsObject>,
+    compactedBlockChangesList: Array<CompactedBlockNullifierChanges.AsObject>,
   }
 }
 
-export class GetRecentCompactedAddressBalanceChangesRequest extends jspb.Message {
+export class GetRecentCompactedNullifierChangesRequest extends jspb.Message {
   hasV0(): boolean;
   clearV0(): void;
-  getV0(): GetRecentCompactedAddressBalanceChangesRequest.GetRecentCompactedAddressBalanceChangesRequestV0 | undefined;
-  setV0(value?: GetRecentCompactedAddressBalanceChangesRequest.GetRecentCompactedAddressBalanceChangesRequestV0): void;
+  getV0(): GetRecentCompactedNullifierChangesRequest.GetRecentCompactedNullifierChangesRequestV0 | undefined;
+  setV0(value?: GetRecentCompactedNullifierChangesRequest.GetRecentCompactedNullifierChangesRequestV0): void;
 
-  getVersionCase(): GetRecentCompactedAddressBalanceChangesRequest.VersionCase;
+  getVersionCase(): GetRecentCompactedNullifierChangesRequest.VersionCase;
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): GetRecentCompactedAddressBalanceChangesRequest.AsObject;
-  static toObject(includeInstance: boolean, msg: GetRecentCompactedAddressBalanceChangesRequest): GetRecentCompactedAddressBalanceChangesRequest.AsObject;
+  toObject(includeInstance?: boolean): GetRecentCompactedNullifierChangesRequest.AsObject;
+  static toObject(includeInstance: boolean, msg: GetRecentCompactedNullifierChangesRequest): GetRecentCompactedNullifierChangesRequest.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: GetRecentCompactedAddressBalanceChangesRequest, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): GetRecentCompactedAddressBalanceChangesRequest;
-  static deserializeBinaryFromReader(message: GetRecentCompactedAddressBalanceChangesRequest, reader: jspb.BinaryReader): GetRecentCompactedAddressBalanceChangesRequest;
+  static serializeBinaryToWriter(message: GetRecentCompactedNullifierChangesRequest, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetRecentCompactedNullifierChangesRequest;
+  static deserializeBinaryFromReader(message: GetRecentCompactedNullifierChangesRequest, reader: jspb.BinaryReader): GetRecentCompactedNullifierChangesRequest;
 }
 
-export namespace GetRecentCompactedAddressBalanceChangesRequest {
+export namespace GetRecentCompactedNullifierChangesRequest {
   export type AsObject = {
-    v0?: GetRecentCompactedAddressBalanceChangesRequest.GetRecentCompactedAddressBalanceChangesRequestV0.AsObject,
+    v0?: GetRecentCompactedNullifierChangesRequest.GetRecentCompactedNullifierChangesRequestV0.AsObject,
   }
 
-  export class GetRecentCompactedAddressBalanceChangesRequestV0 extends jspb.Message {
+  export class GetRecentCompactedNullifierChangesRequestV0 extends jspb.Message {
     getStartBlockHeight(): string;
     setStartBlockHeight(value: string): void;
 
@@ -10411,16 +12593,16 @@ export namespace GetRecentCompactedAddressBalanceChangesRequest {
     setProve(value: boolean): void;
 
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): GetRecentCompactedAddressBalanceChangesRequestV0.AsObject;
-    static toObject(includeInstance: boolean, msg: GetRecentCompactedAddressBalanceChangesRequestV0): GetRecentCompactedAddressBalanceChangesRequestV0.AsObject;
+    toObject(includeInstance?: boolean): GetRecentCompactedNullifierChangesRequestV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetRecentCompactedNullifierChangesRequestV0): GetRecentCompactedNullifierChangesRequestV0.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: GetRecentCompactedAddressBalanceChangesRequestV0, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): GetRecentCompactedAddressBalanceChangesRequestV0;
-    static deserializeBinaryFromReader(message: GetRecentCompactedAddressBalanceChangesRequestV0, reader: jspb.BinaryReader): GetRecentCompactedAddressBalanceChangesRequestV0;
+    static serializeBinaryToWriter(message: GetRecentCompactedNullifierChangesRequestV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetRecentCompactedNullifierChangesRequestV0;
+    static deserializeBinaryFromReader(message: GetRecentCompactedNullifierChangesRequestV0, reader: jspb.BinaryReader): GetRecentCompactedNullifierChangesRequestV0;
   }
 
-  export namespace GetRecentCompactedAddressBalanceChangesRequestV0 {
+  export namespace GetRecentCompactedNullifierChangesRequestV0 {
     export type AsObject = {
       startBlockHeight: string,
       prove: boolean,
@@ -10433,33 +12615,33 @@ export namespace GetRecentCompactedAddressBalanceChangesRequest {
   }
 }
 
-export class GetRecentCompactedAddressBalanceChangesResponse extends jspb.Message {
+export class GetRecentCompactedNullifierChangesResponse extends jspb.Message {
   hasV0(): boolean;
   clearV0(): void;
-  getV0(): GetRecentCompactedAddressBalanceChangesResponse.GetRecentCompactedAddressBalanceChangesResponseV0 | undefined;
-  setV0(value?: GetRecentCompactedAddressBalanceChangesResponse.GetRecentCompactedAddressBalanceChangesResponseV0): void;
+  getV0(): GetRecentCompactedNullifierChangesResponse.GetRecentCompactedNullifierChangesResponseV0 | undefined;
+  setV0(value?: GetRecentCompactedNullifierChangesResponse.GetRecentCompactedNullifierChangesResponseV0): void;
 
-  getVersionCase(): GetRecentCompactedAddressBalanceChangesResponse.VersionCase;
+  getVersionCase(): GetRecentCompactedNullifierChangesResponse.VersionCase;
   serializeBinary(): Uint8Array;
-  toObject(includeInstance?: boolean): GetRecentCompactedAddressBalanceChangesResponse.AsObject;
-  static toObject(includeInstance: boolean, msg: GetRecentCompactedAddressBalanceChangesResponse): GetRecentCompactedAddressBalanceChangesResponse.AsObject;
+  toObject(includeInstance?: boolean): GetRecentCompactedNullifierChangesResponse.AsObject;
+  static toObject(includeInstance: boolean, msg: GetRecentCompactedNullifierChangesResponse): GetRecentCompactedNullifierChangesResponse.AsObject;
   static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
   static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-  static serializeBinaryToWriter(message: GetRecentCompactedAddressBalanceChangesResponse, writer: jspb.BinaryWriter): void;
-  static deserializeBinary(bytes: Uint8Array): GetRecentCompactedAddressBalanceChangesResponse;
-  static deserializeBinaryFromReader(message: GetRecentCompactedAddressBalanceChangesResponse, reader: jspb.BinaryReader): GetRecentCompactedAddressBalanceChangesResponse;
+  static serializeBinaryToWriter(message: GetRecentCompactedNullifierChangesResponse, writer: jspb.BinaryWriter): void;
+  static deserializeBinary(bytes: Uint8Array): GetRecentCompactedNullifierChangesResponse;
+  static deserializeBinaryFromReader(message: GetRecentCompactedNullifierChangesResponse, reader: jspb.BinaryReader): GetRecentCompactedNullifierChangesResponse;
 }
 
-export namespace GetRecentCompactedAddressBalanceChangesResponse {
+export namespace GetRecentCompactedNullifierChangesResponse {
   export type AsObject = {
-    v0?: GetRecentCompactedAddressBalanceChangesResponse.GetRecentCompactedAddressBalanceChangesResponseV0.AsObject,
+    v0?: GetRecentCompactedNullifierChangesResponse.GetRecentCompactedNullifierChangesResponseV0.AsObject,
   }
 
-  export class GetRecentCompactedAddressBalanceChangesResponseV0 extends jspb.Message {
-    hasCompactedAddressBalanceUpdateEntries(): boolean;
-    clearCompactedAddressBalanceUpdateEntries(): void;
-    getCompactedAddressBalanceUpdateEntries(): CompactedAddressBalanceUpdateEntries | undefined;
-    setCompactedAddressBalanceUpdateEntries(value?: CompactedAddressBalanceUpdateEntries): void;
+  export class GetRecentCompactedNullifierChangesResponseV0 extends jspb.Message {
+    hasCompactedNullifierUpdateEntries(): boolean;
+    clearCompactedNullifierUpdateEntries(): void;
+    getCompactedNullifierUpdateEntries(): CompactedNullifierUpdateEntries | undefined;
+    setCompactedNullifierUpdateEntries(value?: CompactedNullifierUpdateEntries): void;
 
     hasProof(): boolean;
     clearProof(): void;
@@ -10471,27 +12653,27 @@ export namespace GetRecentCompactedAddressBalanceChangesResponse {
     getMetadata(): ResponseMetadata | undefined;
     setMetadata(value?: ResponseMetadata): void;
 
-    getResultCase(): GetRecentCompactedAddressBalanceChangesResponseV0.ResultCase;
+    getResultCase(): GetRecentCompactedNullifierChangesResponseV0.ResultCase;
     serializeBinary(): Uint8Array;
-    toObject(includeInstance?: boolean): GetRecentCompactedAddressBalanceChangesResponseV0.AsObject;
-    static toObject(includeInstance: boolean, msg: GetRecentCompactedAddressBalanceChangesResponseV0): GetRecentCompactedAddressBalanceChangesResponseV0.AsObject;
+    toObject(includeInstance?: boolean): GetRecentCompactedNullifierChangesResponseV0.AsObject;
+    static toObject(includeInstance: boolean, msg: GetRecentCompactedNullifierChangesResponseV0): GetRecentCompactedNullifierChangesResponseV0.AsObject;
     static extensions: {[key: number]: jspb.ExtensionFieldInfo<jspb.Message>};
     static extensionsBinary: {[key: number]: jspb.ExtensionFieldBinaryInfo<jspb.Message>};
-    static serializeBinaryToWriter(message: GetRecentCompactedAddressBalanceChangesResponseV0, writer: jspb.BinaryWriter): void;
-    static deserializeBinary(bytes: Uint8Array): GetRecentCompactedAddressBalanceChangesResponseV0;
-    static deserializeBinaryFromReader(message: GetRecentCompactedAddressBalanceChangesResponseV0, reader: jspb.BinaryReader): GetRecentCompactedAddressBalanceChangesResponseV0;
+    static serializeBinaryToWriter(message: GetRecentCompactedNullifierChangesResponseV0, writer: jspb.BinaryWriter): void;
+    static deserializeBinary(bytes: Uint8Array): GetRecentCompactedNullifierChangesResponseV0;
+    static deserializeBinaryFromReader(message: GetRecentCompactedNullifierChangesResponseV0, reader: jspb.BinaryReader): GetRecentCompactedNullifierChangesResponseV0;
   }
 
-  export namespace GetRecentCompactedAddressBalanceChangesResponseV0 {
+  export namespace GetRecentCompactedNullifierChangesResponseV0 {
     export type AsObject = {
-      compactedAddressBalanceUpdateEntries?: CompactedAddressBalanceUpdateEntries.AsObject,
+      compactedNullifierUpdateEntries?: CompactedNullifierUpdateEntries.AsObject,
       proof?: Proof.AsObject,
       metadata?: ResponseMetadata.AsObject,
     }
 
     export enum ResultCase {
       RESULT_NOT_SET = 0,
-      COMPACTED_ADDRESS_BALANCE_UPDATE_ENTRIES = 1,
+      COMPACTED_NULLIFIER_UPDATE_ENTRIES = 1,
       PROOF = 2,
     }
   }