@buildonspark/spark-sdk 0.1.44 → 0.1.46

package/src/services/token-transactions.ts

@@ -9,6 +9,8 @@ import {
   SignTokenTransactionResponse,
   OperatorSpecificOwnerSignature,
   RevocationSecretWithIndex,
+  TokenTransactionWithStatus as TokenTransactionWithStatusV0,
+  QueryTokenTransactionsRequest as QueryTokenTransactionsRequestV0,
 } from "../proto/spark.js";
 import { secp256k1 } from "@noble/curves/secp256k1";
 import { SparkCallOptions } from "../types/grpc.js";
@@ -21,7 +23,10 @@ import {
   calculateAvailableTokenAmount,
   checkIfSelectedOutputsAreAvailable,
 } from "../utils/token-transactions.js";
-import { validateTokenTransaction } from "../utils/token-transaction-validation.js";
+import {
+  validateTokenTransactionV0,
+  validateTokenTransaction,
+} from "../utils/token-transaction-validation.js";
 import { WalletConfigService } from "./config.js";
 import { ConnectionManager } from "./connection.js";
 import {
@@ -36,6 +41,8 @@ import {
   TokenTransaction,
   SignatureWithIndex,
   InputTtxoSignaturesPerOperator,
+  QueryTokenTransactionsRequest as QueryTokenTransactionsRequestV1,
+  TokenTransactionWithStatus as TokenTransactionWithStatusV1,
 } from "../proto/spark_token.js";
 import { TokenTransaction as TokenTransactionV0 } from "../proto/spark.js";
 import { collectResponses } from "../utils/response-validation.js";
@@ -46,6 +53,20 @@ import {
 
 const MAX_TOKEN_OUTPUTS = 500;
 
+export interface FetchOwnedTokenOutputsParams {
+  ownerPublicKeys: Uint8Array[];
+  issuerPublicKeys?: Uint8Array[];
+  tokenIdentifiers?: Uint8Array[];
+}
+
+export interface QueryTokenTransactionsParams {
+  ownerPublicKeys?: string[];
+  issuerPublicKeys?: string[];
+  tokenTransactionHashes?: string[];
+  tokenIdentifiers?: string[];
+  outputIds?: string[];
+}
+
 export class TokenTransactionService {
   protected readonly config: WalletConfigService;
   protected readonly connectionManager: ConnectionManager;
@@ -272,6 +293,7 @@ export class TokenTransactionService {
       tokenOutputs,
       sparkOperatorIdentityPublicKeys: this.collectOperatorIdentityPublicKeys(),
       expiryTime: undefined,
+      clientCreatedTimestamp: new Date(),
     };
   }
 
@@ -548,7 +570,7 @@ export class TokenTransactionService {
       throw new Error("Keyshare info missing in start response");
     }
 
-    validateTokenTransaction(
+    validateTokenTransactionV0(
       startResponse.finalTokenTransaction,
       tokenTransaction,
       signingOperators,
@@ -867,9 +889,34 @@ export class TokenTransactionService {
   }
 
   public async fetchOwnedTokenOutputs(
-    ownerPublicKeys: Uint8Array[],
-    tokenPublicKeys: Uint8Array[],
+    params: FetchOwnedTokenOutputsParams,
   ): Promise<OutputWithPreviousTransactionData[]> {
+    if (this.config.getTokenTransactionVersion() === "V0") {
+      return this.fetchOwnedTokenOutputsV0(params);
+    } else {
+      return this.fetchOwnedTokenOutputsV1(params);
+    }
+  }
+
+  public async queryTokenTransactions(
+    params: QueryTokenTransactionsParams,
+  ): Promise<TokenTransactionWithStatusV0[] | TokenTransactionWithStatusV1[]> {
+    if (this.config.getTokenTransactionVersion() === "V0") {
+      return this.queryTokenTransactionsV0(params);
+    } else {
+      return this.queryTokenTransactionsV1(params);
+    }
+  }
+
+  private async fetchOwnedTokenOutputsV0(
+    params: FetchOwnedTokenOutputsParams,
+  ): Promise<OutputWithPreviousTransactionData[]> {
+    const {
+      ownerPublicKeys,
+      issuerPublicKeys: tokenPublicKeys = [],
+      tokenIdentifiers = [],
+    } = params;
+
     const sparkClient = await this.connectionManager.createSparkClient(
       this.config.getCoordinatorAddress(),
     );
@@ -878,6 +925,42 @@ export class TokenTransactionService {
       const result = await sparkClient.query_token_outputs({
         ownerPublicKeys,
         tokenPublicKeys,
+        tokenIdentifiers,
+        network: this.config.getNetworkProto(),
+      });
+
+      return result.outputsWithPreviousTransactionData;
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to fetch owned token outputs",
+        {
+          operation: "spark.query_token_outputs",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error),
+        },
+        error as Error,
+      );
+    }
+  }
+
+  private async fetchOwnedTokenOutputsV1(
+    params: FetchOwnedTokenOutputsParams,
+  ): Promise<OutputWithPreviousTransactionData[]> {
+    const {
+      ownerPublicKeys,
+      issuerPublicKeys = [],
+      tokenIdentifiers = [],
+    } = params;
+
+    const tokenClient = await this.connectionManager.createSparkTokenClient(
+      this.config.getCoordinatorAddress(),
+    );
+
+    try {
+      const result = await tokenClient.query_token_outputs({
+        ownerPublicKeys,
+        issuerPublicKeys,
+        tokenIdentifiers,
         network: this.config.getNetworkProto(),
       });
 
@@ -886,7 +969,113 @@ export class TokenTransactionService {
       throw new NetworkError(
         "Failed to fetch owned token outputs",
         {
-          operation: "query_token_outputs",
+          operation: "spark_token.query_token_outputs",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error),
+        },
+        error as Error,
+      );
+    }
+  }
+
+  private async queryTokenTransactionsV0(
+    params: QueryTokenTransactionsParams,
+  ): Promise<TokenTransactionWithStatusV1[]> {
+    const {
+      ownerPublicKeys,
+      issuerPublicKeys,
+      tokenTransactionHashes,
+      tokenIdentifiers,
+      outputIds,
+    } = params;
+
+    const sparkClient = await this.connectionManager.createSparkClient(
+      this.config.getCoordinatorAddress(),
+    );
+
+    let queryParams: QueryTokenTransactionsRequestV0 = {
+      tokenPublicKeys: issuerPublicKeys?.map(hexToBytes)!,
+      ownerPublicKeys: ownerPublicKeys?.map(hexToBytes)!,
+      tokenIdentifiers: tokenIdentifiers?.map(hexToBytes)!,
+      tokenTransactionHashes: tokenTransactionHashes?.map(hexToBytes)!,
+      outputIds: outputIds || [],
+      limit: 100,
+      offset: 0,
+    };
+
+    try {
+      const response = await sparkClient.query_token_transactions(queryParams);
+      return response.tokenTransactionsWithStatus.map((tx) => {
+        // Convert V0 structure to V1 structure
+        const v1TokenTransaction: TokenTransaction = {
+          version: 1,
+          network: tx.tokenTransaction!.network,
+          tokenInputs: tx.tokenTransaction!.tokenInputs,
+          tokenOutputs: tx.tokenTransaction!.tokenOutputs!,
+          sparkOperatorIdentityPublicKeys:
+            tx.tokenTransaction!.sparkOperatorIdentityPublicKeys!,
+          expiryTime: undefined, // V0 doesn't have expiry time
+          clientCreatedTimestamp:
+            tx.tokenTransaction?.tokenInputs?.$case === "mintInput"
+              ? new Date(
+                  tx.tokenTransaction.tokenInputs.mintInput
+                    .issuerProvidedTimestamp * 1000,
+                )
+              : new Date(),
+        };
+
+        return {
+          tokenTransaction: v1TokenTransaction,
+          status: tx.status,
+          confirmationMetadata: tx.confirmationMetadata,
+        };
+      });
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to query token transactions",
+        {
+          operation: "spark.query_token_transactions",
+          errorCount: 1,
+          errors: error instanceof Error ? error.message : String(error),
+        },
+        error as Error,
+      );
+    }
+  }
+
+  private async queryTokenTransactionsV1(
+    params: QueryTokenTransactionsParams,
+  ): Promise<TokenTransactionWithStatusV1[]> {
+    const {
+      ownerPublicKeys,
+      issuerPublicKeys,
+      tokenTransactionHashes,
+      tokenIdentifiers,
+      outputIds,
+    } = params;
+
+    const tokenClient = await this.connectionManager.createSparkTokenClient(
+      this.config.getCoordinatorAddress(),
+    );
+
+    let queryParams: QueryTokenTransactionsRequestV1 = {
+      issuerPublicKeys: issuerPublicKeys?.map(hexToBytes)!,
+      ownerPublicKeys: ownerPublicKeys?.map(hexToBytes)!,
+      tokenIdentifiers: tokenIdentifiers?.map(hexToBytes)!,
+      tokenTransactionHashes: tokenTransactionHashes?.map(hexToBytes)!,
+      outputIds: outputIds || [],
+      limit: 100,
+      offset: 0,
+    };
+
+    try {
+      const response = await tokenClient.query_token_transactions(queryParams);
+      return response.tokenTransactionsWithStatus;
+    } catch (error) {
+      throw new NetworkError(
+        "Failed to query token transactions",
+        {
+          operation: "spark_token.query_token_transactions",
           errorCount: 1,
           errors: error instanceof Error ? error.message : String(error),
         },
@@ -898,10 +1087,9 @@ export class TokenTransactionService {
   public async syncTokenOutputs(
     tokenOutputs: Map<string, OutputWithPreviousTransactionData[]>,
   ) {
-    const unsortedTokenOutputs = await this.fetchOwnedTokenOutputs(
-      await this.config.signer.getTrackedPublicKeys(),
-      [],
-    );
+    const unsortedTokenOutputs = await this.fetchOwnedTokenOutputs({
+      ownerPublicKeys: await this.config.signer.getTrackedPublicKeys(),
+    });
 
     unsortedTokenOutputs.forEach((output) => {
       const tokenKey = bytesToHex(output.output!.tokenPublicKey!);

package/src/services/transfer.ts

@@ -295,6 +295,9 @@ export class BaseTransferService {
       leavesToSend: leafSigningJobs,
       keyTweakPackage: encryptedKeyTweaks,
       userSignature: new Uint8Array(),
+      // TODO: Add direct refund signature
+      directLeavesToSend: [],
+      directFromCpfpLeavesToSend: [],
     };
 
     const transferPackageSigningPayload = getTransferPackageSigningPayload(
@@ -426,6 +429,10 @@ export class BaseTransferService {
         nodeId: operatorSigningResult.leafId,
         refundTxSignature: refundAggregate,
         nodeTxSignature: new Uint8Array(),
+        // TODO: Add direct refund signature
+        directNodeTxSignature: new Uint8Array(),
+        directRefundTxSignature: new Uint8Array(),
+        directFromCpfpRefundTxSignature: new Uint8Array(),
       });
     }
     return nodeSignatures;
@@ -532,6 +539,9 @@ export class BaseTransferService {
         secretCipher,
         signature,
         refundSignature: refundSignature ?? new Uint8Array(),
+        // TODO: Add direct refund signature
+        directRefundSignature: new Uint8Array(),
+        directFromCpfpRefundSignature: new Uint8Array(),
       });
     }
 
@@ -930,6 +940,10 @@ export class TransferService extends BaseTransferService {
           rawTx: refundTx.toBytes(),
           signingNonceCommitment: refundNonceCommitmentProto,
         },
+        // TODO: Add direct refund signature
+        directRefundTxSigningJob: undefined,
+        // TODO: Add direct refund signature
+        directFromCpfpRefundTxSigningJob: undefined,
       });
     }
 
@@ -1397,6 +1411,10 @@ export class TransferService extends BaseTransferService {
           nodeId: nodeId,
           nodeTxSignature: signature,
           refundTxSignature: new Uint8Array(),
+          // TODO: Add direct refund signature
+          directNodeTxSignature: new Uint8Array(),
+          directRefundTxSignature: new Uint8Array(),
+          directFromCpfpRefundTxSignature: new Uint8Array(),
         });
       } else if (i === nodes.length) {
         refundSignature = signature;
@@ -1414,6 +1432,10 @@ export class TransferService extends BaseTransferService {
       nodeId: leafNodeId,
       nodeTxSignature: leafSignature,
       refundTxSignature: refundSignature,
+      // TODO: Add direct refund signature
+      directNodeTxSignature: new Uint8Array(),
+      directRefundTxSignature: new Uint8Array(),
+      directFromCpfpRefundTxSignature: new Uint8Array(),
     });
 
     const result = await sparkClient.finalize_node_signatures({

package/src/services/tree-creation.ts

@@ -315,6 +315,9 @@ export class TreeCreationService {
       nodeTxSigningJob: undefined,
       refundTxSigningJob: undefined,
       children: [],
+      directNodeTxSigningJob: undefined,
+      directRefundTxSigningJob: undefined,
+      directFromCpfpRefundTxSigningJob: undefined,
     };
 
     const tx = new Transaction({ version: 3 });
@@ -353,6 +356,9 @@ export class TreeCreationService {
       nodeTxSigningJob: undefined,
       refundTxSigningJob: undefined,
       children: [],
+      directNodeTxSigningJob: undefined,
+      directRefundTxSigningJob: undefined,
+      directFromCpfpRefundTxSigningJob: undefined,
     };
 
     const childTx = new Transaction({ version: 3 });
@@ -464,6 +470,9 @@ export class TreeCreationService {
       nodeTxSigningJob: rootNodeSigningJob,
       refundTxSigningJob: undefined,
       children: [],
+      directNodeTxSigningJob: undefined,
+      directRefundTxSigningJob: undefined,
+      directFromCpfpRefundTxSigningJob: undefined,
     };
     rootCreationNode.nodeTxSigningCommitment = rootNodeSigningCommitment;
 
@@ -584,6 +593,10 @@ export class TreeCreationService {
         nodeId: creationResponseNode.nodeId,
         nodeTxSignature: nodeTxSignature,
         refundTxSignature: refundTxSignature,
+        // TODO: Add direct refund signature
+        directNodeTxSignature: new Uint8Array(),
+        directRefundTxSignature: new Uint8Array(),
+        directFromCpfpRefundTxSignature: new Uint8Array(),
       },
     };
   }

package/src/services/wallet-config.ts

@@ -166,7 +166,7 @@ function getLocalFrostSignerAddress(): string {
   return isHermeticTest() ? "localhost:9999" : "unix:///tmp/frost_0.sock";
 }
 
-const BASE_CONFIG: Required<ConfigOptions> = {
+export const BASE_CONFIG: Required<ConfigOptions> = {
   network: "LOCAL",
   lrc20Address: getLrc20Url("LOCAL"),
   coodinatorIdentifier:
@@ -175,7 +175,7 @@ const BASE_CONFIG: Required<ConfigOptions> = {
   threshold: 2,
   signingOperators: getLocalSigningOperators(),
   tokenSignatures: "SCHNORR",
-  tokenTransactionVersion: "V0",
+  tokenTransactionVersion: "V1",
   tokenValidityDurationSeconds: 180,
   electrsUrl: getElectrsUrl("LOCAL"),
   expectedWithdrawBondSats: 10000,

package/src/spark-wallet/spark-wallet.node.ts

@@ -66,10 +66,6 @@ export class SparkWallet extends BaseSparkWallet {
       "SparkWallet.getTransfers",
       this.getTransfers.bind(this),
     );
-    this.getTokenInfo = this.wrapWithOtelSpan(
-      "SparkWallet.getTokenInfo",
-      this.getTokenInfo.bind(this),
-    );
     this.getBalance = this.wrapWithOtelSpan(
       "SparkWallet.getBalance",
       this.getBalance.bind(this),