@buildonspark/spark-sdk 0.2.1 → 0.2.3

package/dist/index.node.cjs

@@ -1306,6 +1306,7 @@ __export(index_node_exports, {
   TaprootOutputKeysGenerator: () => TaprootOutputKeysGenerator,
   TaprootSparkSigner: () => TaprootSparkSigner,
   TokenTransactionService: () => TokenTransactionService,
+  UnsafeStatelessSparkSigner: () => UnsafeStatelessSparkSigner,
   ValidationError: () => ValidationError,
   WalletConfig: () => WalletConfig,
   addPrivateKeys: () => addPrivateKeys,
@@ -1381,6 +1382,7 @@ __export(index_node_exports, {
 });
 module.exports = __toCommonJS(index_node_exports);
 init_buffer();
+var import_crypto3 = __toESM(require("crypto"), 1);
 
 // src/utils/crypto.ts
 init_buffer();
@@ -1397,9 +1399,6 @@ var setCrypto = (cryptoImplParam) => {
   cryptoImpl = cryptoImplParam;
 };
 
-// src/index.node.ts
-var import_crypto4 = __toESM(require("crypto"), 1);
-
 // src/errors/index.ts
 init_buffer();
 
@@ -15732,14 +15731,6 @@ var SparkServiceDefinition = {
       responseStream: false,
       options: {}
     },
-    create_tree_v2: {
-      name: "create_tree_v2",
-      requestType: CreateTreeRequest,
-      requestStream: false,
-      responseType: CreateTreeResponse,
-      responseStream: false,
-      options: {}
-    },
     get_signing_operator_list: {
       name: "get_signing_operator_list",
       requestType: Empty,
@@ -15906,6 +15897,90 @@ var SparkServiceDefinition = {
       responseType: ExitSingleNodeTreesResponse,
       responseStream: false,
       options: {}
+    },
+    /**
+     * The following endpoints enforce inclusion of Direct Transactions used
+     * for unilateral exits
+     */
+    create_tree_v2: {
+      name: "create_tree_v2",
+      requestType: CreateTreeRequest,
+      requestStream: false,
+      responseType: CreateTreeResponse,
+      responseStream: false,
+      options: {}
+    },
+    cooperative_exit_v2: {
+      name: "cooperative_exit_v2",
+      requestType: CooperativeExitRequest,
+      requestStream: false,
+      responseType: CooperativeExitResponse,
+      responseStream: false,
+      options: {}
+    },
+    extend_leaf_v2: {
+      name: "extend_leaf_v2",
+      requestType: ExtendLeafRequest,
+      requestStream: false,
+      responseType: ExtendLeafResponse,
+      responseStream: false,
+      options: {}
+    },
+    claim_transfer_sign_refunds_v2: {
+      name: "claim_transfer_sign_refunds_v2",
+      requestType: ClaimTransferSignRefundsRequest,
+      requestStream: false,
+      responseType: ClaimTransferSignRefundsResponse,
+      responseStream: false,
+      options: {}
+    },
+    finalize_node_signatures_v2: {
+      name: "finalize_node_signatures_v2",
+      requestType: FinalizeNodeSignaturesRequest,
+      requestStream: false,
+      responseType: FinalizeNodeSignaturesResponse,
+      responseStream: false,
+      options: {}
+    },
+    initiate_preimage_swap_v2: {
+      name: "initiate_preimage_swap_v2",
+      requestType: InitiatePreimageSwapRequest,
+      requestStream: false,
+      responseType: InitiatePreimageSwapResponse,
+      responseStream: false,
+      options: {}
+    },
+    start_leaf_swap_v2: {
+      name: "start_leaf_swap_v2",
+      requestType: StartTransferRequest,
+      requestStream: false,
+      responseType: StartTransferResponse,
+      responseStream: false,
+      options: {}
+    },
+    counter_leaf_swap_v2: {
+      name: "counter_leaf_swap_v2",
+      requestType: CounterLeafSwapRequest,
+      requestStream: false,
+      responseType: CounterLeafSwapResponse,
+      responseStream: false,
+      options: {}
+    },
+    start_transfer_v2: {
+      name: "start_transfer_v2",
+      requestType: StartTransferRequest,
+      requestStream: false,
+      responseType: StartTransferResponse,
+      responseStream: false,
+      options: {}
+    },
+    refresh_timelock_v2: {
+      name: "refresh_timelock_v2",
+      requestType: RefreshTimelockRequest,
+      requestStream: false,
+      responseType: RefreshTimelockResponse,
+      responseStream: false,
+      options: {}
     }
   }
 };
@@ -18857,7 +18932,7 @@ init_buffer();
 var import_core8 = require("@lightsparkdev/core");
 var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
 var isBun = globalThis.Bun !== void 0;
-var packageVersion = true ? "0.2.1" : "unknown";
+var packageVersion = true ? "0.2.3" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
@@ -19189,7 +19264,8 @@ var DefaultSparkSigner = class {
         field: "privateKey"
       });
     }
-    const nonce = this.commitmentToNonceMap.get(selfCommitment);
+    const commitment = selfCommitment.commitment;
+    const nonce = this.commitmentToNonceMap.get(commitment);
     if (!nonce) {
       throw new ValidationError("Nonce not found for commitment", {
         field: "nonce"
@@ -19204,7 +19280,7 @@ var DefaultSparkSigner = class {
       message,
       keyPackage,
       nonce,
-      selfCommitment,
+      selfCommitment: commitment,
       statechainCommitments,
       adaptorPubKey
     });
@@ -19232,7 +19308,7 @@ var DefaultSparkSigner = class {
       statechainPublicKeys,
       verifyingKey,
       statechainCommitments,
-      selfCommitment,
+      selfCommitment: selfCommitment.commitment,
       selfPublicKey: publicKey,
       selfSignature,
       adaptorPubKey
@@ -19283,7 +19359,9 @@ var DefaultSparkSigner = class {
     const nonce = getRandomSigningNonce();
     const commitment = getSigningCommitmentFromNonce(nonce);
     this.commitmentToNonceMap.set(commitment, nonce);
-    return commitment;
+    return {
+      commitment
+    };
   }
   async validateMessageWithIdentityKey(message, signature) {
     if (!this.identityKey?.publicKey) {
@@ -19337,6 +19415,64 @@ var DefaultSparkSigner = class {
     tx.signIdx(privateKey, index);
   }
 };
+var UnsafeStatelessSparkSigner = class extends DefaultSparkSigner {
+  constructor({
+    sparkKeysGenerator
+  } = {}) {
+    super({
+      sparkKeysGenerator
+    });
+  }
+  async getRandomSigningCommitment() {
+    const nonce = getRandomSigningNonce();
+    const commitment = getSigningCommitmentFromNonce(nonce);
+    return {
+      commitment,
+      nonce
+    };
+  }
+  async signFrost({
+    message,
+    keyDerivation,
+    publicKey,
+    verifyingKey,
+    selfCommitment,
+    statechainCommitments,
+    adaptorPubKey
+  }) {
+    const SparkFrost = await getSparkFrostModule();
+    if (!SparkFrost) {
+      throw new ValidationError("SparkFrost module not found", {
+        field: "SparkFrost"
+      });
+    }
+    const signingPrivateKey = await this.getSigningPrivateKeyFromDerivation(keyDerivation);
+    if (!signingPrivateKey) {
+      throw new ValidationError("Private key not found for public key", {
+        field: "privateKey"
+      });
+    }
+    const { commitment, nonce } = selfCommitment;
+    if (!nonce) {
+      throw new ValidationError("Nonce not found for commitment", {
+        field: "nonce"
+      });
+    }
+    const keyPackage = {
+      secretKey: signingPrivateKey,
+      publicKey,
+      verifyingKey
+    };
+    return SparkFrost.signFrost({
+      message,
+      keyPackage,
+      nonce,
+      selfCommitment: commitment,
+      statechainCommitments,
+      adaptorPubKey
+    });
+  }
+};
 var TaprootSparkSigner = class extends DefaultSparkSigner {
   constructor(useAddressIndex = false) {
     super({
@@ -23559,6 +23695,293 @@ var TokenTransactionWithStatus2 = {
     return message;
   }
 };
+function createBaseFreezeTokensPayload2() {
+  return {
+    version: 0,
+    ownerPublicKey: new Uint8Array(0),
+    tokenPublicKey: void 0,
+    tokenIdentifier: void 0,
+    issuerProvidedTimestamp: 0,
+    operatorIdentityPublicKey: new Uint8Array(0),
+    shouldUnfreeze: false
+  };
+}
+var FreezeTokensPayload2 = {
+  encode(message, writer = new import_wire7.BinaryWriter()) {
+    if (message.version !== 0) {
+      writer.uint32(8).uint32(message.version);
+    }
+    if (message.ownerPublicKey.length !== 0) {
+      writer.uint32(18).bytes(message.ownerPublicKey);
+    }
+    if (message.tokenPublicKey !== void 0) {
+      writer.uint32(26).bytes(message.tokenPublicKey);
+    }
+    if (message.tokenIdentifier !== void 0) {
+      writer.uint32(34).bytes(message.tokenIdentifier);
+    }
+    if (message.issuerProvidedTimestamp !== 0) {
+      writer.uint32(40).uint64(message.issuerProvidedTimestamp);
+    }
+    if (message.operatorIdentityPublicKey.length !== 0) {
+      writer.uint32(50).bytes(message.operatorIdentityPublicKey);
+    }
+    if (message.shouldUnfreeze !== false) {
+      writer.uint32(56).bool(message.shouldUnfreeze);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire7.BinaryReader ? input : new import_wire7.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseFreezeTokensPayload2();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 8) {
+            break;
+          }
+          message.version = reader.uint32();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.ownerPublicKey = reader.bytes();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+          message.tokenPublicKey = reader.bytes();
+          continue;
+        }
+        case 4: {
+          if (tag !== 34) {
+            break;
+          }
+          message.tokenIdentifier = reader.bytes();
+          continue;
+        }
+        case 5: {
+          if (tag !== 40) {
+            break;
+          }
+          message.issuerProvidedTimestamp = longToNumber4(reader.uint64());
+          continue;
+        }
+        case 6: {
+          if (tag !== 50) {
+            break;
+          }
+          message.operatorIdentityPublicKey = reader.bytes();
+          continue;
+        }
+        case 7: {
+          if (tag !== 56) {
+            break;
+          }
+          message.shouldUnfreeze = reader.bool();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      version: isSet6(object.version) ? globalThis.Number(object.version) : 0,
+      ownerPublicKey: isSet6(object.ownerPublicKey) ? bytesFromBase645(object.ownerPublicKey) : new Uint8Array(0),
+      tokenPublicKey: isSet6(object.tokenPublicKey) ? bytesFromBase645(object.tokenPublicKey) : void 0,
+      tokenIdentifier: isSet6(object.tokenIdentifier) ? bytesFromBase645(object.tokenIdentifier) : void 0,
+      issuerProvidedTimestamp: isSet6(object.issuerProvidedTimestamp) ? globalThis.Number(object.issuerProvidedTimestamp) : 0,
+      operatorIdentityPublicKey: isSet6(object.operatorIdentityPublicKey) ? bytesFromBase645(object.operatorIdentityPublicKey) : new Uint8Array(0),
+      shouldUnfreeze: isSet6(object.shouldUnfreeze) ? globalThis.Boolean(object.shouldUnfreeze) : false
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.version !== 0) {
+      obj.version = Math.round(message.version);
+    }
+    if (message.ownerPublicKey.length !== 0) {
+      obj.ownerPublicKey = base64FromBytes5(message.ownerPublicKey);
+    }
+    if (message.tokenPublicKey !== void 0) {
+      obj.tokenPublicKey = base64FromBytes5(message.tokenPublicKey);
+    }
+    if (message.tokenIdentifier !== void 0) {
+      obj.tokenIdentifier = base64FromBytes5(message.tokenIdentifier);
+    }
+    if (message.issuerProvidedTimestamp !== 0) {
+      obj.issuerProvidedTimestamp = Math.round(message.issuerProvidedTimestamp);
+    }
+    if (message.operatorIdentityPublicKey.length !== 0) {
+      obj.operatorIdentityPublicKey = base64FromBytes5(message.operatorIdentityPublicKey);
+    }
+    if (message.shouldUnfreeze !== false) {
+      obj.shouldUnfreeze = message.shouldUnfreeze;
+    }
+    return obj;
+  },
+  create(base) {
+    return FreezeTokensPayload2.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseFreezeTokensPayload2();
+    message.version = object.version ?? 0;
+    message.ownerPublicKey = object.ownerPublicKey ?? new Uint8Array(0);
+    message.tokenPublicKey = object.tokenPublicKey ?? void 0;
+    message.tokenIdentifier = object.tokenIdentifier ?? void 0;
+    message.issuerProvidedTimestamp = object.issuerProvidedTimestamp ?? 0;
+    message.operatorIdentityPublicKey = object.operatorIdentityPublicKey ?? new Uint8Array(0);
+    message.shouldUnfreeze = object.shouldUnfreeze ?? false;
+    return message;
+  }
+};
+function createBaseFreezeTokensRequest2() {
+  return { freezeTokensPayload: void 0, issuerSignature: new Uint8Array(0) };
+}
+var FreezeTokensRequest2 = {
+  encode(message, writer = new import_wire7.BinaryWriter()) {
+    if (message.freezeTokensPayload !== void 0) {
+      FreezeTokensPayload2.encode(message.freezeTokensPayload, writer.uint32(10).fork()).join();
+    }
+    if (message.issuerSignature.length !== 0) {
+      writer.uint32(18).bytes(message.issuerSignature);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire7.BinaryReader ? input : new import_wire7.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseFreezeTokensRequest2();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.freezeTokensPayload = FreezeTokensPayload2.decode(reader, reader.uint32());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.issuerSignature = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      freezeTokensPayload: isSet6(object.freezeTokensPayload) ? FreezeTokensPayload2.fromJSON(object.freezeTokensPayload) : void 0,
+      issuerSignature: isSet6(object.issuerSignature) ? bytesFromBase645(object.issuerSignature) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.freezeTokensPayload !== void 0) {
+      obj.freezeTokensPayload = FreezeTokensPayload2.toJSON(message.freezeTokensPayload);
+    }
+    if (message.issuerSignature.length !== 0) {
+      obj.issuerSignature = base64FromBytes5(message.issuerSignature);
+    }
+    return obj;
+  },
+  create(base) {
+    return FreezeTokensRequest2.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseFreezeTokensRequest2();
+    message.freezeTokensPayload = object.freezeTokensPayload !== void 0 && object.freezeTokensPayload !== null ? FreezeTokensPayload2.fromPartial(object.freezeTokensPayload) : void 0;
+    message.issuerSignature = object.issuerSignature ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseFreezeTokensResponse2() {
+  return { impactedOutputIds: [], impactedTokenAmount: new Uint8Array(0) };
+}
+var FreezeTokensResponse2 = {
+  encode(message, writer = new import_wire7.BinaryWriter()) {
+    for (const v of message.impactedOutputIds) {
+      writer.uint32(10).string(v);
+    }
+    if (message.impactedTokenAmount.length !== 0) {
+      writer.uint32(18).bytes(message.impactedTokenAmount);
+    }
+    return writer;
+  },
+  decode(input, length) {
+    const reader = input instanceof import_wire7.BinaryReader ? input : new import_wire7.BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseFreezeTokensResponse2();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.impactedOutputIds.push(reader.string());
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+          message.impactedTokenAmount = reader.bytes();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+  fromJSON(object) {
+    return {
+      impactedOutputIds: globalThis.Array.isArray(object?.impactedOutputIds) ? object.impactedOutputIds.map((e) => globalThis.String(e)) : [],
+      impactedTokenAmount: isSet6(object.impactedTokenAmount) ? bytesFromBase645(object.impactedTokenAmount) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.impactedOutputIds?.length) {
+      obj.impactedOutputIds = message.impactedOutputIds;
+    }
+    if (message.impactedTokenAmount.length !== 0) {
+      obj.impactedTokenAmount = base64FromBytes5(message.impactedTokenAmount);
+    }
+    return obj;
+  },
+  create(base) {
+    return FreezeTokensResponse2.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseFreezeTokensResponse2();
+    message.impactedOutputIds = object.impactedOutputIds?.map((e) => e) || [];
+    message.impactedTokenAmount = object.impactedTokenAmount ?? new Uint8Array(0);
+    return message;
+  }
+};
 var SparkTokenServiceDefinition = {
   name: "SparkTokenService",
   fullName: "spark_token.SparkTokenService",
@@ -23610,6 +24033,14 @@ var SparkTokenServiceDefinition = {
       responseType: QueryTokenOutputsResponse2,
       responseStream: false,
       options: {}
+    },
+    freeze_tokens: {
+      name: "freeze_tokens",
+      requestType: FreezeTokensRequest2,
+      requestStream: false,
+      responseType: FreezeTokensResponse2,
+      responseStream: false,
+      options: {}
     }
   }
 };
@@ -24068,6 +24499,13 @@ var DEFAULT_EXPIRY_TIME = 10 * 60 * 1e3;
 function initialSequence() {
   return 1 << 30 | INITIAL_TIME_LOCK;
 }
+function getSigningJobProto(signingJob) {
+  return {
+    signingPublicKey: signingJob.signingPublicKey,
+    rawTx: signingJob.rawTx,
+    signingNonceCommitment: signingJob.signingNonceCommitment.commitment
+  };
+}
 var BaseTransferService = class {
   config;
   connectionManager;
@@ -24694,7 +25132,7 @@ var TransferService = class extends BaseTransferService {
             refundSigningData.keyDerivation
           ),
           rawTx: refundTx.toBytes(),
-          signingNonceCommitment: refundNonceCommitmentProto
+          signingNonceCommitment: refundNonceCommitmentProto.commitment
         },
         // TODO: Add direct refund signature
         directRefundTxSigningJob: void 0,
@@ -25006,7 +25444,7 @@ var TransferService = class extends BaseTransferService {
     const response = await sparkClient.refresh_timelock({
       leafId: leaf.id,
       ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
-      signingJobs
+      signingJobs: signingJobs.map(getSigningJobProto)
     });
     if (signingJobs.length !== response.signingResults.length) {
       throw Error(
@@ -25172,8 +25610,8 @@ var TransferService = class extends BaseTransferService {
     const response = await sparkClient.extend_leaf({
       leafId: node.id,
       ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
-      nodeTxSigningJob: newNodeSigningJob,
-      refundTxSigningJob: newRefundSigningJob
+      nodeTxSigningJob: getSigningJobProto(newNodeSigningJob),
+      refundTxSigningJob: getSigningJobProto(newRefundSigningJob)
     });
     if (!response.nodeTxSigningResult || !response.refundTxSigningResult) {
       throw new Error("Signing result does not exist");
@@ -25281,7 +25719,7 @@ var TransferService = class extends BaseTransferService {
     const response = await sparkClient.refresh_timelock({
       leafId: node.id,
       ownerIdentityPublicKey: await this.config.signer.getIdentityPublicKey(),
-      signingJobs: [refundSigningJob]
+      signingJobs: [getSigningJobProto(refundSigningJob)]
     });
     if (response.signingResults.length !== 1) {
       throw Error(
@@ -25433,7 +25871,7 @@ var CoopExitService = class extends BaseTransferService {
             leaf.keyDerivation
           ),
           rawTx: refundTx.toBytes(),
-          signingNonceCommitment
+          signingNonceCommitment: signingNonceCommitment.commitment
         },
         // TODO: Add direct refund signature
         directRefundTxSigningJob: void 0,
@@ -25688,12 +26126,12 @@ var DepositService = class {
         rootTxSigningJob: {
           rawTx: rootTx.toBytes(),
           signingPublicKey: signingPubKey,
-          signingNonceCommitment: rootNonceCommitment
+          signingNonceCommitment: rootNonceCommitment.commitment
         },
         refundTxSigningJob: {
           rawTx: refundTx.toBytes(),
           signingPublicKey: signingPubKey,
-          signingNonceCommitment: refundNonceCommitment
+          signingNonceCommitment: refundNonceCommitment.commitment
         }
       });
     } catch (error) {
@@ -28316,7 +28754,9 @@ var TokenTransactionService = class {
       issuerPublicKeys,
       tokenTransactionHashes,
       tokenIdentifiers,
-      outputIds
+      outputIds,
+      pageSize,
+      offset
     } = params;
     const tokenClient = await this.connectionManager.createSparkTokenClient(
       this.config.getCoordinatorAddress()
@@ -28327,8 +28767,8 @@ var TokenTransactionService = class {
       tokenIdentifiers: tokenIdentifiers?.map(import_utils19.hexToBytes),
       tokenTransactionHashes: tokenTransactionHashes?.map(import_utils19.hexToBytes),
       outputIds: outputIds || [],
-      limit: 100,
-      offset: 0
+      limit: pageSize,
+      offset
     };
     try {
       const response = await tokenClient.query_token_transactions(queryParams);
@@ -28765,7 +29205,7 @@ var TreeCreationService = class {
     const signingJob = {
       signingPublicKey: node.signingPublicKey,
       rawTx: tx.toBytes(),
-      signingNonceCommitment
+      signingNonceCommitment: signingNonceCommitment.commitment
     };
     internalCreationNode.nodeTxSigningCommitment = signingNonceCommitment;
     internalCreationNode.nodeTxSigningJob = signingJob;
@@ -28794,7 +29234,7 @@ var TreeCreationService = class {
     const childSigningJob = {
       signingPublicKey: node.signingPublicKey,
       rawTx: childTx.toBytes(),
-      signingNonceCommitment: childSigningNonceCommitment
+      signingNonceCommitment: childSigningNonceCommitment.commitment
     };
     childCreationNode.nodeTxSigningCommitment = childSigningNonceCommitment;
     childCreationNode.nodeTxSigningJob = childSigningJob;
@@ -28821,7 +29261,7 @@ var TreeCreationService = class {
     const refundSigningJob = {
       signingPublicKey: node.signingPublicKey,
       rawTx: refundTx.toBytes(),
-      signingNonceCommitment: refundSigningNonceCommitment
+      signingNonceCommitment: refundSigningNonceCommitment.commitment
     };
     childCreationNode.refundTxSigningCommitment = refundSigningNonceCommitment;
     childCreationNode.refundTxSigningJob = refundSigningJob;
@@ -28856,7 +29296,7 @@ var TreeCreationService = class {
     const rootNodeSigningJob = {
       signingPublicKey: root.signingPublicKey,
       rawTx: rootNodeTx.toBytes(),
-      signingNonceCommitment: rootNodeSigningCommitment
+      signingNonceCommitment: rootNodeSigningCommitment.commitment
     };
     const rootCreationNode = {
       nodeTxSigningJob: rootNodeSigningJob,
@@ -29089,7 +29529,7 @@ var SigningService = class {
           leaf.keyDerivation
         ),
         rawTx: refundTx.toBytes(),
-        signingNonceCommitment: signingCommitment,
+        signingNonceCommitment: signingCommitment.commitment,
         userSignature: signingResult,
         signingCommitments: {
           signingCommitments: signingNonceCommitments
@@ -29682,11 +30122,24 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         }
       }
     }
-    const verifyKey = (pubkey1, pubkey2, verifyingKey) => {
-      return (0, import_utils24.equalBytes)(addPublicKeys(pubkey1, pubkey2), verifyingKey);
-    };
-    for (const [id, leaf] of Object.entries(leaves.nodes)) {
-      if (!verifyKey(
+    const availableLeaves = Object.entries(leaves.nodes).filter(
+      ([_, node]) => node.status === "AVAILABLE"
+    );
+    for (const [id, leaf] of availableLeaves) {
+      if (leaf.parentNodeId && leaf.status === "AVAILABLE" && this.verifyKey(
+        await this.config.signer.getPublicKeyFromDerivation({
+          type: "leaf" /* LEAF */,
+          path: leaf.parentNodeId
+        }),
+        leaf.signingKeyshare?.publicKey ?? new Uint8Array(),
+        leaf.verifyingPublicKey
+      )) {
+        this.transferLeavesToSelf([leaf], {
+          type: "leaf" /* LEAF */,
+          path: leaf.parentNodeId
+        });
+        leavesToIgnore.add(id);
+      } else if (!this.verifyKey(
         await this.config.signer.getPublicKeyFromDerivation({
           type: "leaf" /* LEAF */,
           path: leaf.id
@@ -29697,9 +30150,23 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
         leavesToIgnore.add(id);
       }
     }
-    return Object.entries(leaves.nodes).filter(
-      ([_, node]) => node.status === "AVAILABLE" && !leavesToIgnore.has(node.id)
-    ).map(([_, node]) => node);
+    return availableLeaves.filter(([_, node]) => !leavesToIgnore.has(node.id)).map(([_, node]) => node);
+  }
+  async checkExtendLeaves(leaves) {
+    await this.withLeaves(async () => {
+      for (const leaf of leaves) {
+        if (!leaf.parentNodeId && leaf.status === "AVAILABLE") {
+          const res = await this.transferService.extendTimelock(leaf);
+          await this.transferLeavesToSelf(res.nodes, {
+            type: "leaf" /* LEAF */,
+            path: leaf.id
+          });
+        }
+      }
+    });
+  }
+  verifyKey(pubkey1, pubkey2, verifyingKey) {
+    return (0, import_utils24.equalBytes)(addPublicKeys(pubkey1, pubkey2), verifyingKey);
   }
   async selectLeaves(targetAmounts) {
     if (targetAmounts.length === 0) {
@@ -29838,6 +30305,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     leaves = await this.checkRefreshTimelockNodes(leaves);
     leaves = await this.checkExtendTimeLockNodes(leaves);
     this.leaves = leaves;
+    this.checkExtendLeaves(leaves);
     this.optimizeLeaves().catch((e) => {
       console.error("Failed to optimize leaves", e);
     });
@@ -30537,7 +31005,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     const signingJob = {
       rawTx: tx.toBytes(),
       signingPublicKey: await this.config.signer.getStaticDepositSigningKey(0),
-      signingNonceCommitment
+      signingNonceCommitment: signingNonceCommitment.commitment
     };
     const message = await this.getStaticDepositSigningPayload(
       depositTransactionId,
@@ -31998,14 +32466,18 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
     issuerPublicKeys,
     tokenTransactionHashes,
     tokenIdentifiers,
-    outputIds
+    outputIds,
+    pageSize = 100,
+    offset = 0
   }) {
     return this.tokenTransactionService.queryTokenTransactions({
       ownerPublicKeys,
       issuerPublicKeys,
       tokenTransactionHashes,
       tokenIdentifiers,
-      outputIds
+      outputIds,
+      pageSize,
+      offset
     });
   }
   async getTokenL1Address() {
@@ -32467,7 +32939,7 @@ var SparkWallet = class _SparkWallet extends import_eventemitter3.EventEmitter {
 init_buffer();
 
 // src/index.node.ts
-var cryptoImpl2 = typeof global !== "undefined" && global.crypto ? global.crypto : import_crypto4.default;
+var cryptoImpl2 = typeof global !== "undefined" && global.crypto ? global.crypto : import_crypto3.default;
 setCrypto(cryptoImpl2);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -32490,6 +32962,7 @@ setCrypto(cryptoImpl2);
   TaprootOutputKeysGenerator,
   TaprootSparkSigner,
   TokenTransactionService,
+  UnsafeStatelessSparkSigner,
   ValidationError,
   WalletConfig,
   addPrivateKeys,