@buildonspark/spark-sdk 0.2.2 → 0.2.3

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @buildonspark/spark-sdk
 
+## 0.2.3
+
+### Patch Changes
+
+- -leaf key improvements
+  -token improvements
+
 ## 0.2.2
 
 ### Patch Changes

package/dist/{chunk-TM6CHQXC.js → chunk-3SEOTO43.js}

@@ -2,7 +2,7 @@ import {
   Network,
   TransferStatus,
   TransferType
-} from "./chunk-2ENZX6LT.js";
+} from "./chunk-AAZWSPUK.js";
 
 // src/types/sdk-types.ts
 import { bytesToHex } from "@noble/curves/abstract/utils";

package/dist/{chunk-2ENZX6LT.js → chunk-AAZWSPUK.js}

@@ -14831,14 +14831,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,
@@ -15005,6 +14997,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: {}
     }
   }
 };

package/dist/{chunk-4JD4HIAN.js → chunk-G4MSZ6DE.js}

@@ -3,7 +3,7 @@ import {
   Timestamp,
   networkFromJSON,
   networkToJSON
-} from "./chunk-2ENZX6LT.js";
+} from "./chunk-AAZWSPUK.js";
 
 // src/proto/spark_token.ts
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
@@ -2249,6 +2249,293 @@ var TokenTransactionWithStatus = {
     return message;
   }
 };
+function createBaseFreezeTokensPayload() {
+  return {
+    version: 0,
+    ownerPublicKey: new Uint8Array(0),
+    tokenPublicKey: void 0,
+    tokenIdentifier: void 0,
+    issuerProvidedTimestamp: 0,
+    operatorIdentityPublicKey: new Uint8Array(0),
+    shouldUnfreeze: false
+  };
+}
+var FreezeTokensPayload = {
+  encode(message, writer = new 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 BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseFreezeTokensPayload();
+    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 = longToNumber(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: isSet(object.version) ? globalThis.Number(object.version) : 0,
+      ownerPublicKey: isSet(object.ownerPublicKey) ? bytesFromBase64(object.ownerPublicKey) : new Uint8Array(0),
+      tokenPublicKey: isSet(object.tokenPublicKey) ? bytesFromBase64(object.tokenPublicKey) : void 0,
+      tokenIdentifier: isSet(object.tokenIdentifier) ? bytesFromBase64(object.tokenIdentifier) : void 0,
+      issuerProvidedTimestamp: isSet(object.issuerProvidedTimestamp) ? globalThis.Number(object.issuerProvidedTimestamp) : 0,
+      operatorIdentityPublicKey: isSet(object.operatorIdentityPublicKey) ? bytesFromBase64(object.operatorIdentityPublicKey) : new Uint8Array(0),
+      shouldUnfreeze: isSet(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 = base64FromBytes(message.ownerPublicKey);
+    }
+    if (message.tokenPublicKey !== void 0) {
+      obj.tokenPublicKey = base64FromBytes(message.tokenPublicKey);
+    }
+    if (message.tokenIdentifier !== void 0) {
+      obj.tokenIdentifier = base64FromBytes(message.tokenIdentifier);
+    }
+    if (message.issuerProvidedTimestamp !== 0) {
+      obj.issuerProvidedTimestamp = Math.round(message.issuerProvidedTimestamp);
+    }
+    if (message.operatorIdentityPublicKey.length !== 0) {
+      obj.operatorIdentityPublicKey = base64FromBytes(message.operatorIdentityPublicKey);
+    }
+    if (message.shouldUnfreeze !== false) {
+      obj.shouldUnfreeze = message.shouldUnfreeze;
+    }
+    return obj;
+  },
+  create(base) {
+    return FreezeTokensPayload.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseFreezeTokensPayload();
+    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 createBaseFreezeTokensRequest() {
+  return { freezeTokensPayload: void 0, issuerSignature: new Uint8Array(0) };
+}
+var FreezeTokensRequest = {
+  encode(message, writer = new BinaryWriter()) {
+    if (message.freezeTokensPayload !== void 0) {
+      FreezeTokensPayload.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 BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseFreezeTokensRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+          message.freezeTokensPayload = FreezeTokensPayload.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: isSet(object.freezeTokensPayload) ? FreezeTokensPayload.fromJSON(object.freezeTokensPayload) : void 0,
+      issuerSignature: isSet(object.issuerSignature) ? bytesFromBase64(object.issuerSignature) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.freezeTokensPayload !== void 0) {
+      obj.freezeTokensPayload = FreezeTokensPayload.toJSON(message.freezeTokensPayload);
+    }
+    if (message.issuerSignature.length !== 0) {
+      obj.issuerSignature = base64FromBytes(message.issuerSignature);
+    }
+    return obj;
+  },
+  create(base) {
+    return FreezeTokensRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseFreezeTokensRequest();
+    message.freezeTokensPayload = object.freezeTokensPayload !== void 0 && object.freezeTokensPayload !== null ? FreezeTokensPayload.fromPartial(object.freezeTokensPayload) : void 0;
+    message.issuerSignature = object.issuerSignature ?? new Uint8Array(0);
+    return message;
+  }
+};
+function createBaseFreezeTokensResponse() {
+  return { impactedOutputIds: [], impactedTokenAmount: new Uint8Array(0) };
+}
+var FreezeTokensResponse = {
+  encode(message, writer = new 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 BinaryReader ? input : new BinaryReader(input);
+    const end = length === void 0 ? reader.len : reader.pos + length;
+    const message = createBaseFreezeTokensResponse();
+    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: isSet(object.impactedTokenAmount) ? bytesFromBase64(object.impactedTokenAmount) : new Uint8Array(0)
+    };
+  },
+  toJSON(message) {
+    const obj = {};
+    if (message.impactedOutputIds?.length) {
+      obj.impactedOutputIds = message.impactedOutputIds;
+    }
+    if (message.impactedTokenAmount.length !== 0) {
+      obj.impactedTokenAmount = base64FromBytes(message.impactedTokenAmount);
+    }
+    return obj;
+  },
+  create(base) {
+    return FreezeTokensResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object) {
+    const message = createBaseFreezeTokensResponse();
+    message.impactedOutputIds = object.impactedOutputIds?.map((e) => e) || [];
+    message.impactedTokenAmount = object.impactedTokenAmount ?? new Uint8Array(0);
+    return message;
+  }
+};
 var SparkTokenServiceDefinition = {
   name: "SparkTokenService",
   fullName: "spark_token.SparkTokenService",
@@ -2300,6 +2587,14 @@ var SparkTokenServiceDefinition = {
       responseType: QueryTokenOutputsResponse,
       responseStream: false,
       options: {}
+    },
+    freeze_tokens: {
+      name: "freeze_tokens",
+      requestType: FreezeTokensRequest,
+      requestStream: false,
+      responseType: FreezeTokensResponse,
+      responseStream: false,
+      options: {}
     }
   }
 };
@@ -2390,5 +2685,8 @@ export {
   SpentTokenOutputMetadata,
   TokenTransactionConfirmationMetadata,
   TokenTransactionWithStatus,
+  FreezeTokensPayload,
+  FreezeTokensRequest,
+  FreezeTokensResponse,
   SparkTokenServiceDefinition
 };

package/dist/{chunk-2TUM3R6C.js → chunk-PLLJIZC3.js}

@@ -1,10 +1,10 @@
 import {
   SparkTokenServiceDefinition
-} from "./chunk-4JD4HIAN.js";
+} from "./chunk-G4MSZ6DE.js";
 import {
   mapTransferToWalletTransfer,
   mapTreeNodeToWalletLeaf
-} from "./chunk-TM6CHQXC.js";
+} from "./chunk-3SEOTO43.js";
 import {
   BitcoinNetwork_default,
   ClaimStaticDepositRequestType_default,
@@ -30,7 +30,7 @@ import {
   SparkServiceDefinition,
   TreeNode,
   networkToJSON
-} from "./chunk-2ENZX6LT.js";
+} from "./chunk-AAZWSPUK.js";
 import {
   Buffer,
   __export
@@ -577,7 +577,7 @@ import * as ecies from "eciesjs";
 import { isNode } from "@lightsparkdev/core";
 var isReactNative = typeof navigator !== "undefined" && navigator.product === "ReactNative";
 var isBun = globalThis.Bun !== void 0;
-var packageVersion = true ? "0.2.2" : "unknown";
+var packageVersion = true ? "0.2.3" : "unknown";
 var baseEnvStr = "unknown";
 if (isBun) {
   const bunVersion = "version" in globalThis.Bun ? globalThis.Bun.version : "unknown-version";
@@ -5763,7 +5763,9 @@ var TokenTransactionService = class {
       issuerPublicKeys,
       tokenTransactionHashes,
       tokenIdentifiers,
-      outputIds
+      outputIds,
+      pageSize,
+      offset
     } = params;
     const tokenClient = await this.connectionManager.createSparkTokenClient(
       this.config.getCoordinatorAddress()
@@ -5774,8 +5776,8 @@ var TokenTransactionService = class {
       tokenIdentifiers: tokenIdentifiers?.map(hexToBytes6),
       tokenTransactionHashes: tokenTransactionHashes?.map(hexToBytes6),
       outputIds: outputIds || [],
-      limit: 100,
-      offset: 0
+      limit: pageSize,
+      offset
     };
     try {
       const response = await tokenClient.query_token_transactions(queryParams);
@@ -10116,11 +10118,24 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
         }
       }
     }
-    const verifyKey = (pubkey1, pubkey2, verifyingKey) => {
-      return equalBytes5(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
@@ -10131,9 +10146,23 @@ var SparkWallet = class _SparkWallet extends 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 equalBytes5(addPublicKeys(pubkey1, pubkey2), verifyingKey);
   }
   async selectLeaves(targetAmounts) {
     if (targetAmounts.length === 0) {
@@ -10272,6 +10301,7 @@ var SparkWallet = class _SparkWallet extends 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);
     });
@@ -12432,14 +12462,18 @@ var SparkWallet = class _SparkWallet extends EventEmitter {
     issuerPublicKeys,
     tokenTransactionHashes,
     tokenIdentifiers,
-    outputIds
+    outputIds,
+    pageSize = 100,
+    offset = 0
   }) {
     return this.tokenTransactionService.queryTokenTransactions({
       ownerPublicKeys,
       issuerPublicKeys,
       tokenTransactionHashes,
       tokenIdentifiers,
-      outputIds
+      outputIds,
+      pageSize,
+      offset
     });
   }
   async getTokenL1Address() {

package/dist/{chunk-S2AL73MZ.js → chunk-PTRXJS7Q.js}

@@ -1,6 +1,6 @@
 import {
   setCrypto
-} from "./chunk-2TUM3R6C.js";
+} from "./chunk-PLLJIZC3.js";
 
 // src/index.ts
 var cryptoImpl = typeof window !== "undefined" && window.crypto ? window.crypto : typeof global !== "undefined" && global.crypto ? global.crypto : null;