@buildonspark/spark-sdk 0.1.47 → 0.2.0

package/src/services/deposit.ts

@@ -12,6 +12,7 @@ import {
   GenerateDepositAddressResponse,
   StartDepositTreeCreationResponse,
 } from "../proto/spark.js";
+import { KeyDerivation } from "../signer/types.js";
 import {
   getP2TRAddressFromPublicKey,
   getSigHashFromTx,
@@ -20,10 +21,7 @@ import {
 import { subtractPublicKeys } from "../utils/keys.js";
 import { getNetwork } from "../utils/network.js";
 import { proofOfPossessionMessageHashForDepositAddress } from "../utils/proof.js";
-import {
-  DEFAULT_FEE_SATS,
-  getEphemeralAnchorOutput,
-} from "../utils/transaction.js";
+import { getEphemeralAnchorOutput } from "../utils/transaction.js";
 import { WalletConfigService } from "./config.js";
 import { ConnectionManager } from "./connection.js";
 
@@ -39,7 +37,7 @@ export type GenerateDepositAddressParams = {
 };
 
 export type CreateTreeRootParams = {
-  signingPubKey: Uint8Array;
+  keyDerivation: KeyDerivation;
   verifyingKey: Uint8Array;
   depositTx: Transaction;
   vout: number;
@@ -182,7 +180,7 @@ export class DepositService {
   }
 
   async createTreeRoot({
-    signingPubKey,
+    keyDerivation,
     verifyingKey,
     depositTx,
     vout,
@@ -242,6 +240,9 @@ export class DepositService {
       sequence,
     });
 
+    const signingPubKey =
+      await this.config.signer.getPublicKeyFromDerivation(keyDerivation);
+
     const refundP2trAddress = getP2TRAddressFromPublicKey(
       signingPubKey,
       this.config.getNetwork(),
@@ -346,7 +347,7 @@ export class DepositService {
     const rootSignature = await this.config.signer.signFrost({
       message: rootTxSighash,
       publicKey: signingPubKey,
-      privateAsPubKey: signingPubKey,
+      keyDerivation,
       verifyingKey,
       selfCommitment: rootNonceCommitment,
       statechainCommitments:
@@ -358,7 +359,7 @@ export class DepositService {
     const refundSignature = await this.config.signer.signFrost({
       message: refundTxSighash,
       publicKey: signingPubKey,
-      privateAsPubKey: signingPubKey,
+      keyDerivation,
       verifyingKey,
       selfCommitment: refundNonceCommitment,
       statechainCommitments:

package/src/services/lightning.ts

@@ -236,7 +236,9 @@ export class LightningService {
         );
       }
 
-      amountSats = isZeroAmountInvoice ? amountSatsToSend! : amountMsats / 1000;
+      amountSats = isZeroAmountInvoice
+        ? amountSatsToSend!
+        : Math.ceil(amountMsats / 1000);
 
       if (isNaN(amountSats) || amountSats <= 0) {
         throw new ValidationError("Invalid amount", {

package/src/services/signing.ts

@@ -1,12 +1,10 @@
-import { TransactionInput } from "@scure/btc-signer/psbt";
 import { hexToBytes } from "@noble/curves/abstract/utils";
+import { TransactionInput } from "@scure/btc-signer/psbt";
 import { ValidationError } from "../errors/types.js";
 import {
   RequestedSigningCommitments,
   UserSignedTxSigningJob,
 } from "../proto/spark.js";
-import type { LeafKeyTweak } from "./transfer.js";
-import { WalletConfigService } from "./config.js";
 import {
   getSigHashFromTx,
   getTxFromRawTxBytes,
@@ -16,6 +14,8 @@ import {
   createRefundTx,
   getNextTransactionSequence,
 } from "../utils/transaction.js";
+import { WalletConfigService } from "./config.js";
+import type { LeafKeyTweak } from "./transfer.js";
 
 export class SigningService {
   private readonly config: WalletConfigService;
@@ -83,8 +83,10 @@ export class SigningService {
       }
       const signingResult = await this.config.signer.signFrost({
         message: sighash,
-        publicKey: leaf.signingPubKey,
-        privateAsPubKey: leaf.signingPubKey,
+        keyDerivation: leaf.keyDerivation,
+        publicKey: await this.config.signer.getPublicKeyFromDerivation(
+          leaf.keyDerivation,
+        ),
         selfCommitment: signingCommitment,
         statechainCommitments: signingNonceCommitments,
         adaptorPubKey: new Uint8Array(),
@@ -93,7 +95,9 @@ export class SigningService {
 
       leafSigningJobs.push({
         leafId: leaf.leaf.id,
-        signingPublicKey: leaf.signingPubKey,
+        signingPublicKey: await this.config.signer.getPublicKeyFromDerivation(
+          leaf.keyDerivation,
+        ),
         rawTx: refundTx.toBytes(),
         signingNonceCommitment: signingCommitment,
         userSignature: signingResult,

package/src/services/token-transactions.ts

@@ -3,53 +3,59 @@ import {
   bytesToNumberBE,
   numberToBytesBE,
 } from "@noble/curves/abstract/utils";
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { hexToBytes } from "@noble/hashes/utils";
+import {
+  InternalValidationError,
+  NetworkError,
+  ValidationError,
+} from "../errors/types.js";
 import {
-  OutputWithPreviousTransactionData,
-  OperatorSpecificTokenTransactionSignablePayload,
-  SignTokenTransactionResponse,
   OperatorSpecificOwnerSignature,
+  OperatorSpecificTokenTransactionSignablePayload,
+  OutputWithPreviousTransactionData,
+  QueryTokenTransactionsRequest as QueryTokenTransactionsRequestV0,
   RevocationSecretWithIndex,
+  SignTokenTransactionResponse,
+  TokenTransaction as TokenTransactionV0,
   TokenTransactionWithStatus as TokenTransactionWithStatusV0,
-  QueryTokenTransactionsRequest as QueryTokenTransactionsRequestV0,
 } from "../proto/spark.js";
-import { secp256k1 } from "@noble/curves/secp256k1";
+import {
+  InputTtxoSignaturesPerOperator,
+  QueryTokenTransactionsRequest as QueryTokenTransactionsRequestV1,
+  SignatureWithIndex,
+  TokenOutput,
+  TokenTransaction,
+  TokenTransactionWithStatus as TokenTransactionWithStatusV1,
+} from "../proto/spark_token.js";
+import { TokenOutputsMap } from "../spark-wallet/types.js";
 import { SparkCallOptions } from "../types/grpc.js";
+import { decodeSparkAddress } from "../utils/address.js";
+import { collectResponses } from "../utils/response-validation.js";
 import {
   hashOperatorSpecificTokenTransactionSignablePayload,
-  hashTokenTransactionV0,
   hashTokenTransaction,
+  hashTokenTransactionV0,
 } from "../utils/token-hashing.js";
 import {
-  sumAvailableTokens,
-  checkIfSelectedOutputsAreAvailable,
-} from "../utils/token-transactions.js";
+  Bech32mTokenIdentifier,
+  decodeBech32mTokenIdentifier,
+} from "../utils/token-identifier.js";
+import {
+  KeyshareWithOperatorIndex,
+  recoverRevocationSecretFromKeyshares,
+} from "../utils/token-keyshares.js";
 import {
-  validateTokenTransactionV0,
   validateTokenTransaction,
+  validateTokenTransactionV0,
 } from "../utils/token-transaction-validation.js";
+import {
+  checkIfSelectedOutputsAreAvailable,
+  sumAvailableTokens,
+} from "../utils/token-transactions.js";
 import { WalletConfigService } from "./config.js";
 import { ConnectionManager } from "./connection.js";
-import {
-  ValidationError,
-  NetworkError,
-  InternalValidationError,
-} from "../errors/types.js";
 import { SigningOperator } from "./wallet-config.js";
-import { hexToBytes } from "@noble/hashes/utils";
-import { decodeSparkAddress } from "../utils/address.js";
-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";
-import {
-  KeyshareWithOperatorIndex,
-  recoverRevocationSecretFromKeyshares,
-} from "../utils/token-keyshares.js";
 
 const MAX_TOKEN_OUTPUTS = 500;
 
@@ -80,16 +86,16 @@ export class TokenTransactionService {
   }
 
   public async tokenTransfer(
-    tokenOutputs: Map<string, OutputWithPreviousTransactionData[]>,
+    tokenOutputs: TokenOutputsMap,
     receiverOutputs: {
-      tokenPublicKey: string;
+      tokenIdentifier: Bech32mTokenIdentifier;
       tokenAmount: bigint;
       receiverSparkAddress: string;
     }[],
     outputSelectionStrategy: "SMALL_FIRST" | "LARGE_FIRST" = "SMALL_FIRST",
     selectedOutputs?: OutputWithPreviousTransactionData[],
   ): Promise<string> {
-    if (receiverOutputs.length === 0) {
+    if (!Array.isArray(receiverOutputs) || receiverOutputs.length === 0) {
       throw new ValidationError("No receiver outputs provided", {
         field: "receiverOutputs",
         value: receiverOutputs,
@@ -101,9 +107,11 @@ export class TokenTransactionService {
       (sum, transfer) => sum + transfer.tokenAmount,
       0n,
     );
-
     let outputsToUse: OutputWithPreviousTransactionData[];
 
+    const tokenIdentifier: Bech32mTokenIdentifier =
+      receiverOutputs[0]!!.tokenIdentifier;
+
     if (selectedOutputs) {
       outputsToUse = selectedOutputs;
 
@@ -111,7 +119,7 @@ export class TokenTransactionService {
         !checkIfSelectedOutputsAreAvailable(
           outputsToUse,
           tokenOutputs,
-          hexToBytes(receiverOutputs[0]!!.tokenPublicKey),
+          tokenIdentifier,
         )
       ) {
         throw new ValidationError(
@@ -125,16 +133,14 @@ export class TokenTransactionService {
       }
     } else {
       outputsToUse = this.selectTokenOutputs(
-        tokenOutputs.get(receiverOutputs[0]!!.tokenPublicKey)!!,
+        tokenOutputs.get(tokenIdentifier)!!,
         totalTokenAmount,
         outputSelectionStrategy,
       );
     }
 
     if (outputsToUse.length > MAX_TOKEN_OUTPUTS) {
-      const availableOutputs = tokenOutputs.get(
-        receiverOutputs[0]!!.tokenPublicKey,
-      )!!;
+      const availableOutputs = tokenOutputs.get(tokenIdentifier)!!;
 
       // Sort outputs by the same strategy as in selectTokenOutputs
       const sortedOutputs = [...availableOutputs];
@@ -154,6 +160,23 @@ export class TokenTransactionService {
       );
     }
 
+    const rawTokenIdentifier: Uint8Array = decodeBech32mTokenIdentifier(
+      tokenIdentifier,
+      this.config.getNetworkType(),
+    ).tokenIdentifier;
+
+    // remove for full v0 deprecation
+    let tokenPublicKey: Uint8Array;
+    if (this.config.getTokenTransactionVersion() === "V0") {
+      const tokenClient = await this.connectionManager.createSparkTokenClient(
+        this.config.getCoordinatorAddress(),
+      );
+      const tokenMetadata = await tokenClient.query_token_metadata({
+        tokenIdentifiers: [rawTokenIdentifier],
+      });
+      tokenPublicKey = tokenMetadata.tokenMetadata[0]!.issuerPublicKey;
+    }
+
     const tokenOutputData = receiverOutputs.map((transfer) => {
       const receiverAddress = decodeSparkAddress(
         transfer.receiverSparkAddress,
@@ -161,7 +184,8 @@ export class TokenTransactionService {
       );
       return {
         receiverSparkAddress: hexToBytes(receiverAddress.identityPublicKey),
-        tokenPublicKey: hexToBytes(transfer.tokenPublicKey),
+        rawTokenIdentifier,
+        tokenPublicKey, // Remove for full v0 deprecation
         tokenAmount: transfer.tokenAmount,
       };
     });
@@ -169,6 +193,7 @@ export class TokenTransactionService {
     let tokenTransaction: TokenTransactionV0 | TokenTransaction;
 
     if (this.config.getTokenTransactionVersion() === "V0") {
+      // remove for full v0 deprecation
       tokenTransaction = await this.constructTransferTokenTransactionV0(
         outputsToUse,
         tokenOutputData,
@@ -179,7 +204,6 @@ export class TokenTransactionService {
         tokenOutputData,
       );
     }
-
     const txId = await this.broadcastTokenTransaction(
       tokenTransaction,
       outputsToUse.map((output) => output.output!.ownerPublicKey),
@@ -247,7 +271,7 @@ export class TokenTransactionService {
     selectedOutputs: OutputWithPreviousTransactionData[],
     tokenOutputData: Array<{
       receiverSparkAddress: Uint8Array;
-      tokenPublicKey: Uint8Array;
+      rawTokenIdentifier: Uint8Array;
       tokenAmount: bigint;
     }>,
   ): Promise<TokenTransaction> {
@@ -261,19 +285,21 @@ export class TokenTransactionService {
       0n,
     );
 
-    const tokenOutputs = tokenOutputData.map((output) => ({
-      ownerPublicKey: output.receiverSparkAddress,
-      tokenPublicKey: output.tokenPublicKey,
-      tokenAmount: numberToBytesBE(output.tokenAmount, 16),
-    }));
+    const tokenOutputs: TokenOutput[] = tokenOutputData.map(
+      (output): TokenOutput => ({
+        ownerPublicKey: output.receiverSparkAddress,
+        tokenIdentifier: output.rawTokenIdentifier,
+        tokenAmount: numberToBytesBE(output.tokenAmount, 16),
+      }),
+    );
 
     if (availableTokenAmount > totalRequestedAmount) {
       const changeAmount = availableTokenAmount - totalRequestedAmount;
-      const firstTokenPublicKey = tokenOutputData[0]!!.tokenPublicKey;
+      const firstTokenIdentifierBytes = tokenOutputData[0]!!.rawTokenIdentifier;
 
       tokenOutputs.push({
         ownerPublicKey: await this.config.signer.getIdentityPublicKey(),
-        tokenPublicKey: firstTokenPublicKey,
+        tokenIdentifier: firstTokenIdentifierBytes,
         tokenAmount: numberToBytesBE(changeAmount, 16),
       });
     }
@@ -614,19 +640,27 @@ export class TokenTransactionService {
 
     const ownerSignaturesWithIndex: SignatureWithIndex[] = [];
     if (tokenTransaction.tokenInputs!.$case === "mintInput") {
-      const issuerPublicKey =
-        tokenTransaction.tokenInputs!.mintInput.issuerPublicKey;
-      if (!issuerPublicKey) {
+      const tokenIdentifier =
+        tokenTransaction.tokenInputs!.mintInput.tokenIdentifier;
+      if (!tokenIdentifier) {
         throw new ValidationError("Invalid mint input", {
-          field: "issuerPublicKey",
+          field: "tokenIdentifier",
           value: null,
-          expected: "Non-null issuer public key",
+          expected: "Non-null tokenIdentifier",
+        });
+      }
+      const ownerPubkey = tokenTransaction.tokenOutputs[0]!.ownerPublicKey;
+      if (!ownerPubkey) {
+        throw new ValidationError("Invalid mint input", {
+          field: "ownerPubkey",
+          value: null,
+          expected: "Non-null ownerPubkey",
         });
       }
 
       const ownerSignature = await this.signMessageWithKey(
         partialTokenTransactionHash,
-        issuerPublicKey,
+        ownerPubkey,
       );
 
       ownerSignaturesWithIndex.push({
@@ -1028,6 +1062,7 @@ export class TokenTransactionService {
           tokenTransaction: v1TokenTransaction,
           status: tx.status,
           confirmationMetadata: tx.confirmationMetadata,
+          tokenTransactionHash: tx.tokenTransactionHash,
         };
       });
     } catch (error) {
@@ -1084,23 +1119,6 @@ export class TokenTransactionService {
     }
   }
 
-  public async syncTokenOutputs(
-    tokenOutputs: Map<string, OutputWithPreviousTransactionData[]>,
-  ) {
-    const unsortedTokenOutputs = await this.fetchOwnedTokenOutputs({
-      ownerPublicKeys: await this.config.signer.getTrackedPublicKeys(),
-    });
-
-    unsortedTokenOutputs.forEach((output) => {
-      const tokenKey = bytesToHex(output.output!.tokenPublicKey!);
-      const index = output.previousTransactionVout!;
-
-      tokenOutputs.set(tokenKey, [
-        { ...output, previousTransactionVout: index },
-      ]);
-    });
-  }
-
   public selectTokenOutputs(
     tokenOutputs: OutputWithPreviousTransactionData[],
     tokenAmount: bigint,
@@ -1187,14 +1205,11 @@ export class TokenTransactionService {
         return await this.config.signer.signMessageWithIdentityKey(message);
       }
     } else {
-      if (tokenSignatures === "SCHNORR") {
-        return await this.config.signer.signSchnorr(message, publicKey);
-      } else {
-        return await this.config.signer.signMessageWithPublicKey(
-          message,
-          publicKey,
-        );
-      }
+      throw new ValidationError("Invalid public key", {
+        field: "publicKey",
+        value: bytesToHex(publicKey),
+        expected: bytesToHex(await this.config.signer.getIdentityPublicKey()),
+      });
     }
   }