@buildonspark/spark-sdk 0.1.44 → 0.1.46

package/src/proto/spark_token.ts

@@ -1,6 +1,6 @@
 // Code generated by protoc-gen-ts_proto. DO NOT EDIT.
 // versions:
-//   protoc-gen-ts_proto  v2.7.2
+//   protoc-gen-ts_proto  v2.7.5
 //   protoc               v5.29.3
 // source: spark_token.proto
 
@@ -12,6 +12,114 @@ import { Network, networkFromJSON, networkToJSON, SigningKeyshare } from "./spar
 
 export const protobufPackage = "spark_token";
 
+export enum TokenTransactionType {
+  TOKEN_TRANSACTION_TYPE_UNSPECIFIED = 0,
+  TOKEN_TRANSACTION_TYPE_CREATE = 1,
+  TOKEN_TRANSACTION_TYPE_MINT = 2,
+  TOKEN_TRANSACTION_TYPE_TRANSFER = 3,
+  UNRECOGNIZED = -1,
+}
+
+export function tokenTransactionTypeFromJSON(object: any): TokenTransactionType {
+  switch (object) {
+    case 0:
+    case "TOKEN_TRANSACTION_TYPE_UNSPECIFIED":
+      return TokenTransactionType.TOKEN_TRANSACTION_TYPE_UNSPECIFIED;
+    case 1:
+    case "TOKEN_TRANSACTION_TYPE_CREATE":
+      return TokenTransactionType.TOKEN_TRANSACTION_TYPE_CREATE;
+    case 2:
+    case "TOKEN_TRANSACTION_TYPE_MINT":
+      return TokenTransactionType.TOKEN_TRANSACTION_TYPE_MINT;
+    case 3:
+    case "TOKEN_TRANSACTION_TYPE_TRANSFER":
+      return TokenTransactionType.TOKEN_TRANSACTION_TYPE_TRANSFER;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return TokenTransactionType.UNRECOGNIZED;
+  }
+}
+
+export function tokenTransactionTypeToJSON(object: TokenTransactionType): string {
+  switch (object) {
+    case TokenTransactionType.TOKEN_TRANSACTION_TYPE_UNSPECIFIED:
+      return "TOKEN_TRANSACTION_TYPE_UNSPECIFIED";
+    case TokenTransactionType.TOKEN_TRANSACTION_TYPE_CREATE:
+      return "TOKEN_TRANSACTION_TYPE_CREATE";
+    case TokenTransactionType.TOKEN_TRANSACTION_TYPE_MINT:
+      return "TOKEN_TRANSACTION_TYPE_MINT";
+    case TokenTransactionType.TOKEN_TRANSACTION_TYPE_TRANSFER:
+      return "TOKEN_TRANSACTION_TYPE_TRANSFER";
+    case TokenTransactionType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export enum TokenTransactionStatus {
+  TOKEN_TRANSACTION_STARTED = 0,
+  TOKEN_TRANSACTION_SIGNED = 1,
+  TOKEN_TRANSACTION_REVEALED = 5,
+  TOKEN_TRANSACTION_FINALIZED = 2,
+  TOKEN_TRANSACTION_STARTED_CANCELLED = 3,
+  TOKEN_TRANSACTION_SIGNED_CANCELLED = 4,
+  TOKEN_TRANSACTION_UNKNOWN = 10,
+  UNRECOGNIZED = -1,
+}
+
+export function tokenTransactionStatusFromJSON(object: any): TokenTransactionStatus {
+  switch (object) {
+    case 0:
+    case "TOKEN_TRANSACTION_STARTED":
+      return TokenTransactionStatus.TOKEN_TRANSACTION_STARTED;
+    case 1:
+    case "TOKEN_TRANSACTION_SIGNED":
+      return TokenTransactionStatus.TOKEN_TRANSACTION_SIGNED;
+    case 5:
+    case "TOKEN_TRANSACTION_REVEALED":
+      return TokenTransactionStatus.TOKEN_TRANSACTION_REVEALED;
+    case 2:
+    case "TOKEN_TRANSACTION_FINALIZED":
+      return TokenTransactionStatus.TOKEN_TRANSACTION_FINALIZED;
+    case 3:
+    case "TOKEN_TRANSACTION_STARTED_CANCELLED":
+      return TokenTransactionStatus.TOKEN_TRANSACTION_STARTED_CANCELLED;
+    case 4:
+    case "TOKEN_TRANSACTION_SIGNED_CANCELLED":
+      return TokenTransactionStatus.TOKEN_TRANSACTION_SIGNED_CANCELLED;
+    case 10:
+    case "TOKEN_TRANSACTION_UNKNOWN":
+      return TokenTransactionStatus.TOKEN_TRANSACTION_UNKNOWN;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return TokenTransactionStatus.UNRECOGNIZED;
+  }
+}
+
+export function tokenTransactionStatusToJSON(object: TokenTransactionStatus): string {
+  switch (object) {
+    case TokenTransactionStatus.TOKEN_TRANSACTION_STARTED:
+      return "TOKEN_TRANSACTION_STARTED";
+    case TokenTransactionStatus.TOKEN_TRANSACTION_SIGNED:
+      return "TOKEN_TRANSACTION_SIGNED";
+    case TokenTransactionStatus.TOKEN_TRANSACTION_REVEALED:
+      return "TOKEN_TRANSACTION_REVEALED";
+    case TokenTransactionStatus.TOKEN_TRANSACTION_FINALIZED:
+      return "TOKEN_TRANSACTION_FINALIZED";
+    case TokenTransactionStatus.TOKEN_TRANSACTION_STARTED_CANCELLED:
+      return "TOKEN_TRANSACTION_STARTED_CANCELLED";
+    case TokenTransactionStatus.TOKEN_TRANSACTION_SIGNED_CANCELLED:
+      return "TOKEN_TRANSACTION_SIGNED_CANCELLED";
+    case TokenTransactionStatus.TOKEN_TRANSACTION_UNKNOWN:
+      return "TOKEN_TRANSACTION_UNKNOWN";
+    case TokenTransactionStatus.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
 /**
  * This proto is constructed by the wallet to specify leaves it wants to spend
  * as part of the token transaction.
@@ -27,17 +135,18 @@ export interface TokenTransferInput {
 
 export interface TokenMintInput {
   issuerPublicKey: Uint8Array;
-  /**
-   * Issuer provided timestamp of when the transaction was signed/constructed.
-   * Helps provide idempotency and ensures that each mint input signature is
-   * unique as long as multiple mint signatures are not happening at the same
-   * time. Also gives a potentially useful data point for when the issuer
-   * authorized from their perspective.  Note that we have no way of proving
-   * this is accurate.
-   * TODO: Consider whether implementing generic idempotency controls and/or a
-   * random nonce would be favorable to populating this field.
-   */
-  issuerProvidedTimestamp: number;
+  tokenIdentifier?: Uint8Array | undefined;
+}
+
+export interface TokenCreateInput {
+  issuerPublicKey: Uint8Array;
+  tokenName: string;
+  tokenTicker: string;
+  decimals: number;
+  /** Decoded uint128 */
+  maxSupply: Uint8Array;
+  isFreezable: boolean;
+  creationEntityPublicKey?: Uint8Array | undefined;
 }
 
 /**
@@ -52,7 +161,10 @@ export interface TokenOutput {
   revocationCommitment?: Uint8Array | undefined;
   withdrawBondSats?: number | undefined;
   withdrawRelativeBlockLocktime?: number | undefined;
-  tokenPublicKey: Uint8Array;
+  tokenPublicKey?: Uint8Array | undefined;
+  tokenIdentifier?:
+    | Uint8Array
+    | undefined;
   /** Decoded uint128 */
   tokenAmount: Uint8Array;
 }
@@ -70,10 +182,11 @@ export interface TokenTransaction {
    * leaves must match the token amount in the output leaves.
    */
   version: number;
-  tokenInputs?: { $case: "mintInput"; mintInput: TokenMintInput } | {
-    $case: "transferInput";
-    transferInput: TokenTransferInput;
-  } | undefined;
+  tokenInputs?:
+    | { $case: "mintInput"; mintInput: TokenMintInput }
+    | { $case: "transferInput"; transferInput: TokenTransferInput }
+    | { $case: "createInput"; createInput: TokenCreateInput }
+    | undefined;
   tokenOutputs: TokenOutput[];
   sparkOperatorIdentityPublicKeys: Uint8Array[];
   /**
@@ -83,6 +196,12 @@ export interface TokenTransaction {
    */
   expiryTime: Date | undefined;
   network: Network;
+  /**
+   * The timestamp of when the client created the transaction. This is used to
+   * determine which transaction should win in a race condition. Earlier
+   * timestamps win over later ones.
+   */
+  clientCreatedTimestamp: Date | undefined;
 }
 
 export interface SignatureWithIndex {
@@ -120,7 +239,7 @@ export interface StartTransactionRequest {
   /**
    * How long the transaction should be valid for, in seconds.
    * The server will set the actual expiry_time in the final transaction based
-   * on this duration. Must be between 1 and 300 seconds.
+   * on this duration. Must be within [1, 300] seconds.
    */
   validityDurationSeconds: number;
 }
@@ -140,6 +259,82 @@ export interface CommitTransactionRequest {
 export interface CommitTransactionResponse {
 }
 
+export interface QueryTokenMetadataRequest {
+  tokenIdentifiers: Uint8Array[];
+  issuerPublicKeys: Uint8Array[];
+}
+
+export interface TokenMetadata {
+  issuerPublicKey: Uint8Array;
+  tokenName: string;
+  tokenTicker: string;
+  decimals: number;
+  /** Decoded uint128 */
+  maxSupply: Uint8Array;
+  isFreezable: boolean;
+  creationEntityPublicKey?: Uint8Array | undefined;
+  tokenIdentifier: Uint8Array;
+}
+
+export interface QueryTokenMetadataResponse {
+  tokenMetadata: TokenMetadata[];
+}
+
+export interface QueryTokenOutputsRequest {
+  ownerPublicKeys: Uint8Array[];
+  /** Optionally provide issuer public keys or token identifiers. If both are not set return outputs for all tokens. */
+  issuerPublicKeys: Uint8Array[];
+  tokenIdentifiers: Uint8Array[];
+  /** defaults to mainnet when no network is provided. */
+  network: Network;
+}
+
+/** Request constraints are combined using an AND relation. */
+export interface QueryTokenTransactionsRequest {
+  /** Returns transactions that have one of these output ids in the input or output. */
+  outputIds: string[];
+  /** Returns transactions that have this owner public key as the sender or receiver in one or more of the input/output leaves. */
+  ownerPublicKeys: Uint8Array[];
+  /** Returns transactions that related to this token public key. */
+  issuerPublicKeys: Uint8Array[];
+  /** Returns transactions that related to this token identifier. */
+  tokenIdentifiers: Uint8Array[];
+  /** Returns transactions that match the provided transaction hashes. */
+  tokenTransactionHashes: Uint8Array[];
+  limit: number;
+  offset: number;
+}
+
+export interface QueryTokenTransactionsResponse {
+  tokenTransactionsWithStatus: TokenTransactionWithStatus[];
+  offset: number;
+}
+
+export interface OutputWithPreviousTransactionData {
+  output: TokenOutput | undefined;
+  previousTransactionHash: Uint8Array;
+  previousTransactionVout: number;
+}
+
+export interface QueryTokenOutputsResponse {
+  outputsWithPreviousTransactionData: OutputWithPreviousTransactionData[];
+}
+
+export interface SpentTokenOutputMetadata {
+  outputId: string;
+  revocationSecret: Uint8Array;
+}
+
+export interface TokenTransactionConfirmationMetadata {
+  spentTokenOutputsMetadata: SpentTokenOutputMetadata[];
+}
+
+export interface TokenTransactionWithStatus {
+  tokenTransaction: TokenTransaction | undefined;
+  status: TokenTransactionStatus;
+  confirmationMetadata: TokenTransactionConfirmationMetadata | undefined;
+}
+
 function createBaseTokenOutputToSpend(): TokenOutputToSpend {
   return { prevTokenTransactionHash: new Uint8Array(0), prevTokenTransactionVout: 0 };
 }
@@ -157,7 +352,7 @@ export const TokenOutputToSpend: MessageFns<TokenOutputToSpend> = {
 
   decode(input: BinaryReader | Uint8Array, length?: number): TokenOutputToSpend {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseTokenOutputToSpend();
     while (reader.pos < end) {
       const tag = reader.uint32();
@@ -234,7 +429,7 @@ export const TokenTransferInput: MessageFns<TokenTransferInput> = {
 
   decode(input: BinaryReader | Uint8Array, length?: number): TokenTransferInput {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseTokenTransferInput();
     while (reader.pos < end) {
       const tag = reader.uint32();
@@ -283,7 +478,7 @@ export const TokenTransferInput: MessageFns<TokenTransferInput> = {
 };
 
 function createBaseTokenMintInput(): TokenMintInput {
-  return { issuerPublicKey: new Uint8Array(0), issuerProvidedTimestamp: 0 };
+  return { issuerPublicKey: new Uint8Array(0), tokenIdentifier: undefined };
 }
 
 export const TokenMintInput: MessageFns<TokenMintInput> = {
@@ -291,15 +486,15 @@ export const TokenMintInput: MessageFns<TokenMintInput> = {
     if (message.issuerPublicKey.length !== 0) {
       writer.uint32(10).bytes(message.issuerPublicKey);
     }
-    if (message.issuerProvidedTimestamp !== 0) {
-      writer.uint32(16).uint64(message.issuerProvidedTimestamp);
+    if (message.tokenIdentifier !== undefined) {
+      writer.uint32(18).bytes(message.tokenIdentifier);
     }
     return writer;
   },
 
   decode(input: BinaryReader | Uint8Array, length?: number): TokenMintInput {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseTokenMintInput();
     while (reader.pos < end) {
       const tag = reader.uint32();
@@ -313,11 +508,11 @@ export const TokenMintInput: MessageFns<TokenMintInput> = {
           continue;
         }
         case 2: {
-          if (tag !== 16) {
+          if (tag !== 18) {
             break;
           }
 
-          message.issuerProvidedTimestamp = longToNumber(reader.uint64());
+          message.tokenIdentifier = reader.bytes();
           continue;
         }
       }
@@ -332,9 +527,7 @@ export const TokenMintInput: MessageFns<TokenMintInput> = {
   fromJSON(object: any): TokenMintInput {
     return {
       issuerPublicKey: isSet(object.issuerPublicKey) ? bytesFromBase64(object.issuerPublicKey) : new Uint8Array(0),
-      issuerProvidedTimestamp: isSet(object.issuerProvidedTimestamp)
-        ? globalThis.Number(object.issuerProvidedTimestamp)
-        : 0,
+      tokenIdentifier: isSet(object.tokenIdentifier) ? bytesFromBase64(object.tokenIdentifier) : undefined,
     };
   },
 
@@ -343,8 +536,8 @@ export const TokenMintInput: MessageFns<TokenMintInput> = {
     if (message.issuerPublicKey.length !== 0) {
       obj.issuerPublicKey = base64FromBytes(message.issuerPublicKey);
     }
-    if (message.issuerProvidedTimestamp !== 0) {
-      obj.issuerProvidedTimestamp = Math.round(message.issuerProvidedTimestamp);
+    if (message.tokenIdentifier !== undefined) {
+      obj.tokenIdentifier = base64FromBytes(message.tokenIdentifier);
     }
     return obj;
   },
@@ -355,7 +548,173 @@ export const TokenMintInput: MessageFns<TokenMintInput> = {
   fromPartial(object: DeepPartial<TokenMintInput>): TokenMintInput {
     const message = createBaseTokenMintInput();
     message.issuerPublicKey = object.issuerPublicKey ?? new Uint8Array(0);
-    message.issuerProvidedTimestamp = object.issuerProvidedTimestamp ?? 0;
+    message.tokenIdentifier = object.tokenIdentifier ?? undefined;
+    return message;
+  },
+};
+
+function createBaseTokenCreateInput(): TokenCreateInput {
+  return {
+    issuerPublicKey: new Uint8Array(0),
+    tokenName: "",
+    tokenTicker: "",
+    decimals: 0,
+    maxSupply: new Uint8Array(0),
+    isFreezable: false,
+    creationEntityPublicKey: undefined,
+  };
+}
+
+export const TokenCreateInput: MessageFns<TokenCreateInput> = {
+  encode(message: TokenCreateInput, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.issuerPublicKey.length !== 0) {
+      writer.uint32(10).bytes(message.issuerPublicKey);
+    }
+    if (message.tokenName !== "") {
+      writer.uint32(18).string(message.tokenName);
+    }
+    if (message.tokenTicker !== "") {
+      writer.uint32(26).string(message.tokenTicker);
+    }
+    if (message.decimals !== 0) {
+      writer.uint32(32).uint32(message.decimals);
+    }
+    if (message.maxSupply.length !== 0) {
+      writer.uint32(42).bytes(message.maxSupply);
+    }
+    if (message.isFreezable !== false) {
+      writer.uint32(48).bool(message.isFreezable);
+    }
+    if (message.creationEntityPublicKey !== undefined) {
+      writer.uint32(58).bytes(message.creationEntityPublicKey);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TokenCreateInput {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTokenCreateInput();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.issuerPublicKey = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.tokenName = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.tokenTicker = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.decimals = reader.uint32();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.maxSupply = reader.bytes();
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+
+          message.isFreezable = reader.bool();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+
+          message.creationEntityPublicKey = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TokenCreateInput {
+    return {
+      issuerPublicKey: isSet(object.issuerPublicKey) ? bytesFromBase64(object.issuerPublicKey) : new Uint8Array(0),
+      tokenName: isSet(object.tokenName) ? globalThis.String(object.tokenName) : "",
+      tokenTicker: isSet(object.tokenTicker) ? globalThis.String(object.tokenTicker) : "",
+      decimals: isSet(object.decimals) ? globalThis.Number(object.decimals) : 0,
+      maxSupply: isSet(object.maxSupply) ? bytesFromBase64(object.maxSupply) : new Uint8Array(0),
+      isFreezable: isSet(object.isFreezable) ? globalThis.Boolean(object.isFreezable) : false,
+      creationEntityPublicKey: isSet(object.creationEntityPublicKey)
+        ? bytesFromBase64(object.creationEntityPublicKey)
+        : undefined,
+    };
+  },
+
+  toJSON(message: TokenCreateInput): unknown {
+    const obj: any = {};
+    if (message.issuerPublicKey.length !== 0) {
+      obj.issuerPublicKey = base64FromBytes(message.issuerPublicKey);
+    }
+    if (message.tokenName !== "") {
+      obj.tokenName = message.tokenName;
+    }
+    if (message.tokenTicker !== "") {
+      obj.tokenTicker = message.tokenTicker;
+    }
+    if (message.decimals !== 0) {
+      obj.decimals = Math.round(message.decimals);
+    }
+    if (message.maxSupply.length !== 0) {
+      obj.maxSupply = base64FromBytes(message.maxSupply);
+    }
+    if (message.isFreezable !== false) {
+      obj.isFreezable = message.isFreezable;
+    }
+    if (message.creationEntityPublicKey !== undefined) {
+      obj.creationEntityPublicKey = base64FromBytes(message.creationEntityPublicKey);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<TokenCreateInput>): TokenCreateInput {
+    return TokenCreateInput.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<TokenCreateInput>): TokenCreateInput {
+    const message = createBaseTokenCreateInput();
+    message.issuerPublicKey = object.issuerPublicKey ?? new Uint8Array(0);
+    message.tokenName = object.tokenName ?? "";
+    message.tokenTicker = object.tokenTicker ?? "";
+    message.decimals = object.decimals ?? 0;
+    message.maxSupply = object.maxSupply ?? new Uint8Array(0);
+    message.isFreezable = object.isFreezable ?? false;
+    message.creationEntityPublicKey = object.creationEntityPublicKey ?? undefined;
     return message;
   },
 };
@@ -367,7 +726,8 @@ function createBaseTokenOutput(): TokenOutput {
     revocationCommitment: undefined,
     withdrawBondSats: undefined,
     withdrawRelativeBlockLocktime: undefined,
-    tokenPublicKey: new Uint8Array(0),
+    tokenPublicKey: undefined,
+    tokenIdentifier: undefined,
     tokenAmount: new Uint8Array(0),
   };
 }
@@ -389,9 +749,12 @@ export const TokenOutput: MessageFns<TokenOutput> = {
     if (message.withdrawRelativeBlockLocktime !== undefined) {
       writer.uint32(40).uint64(message.withdrawRelativeBlockLocktime);
     }
-    if (message.tokenPublicKey.length !== 0) {
+    if (message.tokenPublicKey !== undefined) {
       writer.uint32(50).bytes(message.tokenPublicKey);
     }
+    if (message.tokenIdentifier !== undefined) {
+      writer.uint32(66).bytes(message.tokenIdentifier);
+    }
     if (message.tokenAmount.length !== 0) {
       writer.uint32(58).bytes(message.tokenAmount);
     }
@@ -400,7 +763,7 @@ export const TokenOutput: MessageFns<TokenOutput> = {
 
   decode(input: BinaryReader | Uint8Array, length?: number): TokenOutput {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseTokenOutput();
     while (reader.pos < end) {
       const tag = reader.uint32();
@@ -453,6 +816,14 @@ export const TokenOutput: MessageFns<TokenOutput> = {
           message.tokenPublicKey = reader.bytes();
           continue;
         }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+
+          message.tokenIdentifier = reader.bytes();
+          continue;
+        }
         case 7: {
           if (tag !== 58) {
             break;
@@ -481,7 +852,8 @@ export const TokenOutput: MessageFns<TokenOutput> = {
       withdrawRelativeBlockLocktime: isSet(object.withdrawRelativeBlockLocktime)
         ? globalThis.Number(object.withdrawRelativeBlockLocktime)
         : undefined,
-      tokenPublicKey: isSet(object.tokenPublicKey) ? bytesFromBase64(object.tokenPublicKey) : new Uint8Array(0),
+      tokenPublicKey: isSet(object.tokenPublicKey) ? bytesFromBase64(object.tokenPublicKey) : undefined,
+      tokenIdentifier: isSet(object.tokenIdentifier) ? bytesFromBase64(object.tokenIdentifier) : undefined,
       tokenAmount: isSet(object.tokenAmount) ? bytesFromBase64(object.tokenAmount) : new Uint8Array(0),
     };
   },
@@ -503,9 +875,12 @@ export const TokenOutput: MessageFns<TokenOutput> = {
     if (message.withdrawRelativeBlockLocktime !== undefined) {
       obj.withdrawRelativeBlockLocktime = Math.round(message.withdrawRelativeBlockLocktime);
     }
-    if (message.tokenPublicKey.length !== 0) {
+    if (message.tokenPublicKey !== undefined) {
       obj.tokenPublicKey = base64FromBytes(message.tokenPublicKey);
     }
+    if (message.tokenIdentifier !== undefined) {
+      obj.tokenIdentifier = base64FromBytes(message.tokenIdentifier);
+    }
     if (message.tokenAmount.length !== 0) {
       obj.tokenAmount = base64FromBytes(message.tokenAmount);
     }
@@ -522,7 +897,8 @@ export const TokenOutput: MessageFns<TokenOutput> = {
     message.revocationCommitment = object.revocationCommitment ?? undefined;
     message.withdrawBondSats = object.withdrawBondSats ?? undefined;
     message.withdrawRelativeBlockLocktime = object.withdrawRelativeBlockLocktime ?? undefined;
-    message.tokenPublicKey = object.tokenPublicKey ?? new Uint8Array(0);
+    message.tokenPublicKey = object.tokenPublicKey ?? undefined;
+    message.tokenIdentifier = object.tokenIdentifier ?? undefined;
     message.tokenAmount = object.tokenAmount ?? new Uint8Array(0);
     return message;
   },
@@ -536,6 +912,7 @@ function createBaseTokenTransaction(): TokenTransaction {
     sparkOperatorIdentityPublicKeys: [],
     expiryTime: undefined,
     network: 0,
+    clientCreatedTimestamp: undefined,
   };
 }
 
@@ -551,6 +928,9 @@ export const TokenTransaction: MessageFns<TokenTransaction> = {
       case "transferInput":
         TokenTransferInput.encode(message.tokenInputs.transferInput, writer.uint32(26).fork()).join();
         break;
+      case "createInput":
+        TokenCreateInput.encode(message.tokenInputs.createInput, writer.uint32(66).fork()).join();
+        break;
     }
     for (const v of message.tokenOutputs) {
       TokenOutput.encode(v!, writer.uint32(34).fork()).join();
@@ -564,12 +944,15 @@ export const TokenTransaction: MessageFns<TokenTransaction> = {
     if (message.network !== 0) {
       writer.uint32(56).int32(message.network);
     }
+    if (message.clientCreatedTimestamp !== undefined) {
+      Timestamp.encode(toTimestamp(message.clientCreatedTimestamp), writer.uint32(74).fork()).join();
+    }
     return writer;
   },
 
   decode(input: BinaryReader | Uint8Array, length?: number): TokenTransaction {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseTokenTransaction();
     while (reader.pos < end) {
       const tag = reader.uint32();
@@ -601,6 +984,14 @@ export const TokenTransaction: MessageFns<TokenTransaction> = {
           };
           continue;
         }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+
+          message.tokenInputs = { $case: "createInput", createInput: TokenCreateInput.decode(reader, reader.uint32()) };
+          continue;
+        }
         case 4: {
           if (tag !== 34) {
             break;
@@ -633,6 +1024,14 @@ export const TokenTransaction: MessageFns<TokenTransaction> = {
           message.network = reader.int32() as any;
           continue;
         }
+        case 9: {
+          if (tag !== 74) {
+            break;
+          }
+
+          message.clientCreatedTimestamp = fromTimestamp(Timestamp.decode(reader, reader.uint32()));
+          continue;
+        }
       }
       if ((tag & 7) === 4 || tag === 0) {
         break;
@@ -649,6 +1048,8 @@ export const TokenTransaction: MessageFns<TokenTransaction> = {
         ? { $case: "mintInput", mintInput: TokenMintInput.fromJSON(object.mintInput) }
         : isSet(object.transferInput)
         ? { $case: "transferInput", transferInput: TokenTransferInput.fromJSON(object.transferInput) }
+        : isSet(object.createInput)
+        ? { $case: "createInput", createInput: TokenCreateInput.fromJSON(object.createInput) }
         : undefined,
       tokenOutputs: globalThis.Array.isArray(object?.tokenOutputs)
         ? object.tokenOutputs.map((e: any) => TokenOutput.fromJSON(e))
@@ -658,6 +1059,9 @@ export const TokenTransaction: MessageFns<TokenTransaction> = {
         : [],
       expiryTime: isSet(object.expiryTime) ? fromJsonTimestamp(object.expiryTime) : undefined,
       network: isSet(object.network) ? networkFromJSON(object.network) : 0,
+      clientCreatedTimestamp: isSet(object.clientCreatedTimestamp)
+        ? fromJsonTimestamp(object.clientCreatedTimestamp)
+        : undefined,
     };
   },
 
@@ -670,6 +1074,8 @@ export const TokenTransaction: MessageFns<TokenTransaction> = {
       obj.mintInput = TokenMintInput.toJSON(message.tokenInputs.mintInput);
     } else if (message.tokenInputs?.$case === "transferInput") {
       obj.transferInput = TokenTransferInput.toJSON(message.tokenInputs.transferInput);
+    } else if (message.tokenInputs?.$case === "createInput") {
+      obj.createInput = TokenCreateInput.toJSON(message.tokenInputs.createInput);
     }
     if (message.tokenOutputs?.length) {
       obj.tokenOutputs = message.tokenOutputs.map((e) => TokenOutput.toJSON(e));
@@ -683,6 +1089,9 @@ export const TokenTransaction: MessageFns<TokenTransaction> = {
     if (message.network !== 0) {
       obj.network = networkToJSON(message.network);
     }
+    if (message.clientCreatedTimestamp !== undefined) {
+      obj.clientCreatedTimestamp = message.clientCreatedTimestamp.toISOString();
+    }
     return obj;
   },
 
@@ -711,11 +1120,21 @@ export const TokenTransaction: MessageFns<TokenTransaction> = {
         }
         break;
       }
+      case "createInput": {
+        if (object.tokenInputs?.createInput !== undefined && object.tokenInputs?.createInput !== null) {
+          message.tokenInputs = {
+            $case: "createInput",
+            createInput: TokenCreateInput.fromPartial(object.tokenInputs.createInput),
+          };
+        }
+        break;
+      }
     }
     message.tokenOutputs = object.tokenOutputs?.map((e) => TokenOutput.fromPartial(e)) || [];
     message.sparkOperatorIdentityPublicKeys = object.sparkOperatorIdentityPublicKeys?.map((e) => e) || [];
     message.expiryTime = object.expiryTime ?? undefined;
     message.network = object.network ?? 0;
+    message.clientCreatedTimestamp = object.clientCreatedTimestamp ?? undefined;
     return message;
   },
 };
@@ -737,7 +1156,7 @@ export const SignatureWithIndex: MessageFns<SignatureWithIndex> = {
 
   decode(input: BinaryReader | Uint8Array, length?: number): SignatureWithIndex {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseSignatureWithIndex();
     while (reader.pos < end) {
       const tag = reader.uint32();
@@ -813,7 +1232,7 @@ export const InputTtxoSignaturesPerOperator: MessageFns<InputTtxoSignaturesPerOp
 
   decode(input: BinaryReader | Uint8Array, length?: number): InputTtxoSignaturesPerOperator {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseInputTtxoSignaturesPerOperator();
     while (reader.pos < end) {
       const tag = reader.uint32();
@@ -904,7 +1323,7 @@ export const StartTransactionRequest: MessageFns<StartTransactionRequest> = {
 
   decode(input: BinaryReader | Uint8Array, length?: number): StartTransactionRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseStartTransactionRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
@@ -1020,7 +1439,7 @@ export const StartTransactionResponse: MessageFns<StartTransactionResponse> = {
 
   decode(input: BinaryReader | Uint8Array, length?: number): StartTransactionResponse {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseStartTransactionResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
@@ -1114,7 +1533,7 @@ export const CommitTransactionRequest: MessageFns<CommitTransactionRequest> = {
 
   decode(input: BinaryReader | Uint8Array, length?: number): CommitTransactionRequest {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseCommitTransactionRequest();
     while (reader.pos < end) {
       const tag = reader.uint32();
@@ -1224,7 +1643,7 @@ export const CommitTransactionResponse: MessageFns<CommitTransactionResponse> =
 
   decode(input: BinaryReader | Uint8Array, length?: number): CommitTransactionResponse {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
-    let end = length === undefined ? reader.len : reader.pos + length;
+    const end = length === undefined ? reader.len : reader.pos + length;
     const message = createBaseCommitTransactionResponse();
     while (reader.pos < end) {
       const tag = reader.uint32();
@@ -1256,74 +1675,1218 @@ export const CommitTransactionResponse: MessageFns<CommitTransactionResponse> =
   },
 };
 
-export type SparkTokenServiceDefinition = typeof SparkTokenServiceDefinition;
-export const SparkTokenServiceDefinition = {
-  name: "SparkTokenService",
-  fullName: "spark_token.SparkTokenService",
-  methods: {
-    /**
-     * Start process to create final token transaction with all inputs required
-     * from user and SOs (including revocation secret commitment)
-     */
-    start_transaction: {
-      name: "start_transaction",
-      requestType: StartTransactionRequest,
-      requestStream: false,
-      responseType: StartTransactionResponse,
-      responseStream: false,
-      options: {},
-    },
-    /**
-     * Complete the transaction and commit it with all SOs. This will be
-     * coordinated by one SO.
-     */
-    commit_transaction: {
-      name: "commit_transaction",
-      requestType: CommitTransactionRequest,
-      requestStream: false,
-      responseType: CommitTransactionResponse,
-      responseStream: false,
-      options: {},
-    },
+function createBaseQueryTokenMetadataRequest(): QueryTokenMetadataRequest {
+  return { tokenIdentifiers: [], issuerPublicKeys: [] };
+}
+
+export const QueryTokenMetadataRequest: MessageFns<QueryTokenMetadataRequest> = {
+  encode(message: QueryTokenMetadataRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.tokenIdentifiers) {
+      writer.uint32(10).bytes(v!);
+    }
+    for (const v of message.issuerPublicKeys) {
+      writer.uint32(18).bytes(v!);
+    }
+    return writer;
   },
-} as const;
 
-export interface SparkTokenServiceImplementation<CallContextExt = {}> {
-  /**
-   * Start process to create final token transaction with all inputs required
-   * from user and SOs (including revocation secret commitment)
-   */
-  start_transaction(
-    request: StartTransactionRequest,
-    context: CallContext & CallContextExt,
-  ): Promise<DeepPartial<StartTransactionResponse>>;
-  /**
-   * Complete the transaction and commit it with all SOs. This will be
-   * coordinated by one SO.
-   */
-  commit_transaction(
-    request: CommitTransactionRequest,
-    context: CallContext & CallContextExt,
-  ): Promise<DeepPartial<CommitTransactionResponse>>;
-}
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryTokenMetadataRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryTokenMetadataRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
 
-export interface SparkTokenServiceClient<CallOptionsExt = {}> {
-  /**
-   * Start process to create final token transaction with all inputs required
-   * from user and SOs (including revocation secret commitment)
-   */
-  start_transaction(
-    request: DeepPartial<StartTransactionRequest>,
-    options?: CallOptions & CallOptionsExt,
-  ): Promise<StartTransactionResponse>;
-  /**
-   * Complete the transaction and commit it with all SOs. This will be
-   * coordinated by one SO.
+          message.tokenIdentifiers.push(reader.bytes());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.issuerPublicKeys.push(reader.bytes());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): QueryTokenMetadataRequest {
+    return {
+      tokenIdentifiers: globalThis.Array.isArray(object?.tokenIdentifiers)
+        ? object.tokenIdentifiers.map((e: any) => bytesFromBase64(e))
+        : [],
+      issuerPublicKeys: globalThis.Array.isArray(object?.issuerPublicKeys)
+        ? object.issuerPublicKeys.map((e: any) => bytesFromBase64(e))
+        : [],
+    };
+  },
+
+  toJSON(message: QueryTokenMetadataRequest): unknown {
+    const obj: any = {};
+    if (message.tokenIdentifiers?.length) {
+      obj.tokenIdentifiers = message.tokenIdentifiers.map((e) => base64FromBytes(e));
+    }
+    if (message.issuerPublicKeys?.length) {
+      obj.issuerPublicKeys = message.issuerPublicKeys.map((e) => base64FromBytes(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<QueryTokenMetadataRequest>): QueryTokenMetadataRequest {
+    return QueryTokenMetadataRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<QueryTokenMetadataRequest>): QueryTokenMetadataRequest {
+    const message = createBaseQueryTokenMetadataRequest();
+    message.tokenIdentifiers = object.tokenIdentifiers?.map((e) => e) || [];
+    message.issuerPublicKeys = object.issuerPublicKeys?.map((e) => e) || [];
+    return message;
+  },
+};
+
+function createBaseTokenMetadata(): TokenMetadata {
+  return {
+    issuerPublicKey: new Uint8Array(0),
+    tokenName: "",
+    tokenTicker: "",
+    decimals: 0,
+    maxSupply: new Uint8Array(0),
+    isFreezable: false,
+    creationEntityPublicKey: undefined,
+    tokenIdentifier: new Uint8Array(0),
+  };
+}
+
+export const TokenMetadata: MessageFns<TokenMetadata> = {
+  encode(message: TokenMetadata, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.issuerPublicKey.length !== 0) {
+      writer.uint32(10).bytes(message.issuerPublicKey);
+    }
+    if (message.tokenName !== "") {
+      writer.uint32(18).string(message.tokenName);
+    }
+    if (message.tokenTicker !== "") {
+      writer.uint32(26).string(message.tokenTicker);
+    }
+    if (message.decimals !== 0) {
+      writer.uint32(32).uint32(message.decimals);
+    }
+    if (message.maxSupply.length !== 0) {
+      writer.uint32(42).bytes(message.maxSupply);
+    }
+    if (message.isFreezable !== false) {
+      writer.uint32(48).bool(message.isFreezable);
+    }
+    if (message.creationEntityPublicKey !== undefined) {
+      writer.uint32(58).bytes(message.creationEntityPublicKey);
+    }
+    if (message.tokenIdentifier.length !== 0) {
+      writer.uint32(66).bytes(message.tokenIdentifier);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TokenMetadata {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTokenMetadata();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.issuerPublicKey = reader.bytes();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.tokenName = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.tokenTicker = reader.string();
+          continue;
+        }
+        case 4: {
+          if (tag !== 32) {
+            break;
+          }
+
+          message.decimals = reader.uint32();
+          continue;
+        }
+        case 5: {
+          if (tag !== 42) {
+            break;
+          }
+
+          message.maxSupply = reader.bytes();
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+
+          message.isFreezable = reader.bool();
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+
+          message.creationEntityPublicKey = reader.bytes();
+          continue;
+        }
+        case 8: {
+          if (tag !== 66) {
+            break;
+          }
+
+          message.tokenIdentifier = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TokenMetadata {
+    return {
+      issuerPublicKey: isSet(object.issuerPublicKey) ? bytesFromBase64(object.issuerPublicKey) : new Uint8Array(0),
+      tokenName: isSet(object.tokenName) ? globalThis.String(object.tokenName) : "",
+      tokenTicker: isSet(object.tokenTicker) ? globalThis.String(object.tokenTicker) : "",
+      decimals: isSet(object.decimals) ? globalThis.Number(object.decimals) : 0,
+      maxSupply: isSet(object.maxSupply) ? bytesFromBase64(object.maxSupply) : new Uint8Array(0),
+      isFreezable: isSet(object.isFreezable) ? globalThis.Boolean(object.isFreezable) : false,
+      creationEntityPublicKey: isSet(object.creationEntityPublicKey)
+        ? bytesFromBase64(object.creationEntityPublicKey)
+        : undefined,
+      tokenIdentifier: isSet(object.tokenIdentifier) ? bytesFromBase64(object.tokenIdentifier) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: TokenMetadata): unknown {
+    const obj: any = {};
+    if (message.issuerPublicKey.length !== 0) {
+      obj.issuerPublicKey = base64FromBytes(message.issuerPublicKey);
+    }
+    if (message.tokenName !== "") {
+      obj.tokenName = message.tokenName;
+    }
+    if (message.tokenTicker !== "") {
+      obj.tokenTicker = message.tokenTicker;
+    }
+    if (message.decimals !== 0) {
+      obj.decimals = Math.round(message.decimals);
+    }
+    if (message.maxSupply.length !== 0) {
+      obj.maxSupply = base64FromBytes(message.maxSupply);
+    }
+    if (message.isFreezable !== false) {
+      obj.isFreezable = message.isFreezable;
+    }
+    if (message.creationEntityPublicKey !== undefined) {
+      obj.creationEntityPublicKey = base64FromBytes(message.creationEntityPublicKey);
+    }
+    if (message.tokenIdentifier.length !== 0) {
+      obj.tokenIdentifier = base64FromBytes(message.tokenIdentifier);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<TokenMetadata>): TokenMetadata {
+    return TokenMetadata.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<TokenMetadata>): TokenMetadata {
+    const message = createBaseTokenMetadata();
+    message.issuerPublicKey = object.issuerPublicKey ?? new Uint8Array(0);
+    message.tokenName = object.tokenName ?? "";
+    message.tokenTicker = object.tokenTicker ?? "";
+    message.decimals = object.decimals ?? 0;
+    message.maxSupply = object.maxSupply ?? new Uint8Array(0);
+    message.isFreezable = object.isFreezable ?? false;
+    message.creationEntityPublicKey = object.creationEntityPublicKey ?? undefined;
+    message.tokenIdentifier = object.tokenIdentifier ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function createBaseQueryTokenMetadataResponse(): QueryTokenMetadataResponse {
+  return { tokenMetadata: [] };
+}
+
+export const QueryTokenMetadataResponse: MessageFns<QueryTokenMetadataResponse> = {
+  encode(message: QueryTokenMetadataResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.tokenMetadata) {
+      TokenMetadata.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryTokenMetadataResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryTokenMetadataResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.tokenMetadata.push(TokenMetadata.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): QueryTokenMetadataResponse {
+    return {
+      tokenMetadata: globalThis.Array.isArray(object?.tokenMetadata)
+        ? object.tokenMetadata.map((e: any) => TokenMetadata.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: QueryTokenMetadataResponse): unknown {
+    const obj: any = {};
+    if (message.tokenMetadata?.length) {
+      obj.tokenMetadata = message.tokenMetadata.map((e) => TokenMetadata.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<QueryTokenMetadataResponse>): QueryTokenMetadataResponse {
+    return QueryTokenMetadataResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<QueryTokenMetadataResponse>): QueryTokenMetadataResponse {
+    const message = createBaseQueryTokenMetadataResponse();
+    message.tokenMetadata = object.tokenMetadata?.map((e) => TokenMetadata.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseQueryTokenOutputsRequest(): QueryTokenOutputsRequest {
+  return { ownerPublicKeys: [], issuerPublicKeys: [], tokenIdentifiers: [], network: 0 };
+}
+
+export const QueryTokenOutputsRequest: MessageFns<QueryTokenOutputsRequest> = {
+  encode(message: QueryTokenOutputsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.ownerPublicKeys) {
+      writer.uint32(10).bytes(v!);
+    }
+    for (const v of message.issuerPublicKeys) {
+      writer.uint32(18).bytes(v!);
+    }
+    for (const v of message.tokenIdentifiers) {
+      writer.uint32(34).bytes(v!);
+    }
+    if (message.network !== 0) {
+      writer.uint32(24).int32(message.network);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryTokenOutputsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryTokenOutputsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.ownerPublicKeys.push(reader.bytes());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.issuerPublicKeys.push(reader.bytes());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.tokenIdentifiers.push(reader.bytes());
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.network = reader.int32() as any;
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): QueryTokenOutputsRequest {
+    return {
+      ownerPublicKeys: globalThis.Array.isArray(object?.ownerPublicKeys)
+        ? object.ownerPublicKeys.map((e: any) => bytesFromBase64(e))
+        : [],
+      issuerPublicKeys: globalThis.Array.isArray(object?.issuerPublicKeys)
+        ? object.issuerPublicKeys.map((e: any) => bytesFromBase64(e))
+        : [],
+      tokenIdentifiers: globalThis.Array.isArray(object?.tokenIdentifiers)
+        ? object.tokenIdentifiers.map((e: any) => bytesFromBase64(e))
+        : [],
+      network: isSet(object.network) ? networkFromJSON(object.network) : 0,
+    };
+  },
+
+  toJSON(message: QueryTokenOutputsRequest): unknown {
+    const obj: any = {};
+    if (message.ownerPublicKeys?.length) {
+      obj.ownerPublicKeys = message.ownerPublicKeys.map((e) => base64FromBytes(e));
+    }
+    if (message.issuerPublicKeys?.length) {
+      obj.issuerPublicKeys = message.issuerPublicKeys.map((e) => base64FromBytes(e));
+    }
+    if (message.tokenIdentifiers?.length) {
+      obj.tokenIdentifiers = message.tokenIdentifiers.map((e) => base64FromBytes(e));
+    }
+    if (message.network !== 0) {
+      obj.network = networkToJSON(message.network);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<QueryTokenOutputsRequest>): QueryTokenOutputsRequest {
+    return QueryTokenOutputsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<QueryTokenOutputsRequest>): QueryTokenOutputsRequest {
+    const message = createBaseQueryTokenOutputsRequest();
+    message.ownerPublicKeys = object.ownerPublicKeys?.map((e) => e) || [];
+    message.issuerPublicKeys = object.issuerPublicKeys?.map((e) => e) || [];
+    message.tokenIdentifiers = object.tokenIdentifiers?.map((e) => e) || [];
+    message.network = object.network ?? 0;
+    return message;
+  },
+};
+
+function createBaseQueryTokenTransactionsRequest(): QueryTokenTransactionsRequest {
+  return {
+    outputIds: [],
+    ownerPublicKeys: [],
+    issuerPublicKeys: [],
+    tokenIdentifiers: [],
+    tokenTransactionHashes: [],
+    limit: 0,
+    offset: 0,
+  };
+}
+
+export const QueryTokenTransactionsRequest: MessageFns<QueryTokenTransactionsRequest> = {
+  encode(message: QueryTokenTransactionsRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.outputIds) {
+      writer.uint32(10).string(v!);
+    }
+    for (const v of message.ownerPublicKeys) {
+      writer.uint32(18).bytes(v!);
+    }
+    for (const v of message.issuerPublicKeys) {
+      writer.uint32(26).bytes(v!);
+    }
+    for (const v of message.tokenIdentifiers) {
+      writer.uint32(58).bytes(v!);
+    }
+    for (const v of message.tokenTransactionHashes) {
+      writer.uint32(34).bytes(v!);
+    }
+    if (message.limit !== 0) {
+      writer.uint32(40).int64(message.limit);
+    }
+    if (message.offset !== 0) {
+      writer.uint32(48).int64(message.offset);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryTokenTransactionsRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryTokenTransactionsRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.outputIds.push(reader.string());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.ownerPublicKeys.push(reader.bytes());
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.issuerPublicKeys.push(reader.bytes());
+          continue;
+        }
+        case 7: {
+          if (tag !== 58) {
+            break;
+          }
+
+          message.tokenIdentifiers.push(reader.bytes());
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+
+          message.tokenTransactionHashes.push(reader.bytes());
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+
+          message.limit = longToNumber(reader.int64());
+          continue;
+        }
+        case 6: {
+          if (tag !== 48) {
+            break;
+          }
+
+          message.offset = longToNumber(reader.int64());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): QueryTokenTransactionsRequest {
+    return {
+      outputIds: globalThis.Array.isArray(object?.outputIds)
+        ? object.outputIds.map((e: any) => globalThis.String(e))
+        : [],
+      ownerPublicKeys: globalThis.Array.isArray(object?.ownerPublicKeys)
+        ? object.ownerPublicKeys.map((e: any) => bytesFromBase64(e))
+        : [],
+      issuerPublicKeys: globalThis.Array.isArray(object?.issuerPublicKeys)
+        ? object.issuerPublicKeys.map((e: any) => bytesFromBase64(e))
+        : [],
+      tokenIdentifiers: globalThis.Array.isArray(object?.tokenIdentifiers)
+        ? object.tokenIdentifiers.map((e: any) => bytesFromBase64(e))
+        : [],
+      tokenTransactionHashes: globalThis.Array.isArray(object?.tokenTransactionHashes)
+        ? object.tokenTransactionHashes.map((e: any) => bytesFromBase64(e))
+        : [],
+      limit: isSet(object.limit) ? globalThis.Number(object.limit) : 0,
+      offset: isSet(object.offset) ? globalThis.Number(object.offset) : 0,
+    };
+  },
+
+  toJSON(message: QueryTokenTransactionsRequest): unknown {
+    const obj: any = {};
+    if (message.outputIds?.length) {
+      obj.outputIds = message.outputIds;
+    }
+    if (message.ownerPublicKeys?.length) {
+      obj.ownerPublicKeys = message.ownerPublicKeys.map((e) => base64FromBytes(e));
+    }
+    if (message.issuerPublicKeys?.length) {
+      obj.issuerPublicKeys = message.issuerPublicKeys.map((e) => base64FromBytes(e));
+    }
+    if (message.tokenIdentifiers?.length) {
+      obj.tokenIdentifiers = message.tokenIdentifiers.map((e) => base64FromBytes(e));
+    }
+    if (message.tokenTransactionHashes?.length) {
+      obj.tokenTransactionHashes = message.tokenTransactionHashes.map((e) => base64FromBytes(e));
+    }
+    if (message.limit !== 0) {
+      obj.limit = Math.round(message.limit);
+    }
+    if (message.offset !== 0) {
+      obj.offset = Math.round(message.offset);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<QueryTokenTransactionsRequest>): QueryTokenTransactionsRequest {
+    return QueryTokenTransactionsRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<QueryTokenTransactionsRequest>): QueryTokenTransactionsRequest {
+    const message = createBaseQueryTokenTransactionsRequest();
+    message.outputIds = object.outputIds?.map((e) => e) || [];
+    message.ownerPublicKeys = object.ownerPublicKeys?.map((e) => e) || [];
+    message.issuerPublicKeys = object.issuerPublicKeys?.map((e) => e) || [];
+    message.tokenIdentifiers = object.tokenIdentifiers?.map((e) => e) || [];
+    message.tokenTransactionHashes = object.tokenTransactionHashes?.map((e) => e) || [];
+    message.limit = object.limit ?? 0;
+    message.offset = object.offset ?? 0;
+    return message;
+  },
+};
+
+function createBaseQueryTokenTransactionsResponse(): QueryTokenTransactionsResponse {
+  return { tokenTransactionsWithStatus: [], offset: 0 };
+}
+
+export const QueryTokenTransactionsResponse: MessageFns<QueryTokenTransactionsResponse> = {
+  encode(message: QueryTokenTransactionsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.tokenTransactionsWithStatus) {
+      TokenTransactionWithStatus.encode(v!, writer.uint32(10).fork()).join();
+    }
+    if (message.offset !== 0) {
+      writer.uint32(16).int64(message.offset);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryTokenTransactionsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryTokenTransactionsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.tokenTransactionsWithStatus.push(TokenTransactionWithStatus.decode(reader, reader.uint32()));
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.offset = longToNumber(reader.int64());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): QueryTokenTransactionsResponse {
+    return {
+      tokenTransactionsWithStatus: globalThis.Array.isArray(object?.tokenTransactionsWithStatus)
+        ? object.tokenTransactionsWithStatus.map((e: any) => TokenTransactionWithStatus.fromJSON(e))
+        : [],
+      offset: isSet(object.offset) ? globalThis.Number(object.offset) : 0,
+    };
+  },
+
+  toJSON(message: QueryTokenTransactionsResponse): unknown {
+    const obj: any = {};
+    if (message.tokenTransactionsWithStatus?.length) {
+      obj.tokenTransactionsWithStatus = message.tokenTransactionsWithStatus.map((e) =>
+        TokenTransactionWithStatus.toJSON(e)
+      );
+    }
+    if (message.offset !== 0) {
+      obj.offset = Math.round(message.offset);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<QueryTokenTransactionsResponse>): QueryTokenTransactionsResponse {
+    return QueryTokenTransactionsResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<QueryTokenTransactionsResponse>): QueryTokenTransactionsResponse {
+    const message = createBaseQueryTokenTransactionsResponse();
+    message.tokenTransactionsWithStatus =
+      object.tokenTransactionsWithStatus?.map((e) => TokenTransactionWithStatus.fromPartial(e)) || [];
+    message.offset = object.offset ?? 0;
+    return message;
+  },
+};
+
+function createBaseOutputWithPreviousTransactionData(): OutputWithPreviousTransactionData {
+  return { output: undefined, previousTransactionHash: new Uint8Array(0), previousTransactionVout: 0 };
+}
+
+export const OutputWithPreviousTransactionData: MessageFns<OutputWithPreviousTransactionData> = {
+  encode(message: OutputWithPreviousTransactionData, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.output !== undefined) {
+      TokenOutput.encode(message.output, writer.uint32(10).fork()).join();
+    }
+    if (message.previousTransactionHash.length !== 0) {
+      writer.uint32(18).bytes(message.previousTransactionHash);
+    }
+    if (message.previousTransactionVout !== 0) {
+      writer.uint32(24).uint32(message.previousTransactionVout);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): OutputWithPreviousTransactionData {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseOutputWithPreviousTransactionData();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.output = TokenOutput.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.previousTransactionHash = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 24) {
+            break;
+          }
+
+          message.previousTransactionVout = reader.uint32();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): OutputWithPreviousTransactionData {
+    return {
+      output: isSet(object.output) ? TokenOutput.fromJSON(object.output) : undefined,
+      previousTransactionHash: isSet(object.previousTransactionHash)
+        ? bytesFromBase64(object.previousTransactionHash)
+        : new Uint8Array(0),
+      previousTransactionVout: isSet(object.previousTransactionVout)
+        ? globalThis.Number(object.previousTransactionVout)
+        : 0,
+    };
+  },
+
+  toJSON(message: OutputWithPreviousTransactionData): unknown {
+    const obj: any = {};
+    if (message.output !== undefined) {
+      obj.output = TokenOutput.toJSON(message.output);
+    }
+    if (message.previousTransactionHash.length !== 0) {
+      obj.previousTransactionHash = base64FromBytes(message.previousTransactionHash);
+    }
+    if (message.previousTransactionVout !== 0) {
+      obj.previousTransactionVout = Math.round(message.previousTransactionVout);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<OutputWithPreviousTransactionData>): OutputWithPreviousTransactionData {
+    return OutputWithPreviousTransactionData.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<OutputWithPreviousTransactionData>): OutputWithPreviousTransactionData {
+    const message = createBaseOutputWithPreviousTransactionData();
+    message.output = (object.output !== undefined && object.output !== null)
+      ? TokenOutput.fromPartial(object.output)
+      : undefined;
+    message.previousTransactionHash = object.previousTransactionHash ?? new Uint8Array(0);
+    message.previousTransactionVout = object.previousTransactionVout ?? 0;
+    return message;
+  },
+};
+
+function createBaseQueryTokenOutputsResponse(): QueryTokenOutputsResponse {
+  return { outputsWithPreviousTransactionData: [] };
+}
+
+export const QueryTokenOutputsResponse: MessageFns<QueryTokenOutputsResponse> = {
+  encode(message: QueryTokenOutputsResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.outputsWithPreviousTransactionData) {
+      OutputWithPreviousTransactionData.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): QueryTokenOutputsResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseQueryTokenOutputsResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.outputsWithPreviousTransactionData.push(
+            OutputWithPreviousTransactionData.decode(reader, reader.uint32()),
+          );
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): QueryTokenOutputsResponse {
+    return {
+      outputsWithPreviousTransactionData: globalThis.Array.isArray(object?.outputsWithPreviousTransactionData)
+        ? object.outputsWithPreviousTransactionData.map((e: any) => OutputWithPreviousTransactionData.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: QueryTokenOutputsResponse): unknown {
+    const obj: any = {};
+    if (message.outputsWithPreviousTransactionData?.length) {
+      obj.outputsWithPreviousTransactionData = message.outputsWithPreviousTransactionData.map((e) =>
+        OutputWithPreviousTransactionData.toJSON(e)
+      );
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<QueryTokenOutputsResponse>): QueryTokenOutputsResponse {
+    return QueryTokenOutputsResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<QueryTokenOutputsResponse>): QueryTokenOutputsResponse {
+    const message = createBaseQueryTokenOutputsResponse();
+    message.outputsWithPreviousTransactionData =
+      object.outputsWithPreviousTransactionData?.map((e) => OutputWithPreviousTransactionData.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseSpentTokenOutputMetadata(): SpentTokenOutputMetadata {
+  return { outputId: "", revocationSecret: new Uint8Array(0) };
+}
+
+export const SpentTokenOutputMetadata: MessageFns<SpentTokenOutputMetadata> = {
+  encode(message: SpentTokenOutputMetadata, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.outputId !== "") {
+      writer.uint32(10).string(message.outputId);
+    }
+    if (message.revocationSecret.length !== 0) {
+      writer.uint32(18).bytes(message.revocationSecret);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): SpentTokenOutputMetadata {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseSpentTokenOutputMetadata();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.outputId = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.revocationSecret = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): SpentTokenOutputMetadata {
+    return {
+      outputId: isSet(object.outputId) ? globalThis.String(object.outputId) : "",
+      revocationSecret: isSet(object.revocationSecret) ? bytesFromBase64(object.revocationSecret) : new Uint8Array(0),
+    };
+  },
+
+  toJSON(message: SpentTokenOutputMetadata): unknown {
+    const obj: any = {};
+    if (message.outputId !== "") {
+      obj.outputId = message.outputId;
+    }
+    if (message.revocationSecret.length !== 0) {
+      obj.revocationSecret = base64FromBytes(message.revocationSecret);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<SpentTokenOutputMetadata>): SpentTokenOutputMetadata {
+    return SpentTokenOutputMetadata.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<SpentTokenOutputMetadata>): SpentTokenOutputMetadata {
+    const message = createBaseSpentTokenOutputMetadata();
+    message.outputId = object.outputId ?? "";
+    message.revocationSecret = object.revocationSecret ?? new Uint8Array(0);
+    return message;
+  },
+};
+
+function createBaseTokenTransactionConfirmationMetadata(): TokenTransactionConfirmationMetadata {
+  return { spentTokenOutputsMetadata: [] };
+}
+
+export const TokenTransactionConfirmationMetadata: MessageFns<TokenTransactionConfirmationMetadata> = {
+  encode(message: TokenTransactionConfirmationMetadata, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    for (const v of message.spentTokenOutputsMetadata) {
+      SpentTokenOutputMetadata.encode(v!, writer.uint32(10).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TokenTransactionConfirmationMetadata {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTokenTransactionConfirmationMetadata();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.spentTokenOutputsMetadata.push(SpentTokenOutputMetadata.decode(reader, reader.uint32()));
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TokenTransactionConfirmationMetadata {
+    return {
+      spentTokenOutputsMetadata: globalThis.Array.isArray(object?.spentTokenOutputsMetadata)
+        ? object.spentTokenOutputsMetadata.map((e: any) => SpentTokenOutputMetadata.fromJSON(e))
+        : [],
+    };
+  },
+
+  toJSON(message: TokenTransactionConfirmationMetadata): unknown {
+    const obj: any = {};
+    if (message.spentTokenOutputsMetadata?.length) {
+      obj.spentTokenOutputsMetadata = message.spentTokenOutputsMetadata.map((e) => SpentTokenOutputMetadata.toJSON(e));
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<TokenTransactionConfirmationMetadata>): TokenTransactionConfirmationMetadata {
+    return TokenTransactionConfirmationMetadata.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<TokenTransactionConfirmationMetadata>): TokenTransactionConfirmationMetadata {
+    const message = createBaseTokenTransactionConfirmationMetadata();
+    message.spentTokenOutputsMetadata =
+      object.spentTokenOutputsMetadata?.map((e) => SpentTokenOutputMetadata.fromPartial(e)) || [];
+    return message;
+  },
+};
+
+function createBaseTokenTransactionWithStatus(): TokenTransactionWithStatus {
+  return { tokenTransaction: undefined, status: 0, confirmationMetadata: undefined };
+}
+
+export const TokenTransactionWithStatus: MessageFns<TokenTransactionWithStatus> = {
+  encode(message: TokenTransactionWithStatus, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.tokenTransaction !== undefined) {
+      TokenTransaction.encode(message.tokenTransaction, writer.uint32(10).fork()).join();
+    }
+    if (message.status !== 0) {
+      writer.uint32(16).int32(message.status);
+    }
+    if (message.confirmationMetadata !== undefined) {
+      TokenTransactionConfirmationMetadata.encode(message.confirmationMetadata, writer.uint32(26).fork()).join();
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TokenTransactionWithStatus {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTokenTransactionWithStatus();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.tokenTransaction = TokenTransaction.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 16) {
+            break;
+          }
+
+          message.status = reader.int32() as any;
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.confirmationMetadata = TokenTransactionConfirmationMetadata.decode(reader, reader.uint32());
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TokenTransactionWithStatus {
+    return {
+      tokenTransaction: isSet(object.tokenTransaction) ? TokenTransaction.fromJSON(object.tokenTransaction) : undefined,
+      status: isSet(object.status) ? tokenTransactionStatusFromJSON(object.status) : 0,
+      confirmationMetadata: isSet(object.confirmationMetadata)
+        ? TokenTransactionConfirmationMetadata.fromJSON(object.confirmationMetadata)
+        : undefined,
+    };
+  },
+
+  toJSON(message: TokenTransactionWithStatus): unknown {
+    const obj: any = {};
+    if (message.tokenTransaction !== undefined) {
+      obj.tokenTransaction = TokenTransaction.toJSON(message.tokenTransaction);
+    }
+    if (message.status !== 0) {
+      obj.status = tokenTransactionStatusToJSON(message.status);
+    }
+    if (message.confirmationMetadata !== undefined) {
+      obj.confirmationMetadata = TokenTransactionConfirmationMetadata.toJSON(message.confirmationMetadata);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<TokenTransactionWithStatus>): TokenTransactionWithStatus {
+    return TokenTransactionWithStatus.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<TokenTransactionWithStatus>): TokenTransactionWithStatus {
+    const message = createBaseTokenTransactionWithStatus();
+    message.tokenTransaction = (object.tokenTransaction !== undefined && object.tokenTransaction !== null)
+      ? TokenTransaction.fromPartial(object.tokenTransaction)
+      : undefined;
+    message.status = object.status ?? 0;
+    message.confirmationMetadata = (object.confirmationMetadata !== undefined && object.confirmationMetadata !== null)
+      ? TokenTransactionConfirmationMetadata.fromPartial(object.confirmationMetadata)
+      : undefined;
+    return message;
+  },
+};
+
+export type SparkTokenServiceDefinition = typeof SparkTokenServiceDefinition;
+export const SparkTokenServiceDefinition = {
+  name: "SparkTokenService",
+  fullName: "spark_token.SparkTokenService",
+  methods: {
+    /**
+     * Start process to create final token transaction with all inputs required
+     * from user and SOs (including revocation secret commitment)
+     */
+    start_transaction: {
+      name: "start_transaction",
+      requestType: StartTransactionRequest,
+      requestStream: false,
+      responseType: StartTransactionResponse,
+      responseStream: false,
+      options: {},
+    },
+    /**
+     * Complete the transaction and commit it with all SOs. This will be
+     * coordinated by one SO.
+     */
+    commit_transaction: {
+      name: "commit_transaction",
+      requestType: CommitTransactionRequest,
+      requestStream: false,
+      responseType: CommitTransactionResponse,
+      responseStream: false,
+      options: {},
+    },
+    query_token_metadata: {
+      name: "query_token_metadata",
+      requestType: QueryTokenMetadataRequest,
+      requestStream: false,
+      responseType: QueryTokenMetadataResponse,
+      responseStream: false,
+      options: {},
+    },
+    query_token_transactions: {
+      name: "query_token_transactions",
+      requestType: QueryTokenTransactionsRequest,
+      requestStream: false,
+      responseType: QueryTokenTransactionsResponse,
+      responseStream: false,
+      options: {},
+    },
+    query_token_outputs: {
+      name: "query_token_outputs",
+      requestType: QueryTokenOutputsRequest,
+      requestStream: false,
+      responseType: QueryTokenOutputsResponse,
+      responseStream: false,
+      options: {},
+    },
+  },
+} as const;
+
+export interface SparkTokenServiceImplementation<CallContextExt = {}> {
+  /**
+   * Start process to create final token transaction with all inputs required
+   * from user and SOs (including revocation secret commitment)
+   */
+  start_transaction(
+    request: StartTransactionRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<StartTransactionResponse>>;
+  /**
+   * Complete the transaction and commit it with all SOs. This will be
+   * coordinated by one SO.
+   */
+  commit_transaction(
+    request: CommitTransactionRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<CommitTransactionResponse>>;
+  query_token_metadata(
+    request: QueryTokenMetadataRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<QueryTokenMetadataResponse>>;
+  query_token_transactions(
+    request: QueryTokenTransactionsRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<QueryTokenTransactionsResponse>>;
+  query_token_outputs(
+    request: QueryTokenOutputsRequest,
+    context: CallContext & CallContextExt,
+  ): Promise<DeepPartial<QueryTokenOutputsResponse>>;
+}
+
+export interface SparkTokenServiceClient<CallOptionsExt = {}> {
+  /**
+   * Start process to create final token transaction with all inputs required
+   * from user and SOs (including revocation secret commitment)
+   */
+  start_transaction(
+    request: DeepPartial<StartTransactionRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<StartTransactionResponse>;
+  /**
+   * Complete the transaction and commit it with all SOs. This will be
+   * coordinated by one SO.
    */
   commit_transaction(
     request: DeepPartial<CommitTransactionRequest>,
     options?: CallOptions & CallOptionsExt,
   ): Promise<CommitTransactionResponse>;
+  query_token_metadata(
+    request: DeepPartial<QueryTokenMetadataRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<QueryTokenMetadataResponse>;
+  query_token_transactions(
+    request: DeepPartial<QueryTokenTransactionsRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<QueryTokenTransactionsResponse>;
+  query_token_outputs(
+    request: DeepPartial<QueryTokenOutputsRequest>,
+    options?: CallOptions & CallOptionsExt,
+  ): Promise<QueryTokenOutputsResponse>;
 }
 
 function bytesFromBase64(b64: string): Uint8Array {