@buildonspark/issuer-sdk 0.0.75 → 0.0.76

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @buildonspark/issuer-sdk
 
+## 0.0.76
+
+### Patch Changes
+
+- - Update parsing of spark address from fallback_adress to route_hints
+  - Update sdk checks on transactions
+  - Add token features
+  - Improve stability and cleanup
+- Updated dependencies
+  - @buildonspark/spark-sdk@0.1.45
+
 ## 0.0.75
 
 ### Patch Changes

package/dist/index.cjs

@@ -43,7 +43,7 @@ var import_lrc20_sdk = require("@buildonspark/lrc20-sdk");
 var import_spark_sdk3 = require("@buildonspark/spark-sdk");
 var import_core = require("@lightsparkdev/core");
 var import_address = require("@buildonspark/spark-sdk/address");
-var import_utils6 = require("@noble/curves/abstract/utils");
+var import_utils5 = require("@noble/curves/abstract/utils");
 
 // src/services/freeze.ts
 var import_utils2 = require("@buildonspark/spark-sdk/utils");
@@ -189,8 +189,7 @@ var IssuerTokenTransactionService = class extends import_token_transactions.Toke
       tokenInputs: {
         $case: "mintInput",
         mintInput: {
-          issuerPublicKey: tokenPublicKey,
-          issuerProvidedTimestamp: Date.now()
+          issuerPublicKey: tokenPublicKey
         }
       },
       tokenOutputs: [
@@ -200,113 +199,15 @@ var IssuerTokenTransactionService = class extends import_token_transactions.Toke
           tokenAmount: (0, import_utils4.numberToBytesBE)(tokenAmount, 16)
         }
       ],
+      clientCreatedTimestamp: /* @__PURE__ */ new Date(),
       sparkOperatorIdentityPublicKeys: super.collectOperatorIdentityPublicKeys(),
       expiryTime: void 0
     };
   }
 };
 
-// src/utils/type-mappers.ts
-var import_utils5 = require("@noble/curves/abstract/utils");
-var import_lrc20 = require("@buildonspark/spark-sdk/proto/lrc20");
-function convertToTokenActivity(rawTransactions) {
-  const response = {
-    transactions: rawTransactions.transactions.map((transaction) => {
-      if (!transaction.transaction) {
-        return { transaction: void 0 };
-      }
-      if (transaction.transaction.$case === "onChain") {
-        const onChain = transaction.transaction.onChain;
-        return {
-          transaction: {
-            $case: "onChain",
-            onChain: {
-              operationType: getEnumName(import_lrc20.OperationType, onChain.operationType),
-              transactionHash: (0, import_utils5.bytesToHex)(onChain.transactionHash),
-              rawtx: (0, import_utils5.bytesToHex)(onChain.rawtx),
-              status: getEnumName(import_lrc20.OnChainTransactionStatus, onChain.status),
-              inputs: onChain.inputs.map((input) => ({
-                rawTx: (0, import_utils5.bytesToHex)(input.rawTx),
-                vout: input.vout,
-                amountSats: input.amountSats,
-                tokenPublicKey: input.tokenPublicKey,
-                tokenAmount: input.tokenAmount ? (0, import_utils5.bytesToNumberBE)(input.tokenAmount).toString() : void 0
-              })),
-              outputs: onChain.outputs.map((output) => ({
-                rawTx: (0, import_utils5.bytesToHex)(output.rawTx),
-                vout: output.vout,
-                amountSats: output.amountSats,
-                tokenPublicKey: output.tokenPublicKey,
-                tokenAmount: output.tokenAmount ? (0, import_utils5.bytesToNumberBE)(output.tokenAmount).toString() : void 0
-              })),
-              broadcastedAt: onChain.broadcastedAt,
-              confirmedAt: onChain.confirmedAt
-            }
-          }
-        };
-      } else if (transaction.transaction.$case === "spark") {
-        const spark = transaction.transaction.spark;
-        return {
-          transaction: {
-            $case: "spark",
-            spark: {
-              operationType: getEnumName(import_lrc20.OperationType, spark.operationType),
-              transactionHash: (0, import_utils5.bytesToHex)(spark.transactionHash),
-              status: getEnumName(import_lrc20.SparkTransactionStatus, spark.status),
-              confirmedAt: spark.confirmedAt,
-              leavesToCreate: spark.leavesToCreate.map((leaf) => ({
-                tokenPublicKey: (0, import_utils5.bytesToHex)(leaf.tokenPublicKey),
-                id: leaf.id,
-                ownerPublicKey: (0, import_utils5.bytesToHex)(leaf.ownerPublicKey),
-                revocationPublicKey: (0, import_utils5.bytesToHex)(leaf.revocationPublicKey),
-                withdrawalBondSats: leaf.withdrawalBondSats,
-                withdrawalLocktime: leaf.withdrawalLocktime,
-                tokenAmount: (0, import_utils5.bytesToNumberBE)(leaf.tokenAmount).toString(),
-                createTxHash: (0, import_utils5.bytesToHex)(leaf.createTxHash),
-                createTxVoutIndex: leaf.createTxVoutIndex,
-                spendTxHash: leaf.spendTxHash ? (0, import_utils5.bytesToHex)(leaf.spendTxHash) : void 0,
-                spendTxVoutIndex: leaf.spendTxVoutIndex,
-                isFrozen: leaf.isFrozen
-              })),
-              leavesToSpend: spark.leavesToSpend.map((leaf) => ({
-                tokenPublicKey: (0, import_utils5.bytesToHex)(leaf.tokenPublicKey),
-                id: leaf.id,
-                ownerPublicKey: (0, import_utils5.bytesToHex)(leaf.ownerPublicKey),
-                revocationPublicKey: (0, import_utils5.bytesToHex)(leaf.revocationPublicKey),
-                withdrawalBondSats: leaf.withdrawalBondSats,
-                withdrawalLocktime: leaf.withdrawalLocktime,
-                tokenAmount: (0, import_utils5.bytesToNumberBE)(leaf.tokenAmount).toString(),
-                createTxHash: (0, import_utils5.bytesToHex)(leaf.createTxHash),
-                createTxVoutIndex: leaf.createTxVoutIndex,
-                spendTxHash: leaf.spendTxHash ? (0, import_utils5.bytesToHex)(leaf.spendTxHash) : void 0,
-                spendTxVoutIndex: leaf.spendTxVoutIndex,
-                isFrozen: leaf.isFrozen
-              })),
-              sparkOperatorIdentityPublicKeys: spark.sparkOperatorIdentityPublicKeys.map(
-                (key) => (0, import_utils5.bytesToHex)(key)
-              )
-            }
-          }
-        };
-      }
-      return { transaction: void 0 };
-    }),
-    nextCursor: rawTransactions.nextCursor ? {
-      lastTransactionHash: (0, import_utils5.bytesToHex)(
-        rawTransactions.nextCursor.lastTransactionHash
-      ),
-      layer: getEnumName(import_lrc20.Layer, rawTransactions.nextCursor.layer)
-    } : void 0
-  };
-  return response;
-}
-function getEnumName(enumObj, value) {
-  return enumObj[value];
-}
-
 // src/issuer-wallet/issuer-spark-wallet.ts
 var import_spark_sdk4 = require("@buildonspark/spark-sdk");
-var import_lrc202 = require("@buildonspark/spark-sdk/proto/lrc20");
 var BURN_ADDRESS = "02".repeat(33);
 var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk3.SparkWallet {
   issuerTokenTransactionService;
@@ -358,10 +259,6 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk3.Spark
       "SparkIssuerWallet.unfreezeTokens",
       this.unfreezeTokens.bind(this)
     );
-    this.getIssuerTokenActivity = this.wrapWithOtelSpan(
-      "SparkIssuerWallet.getIssuerTokenActivity",
-      this.getIssuerTokenActivity.bind(this)
-    );
     this.getIssuerTokenDistribution = this.wrapWithOtelSpan(
       "SparkIssuerWallet.getIssuerTokenDistribution",
       this.getIssuerTokenDistribution.bind(this)
@@ -389,13 +286,16 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk3.Spark
   async getIssuerTokenBalance() {
     const publicKey = await super.getIdentityPublicKey();
     const balanceObj = await this.getBalance();
-    if (!balanceObj.tokenBalances || !balanceObj.tokenBalances.has(publicKey)) {
+    const issuerBalance = [...balanceObj.tokenBalances.entries()].find(
+      ([, info]) => info.tokenMetadata.tokenPublicKey === publicKey
+    );
+    if (!balanceObj.tokenBalances || issuerBalance === void 0) {
       return {
         balance: 0n
       };
     }
     return {
-      balance: balanceObj.tokenBalances.get(publicKey).balance
+      balance: issuerBalance[1].balance
     };
   }
   /**
@@ -407,17 +307,17 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk3.Spark
     const lrc20Client = await this.lrc20ConnectionManager.createLrc20Client();
     try {
       const tokenInfo = await lrc20Client.getTokenPubkeyInfo({
-        publicKeys: [(0, import_utils6.hexToBytes)(await super.getIdentityPublicKey())]
+        publicKeys: [(0, import_utils5.hexToBytes)(await super.getIdentityPublicKey())]
       });
       const info = tokenInfo.tokenPubkeyInfos[0];
       return {
-        tokenPublicKey: (0, import_utils6.bytesToHex)(info.announcement.publicKey.publicKey),
+        tokenPublicKey: (0, import_utils5.bytesToHex)(info.announcement.publicKey.publicKey),
         tokenName: info.announcement.name,
         tokenSymbol: info.announcement.symbol,
-        tokenDecimals: Number((0, import_utils6.bytesToNumberBE)(info.announcement.decimal)),
+        tokenDecimals: Number((0, import_utils5.bytesToNumberBE)(info.announcement.decimal)),
         isFreezable: info.announcement.isFreezable,
-        maxSupply: (0, import_utils6.bytesToNumberBE)(info.announcement.maxSupply),
-        totalSupply: (0, import_utils6.bytesToNumberBE)(info.totalSupply)
+        maxSupply: (0, import_utils5.bytesToNumberBE)(info.announcement.maxSupply),
+        totalSupply: (0, import_utils5.bytesToNumberBE)(info.totalSupply)
       };
     } catch (error) {
       throw new import_spark_sdk3.NetworkError("Failed to get token info", {
@@ -437,12 +337,12 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk3.Spark
     let tokenTransaction;
     if (this.config.getTokenTransactionVersion() === "V0") {
       tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransactionV0(
-        (0, import_utils6.hexToBytes)(tokenPublicKey),
+        (0, import_utils5.hexToBytes)(tokenPublicKey),
         tokenAmount
       );
     } else {
       tokenTransaction = await this.issuerTokenTransactionService.constructMintTokenTransaction(
-        (0, import_utils6.hexToBytes)(tokenPublicKey),
+        (0, import_utils5.hexToBytes)(tokenPublicKey),
         tokenAmount
       );
     }
@@ -481,10 +381,10 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk3.Spark
       this.config.getNetworkType()
     );
     const response = await this.tokenFreezeService.freezeTokens(
-      (0, import_utils6.hexToBytes)(decodedOwnerPubkey.identityPublicKey),
-      (0, import_utils6.hexToBytes)(tokenPublicKey)
+      (0, import_utils5.hexToBytes)(decodedOwnerPubkey.identityPublicKey),
+      (0, import_utils5.hexToBytes)(tokenPublicKey)
     );
-    const tokenAmount = (0, import_utils6.bytesToNumberBE)(response.impactedTokenAmount);
+    const tokenAmount = (0, import_utils5.bytesToNumberBE)(response.impactedTokenAmount);
     return {
       impactedOutputIds: response.impactedOutputIds,
       impactedTokenAmount: tokenAmount
@@ -503,105 +403,15 @@ var IssuerSparkWallet = class _IssuerSparkWallet extends import_spark_sdk3.Spark
       this.config.getNetworkType()
     );
     const response = await this.tokenFreezeService.unfreezeTokens(
-      (0, import_utils6.hexToBytes)(decodedOwnerPubkey.identityPublicKey),
-      (0, import_utils6.hexToBytes)(tokenPublicKey)
+      (0, import_utils5.hexToBytes)(decodedOwnerPubkey.identityPublicKey),
+      (0, import_utils5.hexToBytes)(tokenPublicKey)
     );
-    const tokenAmount = (0, import_utils6.bytesToNumberBE)(response.impactedTokenAmount);
+    const tokenAmount = (0, import_utils5.bytesToNumberBE)(response.impactedTokenAmount);
     return {
       impactedOutputIds: response.impactedOutputIds,
       impactedTokenAmount: tokenAmount
     };
   }
-  /**
-   * Retrieves the activity history for the issuer's token.
-   * @param pageSize - The number of transactions to return per page (default: 100)
-   * @param cursor - Optional cursor for pagination
-   * @param operationTypes - Optional array of operation types to filter by
-   * @param beforeTimestamp - Optional timestamp to filter transactions before
-   * @param afterTimestamp - Optional timestamp to filter transactions after
-   * @returns An object containing the token activity data
-   * @throws {ValidationError} If pageSize is not a safe integer
-   * @throws {NetworkError} If the activity data cannot be retrieved
-   */
-  async getIssuerTokenActivity(pageSize = 100, cursor, operationTypes, beforeTimestamp, afterTimestamp) {
-    if (!Number.isSafeInteger(pageSize)) {
-      throw new import_spark_sdk3.ValidationError("pageSize must be less than 2^53", {
-        field: "pageSize",
-        value: pageSize,
-        expected: "smaller or equal to " + Number.MAX_SAFE_INTEGER
-      });
-    }
-    const lrc20Client = await this.lrc20ConnectionManager.createLrc20Client();
-    let convertedCursor;
-    if (cursor) {
-      const lastTransactionHash = typeof cursor.lastTransactionHash === "string" ? (0, import_utils6.hexToBytes)(cursor.lastTransactionHash) : cursor.lastTransactionHash;
-      let layer;
-      if (typeof cursor.layer === "string") {
-        switch (cursor.layer.toUpperCase()) {
-          case "L1":
-            layer = import_lrc202.Layer.L1;
-            break;
-          case "Spark":
-            layer = import_lrc202.Layer.SPARK;
-            break;
-          default:
-            layer = import_lrc202.Layer.UNRECOGNIZED;
-        }
-      } else {
-        layer = cursor.layer;
-      }
-      convertedCursor = {
-        lastTransactionHash,
-        layer
-      };
-    }
-    let convertedOperationTypes;
-    if (operationTypes) {
-      if (typeof operationTypes[0] === "string") {
-        convertedOperationTypes = operationTypes.map((opType) => {
-          switch (opType.toUpperCase()) {
-            case "USER_TRANSFER":
-              return import_lrc202.OperationType.USER_TRANSFER;
-            case "USER_BURN":
-              return import_lrc202.OperationType.USER_BURN;
-            case "ISSUER_ANNOUNCE":
-              return import_lrc202.OperationType.ISSUER_ANNOUNCE;
-            case "ISSUER_MINT":
-              return import_lrc202.OperationType.ISSUER_MINT;
-            case "ISSUER_TRANSFER":
-              return import_lrc202.OperationType.ISSUER_TRANSFER;
-            case "ISSUER_FREEZE":
-              return import_lrc202.OperationType.ISSUER_FREEZE;
-            case "ISSUER_UNFREEZE":
-              return import_lrc202.OperationType.ISSUER_UNFREEZE;
-            case "ISSUER_BURN":
-              return import_lrc202.OperationType.ISSUER_BURN;
-            default:
-              return import_lrc202.OperationType.UNRECOGNIZED;
-          }
-        });
-      } else {
-        convertedOperationTypes = operationTypes;
-      }
-    }
-    try {
-      const transactions = await lrc20Client.listTransactions({
-        tokenPublicKey: (0, import_utils6.hexToBytes)(await super.getIdentityPublicKey()),
-        cursor: convertedCursor,
-        pageSize,
-        beforeTimestamp,
-        afterTimestamp,
-        operationTypes: convertedOperationTypes
-      });
-      return convertToTokenActivity(transactions);
-    } catch (error) {
-      throw new import_spark_sdk3.NetworkError("Failed to get token activity", {
-        operation: "listTransactions",
-        errorCount: 1,
-        errors: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
   /**
    * Retrieves the distribution information for the issuer's token.
    * @throws {NotImplementedError} This feature is not yet supported

package/dist/index.d.cts

@@ -1,8 +1,7 @@
 import { SparkWallet, SparkWalletProps } from '@buildonspark/spark-sdk';
 import { OutputWithPreviousTransactionData } from '@buildonspark/spark-sdk/proto/spark';
 import { ConfigOptions } from '@buildonspark/spark-sdk/services/wallet-config';
-import { TokenActivityResponse, TokenDistribution } from './types.cjs';
-import { Layer, OperationType } from '@buildonspark/spark-sdk/proto/lrc20';
+import { TokenDistribution } from './types.cjs';
 import { SparkSigner } from '@buildonspark/spark-sdk/signer';
 
 type IssuerTokenInfo = {
@@ -78,21 +77,6 @@ declare class IssuerSparkWallet extends SparkWallet {
         impactedOutputIds: string[];
         impactedTokenAmount: bigint;
     }>;
-    /**
-     * Retrieves the activity history for the issuer's token.
-     * @param pageSize - The number of transactions to return per page (default: 100)
-     * @param cursor - Optional cursor for pagination
-     * @param operationTypes - Optional array of operation types to filter by
-     * @param beforeTimestamp - Optional timestamp to filter transactions before
-     * @param afterTimestamp - Optional timestamp to filter transactions after
-     * @returns An object containing the token activity data
-     * @throws {ValidationError} If pageSize is not a safe integer
-     * @throws {NetworkError} If the activity data cannot be retrieved
-     */
-    getIssuerTokenActivity(pageSize?: number, cursor?: {
-        lastTransactionHash: string | Uint8Array;
-        layer: string | Layer;
-    }, operationTypes?: string[] | OperationType[], beforeTimestamp?: Date, afterTimestamp?: Date): Promise<TokenActivityResponse>;
     /**
      * Retrieves the distribution information for the issuer's token.
      * @throws {NotImplementedError} This feature is not yet supported

package/dist/index.d.ts

@@ -1,8 +1,7 @@
 import { SparkWallet, SparkWalletProps } from '@buildonspark/spark-sdk';
 import { OutputWithPreviousTransactionData } from '@buildonspark/spark-sdk/proto/spark';
 import { ConfigOptions } from '@buildonspark/spark-sdk/services/wallet-config';
-import { TokenActivityResponse, TokenDistribution } from './types.js';
-import { Layer, OperationType } from '@buildonspark/spark-sdk/proto/lrc20';
+import { TokenDistribution } from './types.js';
 import { SparkSigner } from '@buildonspark/spark-sdk/signer';
 
 type IssuerTokenInfo = {
@@ -78,21 +77,6 @@ declare class IssuerSparkWallet extends SparkWallet {
         impactedOutputIds: string[];
         impactedTokenAmount: bigint;
     }>;
-    /**
-     * Retrieves the activity history for the issuer's token.
-     * @param pageSize - The number of transactions to return per page (default: 100)
-     * @param cursor - Optional cursor for pagination
-     * @param operationTypes - Optional array of operation types to filter by
-     * @param beforeTimestamp - Optional timestamp to filter transactions before
-     * @param afterTimestamp - Optional timestamp to filter transactions after
-     * @returns An object containing the token activity data
-     * @throws {ValidationError} If pageSize is not a safe integer
-     * @throws {NetworkError} If the activity data cannot be retrieved
-     */
-    getIssuerTokenActivity(pageSize?: number, cursor?: {
-        lastTransactionHash: string | Uint8Array;
-        layer: string | Layer;
-    }, operationTypes?: string[] | OperationType[], beforeTimestamp?: Date, afterTimestamp?: Date): Promise<TokenActivityResponse>;
     /**
      * Retrieves the distribution information for the issuer's token.
      * @throws {NotImplementedError} This feature is not yet supported