@buildonspark/issuer-sdk 0.0.59 → 0.0.60

package/src/tests/integration/spark.test.ts

@@ -1,6 +1,6 @@
 import { filterTokenBalanceForTokenPublicKey } from "@buildonspark/spark-sdk/utils";
 import { jest } from "@jest/globals";
-import { hexToBytes } from "@noble/curves/abstract/utils";
+import { encodeSparkAddress } from "@buildonspark/spark-sdk/address";
 import {
   LOCAL_WALLET_CONFIG_ECDSA,
   LOCAL_WALLET_CONFIG_SCHNORR,
@@ -8,8 +8,23 @@ import {
 import { BitcoinFaucet } from "../../../../spark-sdk/src/tests/utils/test-faucet.js";
 import { IssuerSparkWalletTesting } from "../utils/issuer-test-wallet.js";
 import { SparkWalletTesting } from "../utils/spark-testing-wallet.js";
-import { SparkWallet } from "@buildonspark/spark-sdk";
 import { IssuerSparkWallet } from "../../index.js";
+import { OperationType } from "@buildonspark/spark-sdk/proto/lrc20";
+
+function hexStringToUint8Array(hexString) {
+  if (hexString.length % 2 !== 0) {
+    throw new Error("Hex string must have an even number of characters.");
+  }
+
+  const uint8Array = new Uint8Array(hexString.length / 2);
+
+  for (let i = 0; i < hexString.length; i += 2) {
+    const byte = parseInt(hexString.substring(i, i + 2), 16);
+    uint8Array[i / 2] = byte;
+  }
+
+  return uint8Array;
+}
 
 const brokenTestFn = process.env.GITHUB_ACTIONS ? it.skip : it;
 describe("token integration tests", () => {
@@ -113,6 +128,138 @@ describe("token integration tests", () => {
     expect(destinationBalance.balance).toEqual(tokenAmount);
   });
 
+  it("should announce, mint, get list all transactions, and transfer tokens with ECDSA multiple times, get list all transactions again and check difference", async () => {
+    const tokenAmount: bigint = 100n;
+
+    const { wallet: issuerWallet } = await IssuerSparkWalletTesting.initialize({
+      options: LOCAL_WALLET_CONFIG_ECDSA,
+    });
+
+    const { wallet: destinationWallet } = await SparkWalletTesting.initialize({
+      options: LOCAL_WALLET_CONFIG_ECDSA,
+    });
+
+    await fundAndAnnounce(issuerWallet, 100000n, 0, "ECDSATransfer", "ETT");
+
+    {
+      const transactions = await issuerWallet.getIssuerTokenActivity();
+      const amount_of_transactions = transactions.transactions.length;
+      expect(amount_of_transactions).toEqual(0);
+    }
+
+    await issuerWallet.mintTokens(tokenAmount);
+
+    {
+      const transactions = await issuerWallet.getIssuerTokenActivity();
+      const amount_of_transactions = transactions.transactions.length;
+      expect(amount_of_transactions).toEqual(1);
+    }
+
+    await issuerWallet.transferTokens({
+      tokenAmount,
+      tokenPublicKey: await issuerWallet.getIdentityPublicKey(),
+      receiverSparkAddress: await destinationWallet.getSparkAddress(),
+    });
+
+    {
+      const transactions = await issuerWallet.getIssuerTokenActivity();
+      const amount_of_transactions = transactions.transactions.length;
+      expect(amount_of_transactions).toEqual(2);
+    }
+
+    for (let index = 0; index < 100; ++index) {
+      await issuerWallet.mintTokens(tokenAmount);
+      await issuerWallet.transferTokens({
+        tokenAmount,
+        tokenPublicKey: await issuerWallet.getIdentityPublicKey(),
+        receiverSparkAddress: await destinationWallet.getSparkAddress(),
+      });
+    } // 202 in total
+
+    let all_transactions = await issuerWallet.getIssuerTokenActivity(250);
+    const amount_of_transactions = all_transactions.transactions.length;
+    expect(amount_of_transactions).toEqual(202);
+
+    {
+      const transactions = await issuerWallet.getIssuerTokenActivity(10);
+      const amount_of_transactions = transactions.transactions.length;
+      expect(amount_of_transactions).toEqual(10);
+    }
+
+    {
+      let hashset_of_all_transactions: Set<String> = new Set();
+
+      let transactions = await issuerWallet.getIssuerTokenActivity(10);
+      let amount_of_transactions = transactions.transactions.length;
+      expect(amount_of_transactions).toEqual(10);
+      let page_num = 0;
+      for (let index = 0; index < transactions.transactions.length; ++index) {
+        const element = transactions.transactions[index];
+        if (!(element.transaction === undefined)) {
+          let hash: String = "";
+          if (element.transaction.$case === "spark") {
+            hash = element.transaction.spark.transactionHash;
+          } else if (element.transaction.$case === "onChain") {
+            hash = element.transaction.onChain.transactionHash;
+          }
+          if (hashset_of_all_transactions.has(hash)) {
+            expect(
+              `Dublicate found. Pagination is broken? Index of transaction: ${index} ; page №: ${page_num} ; page size: 10 ; hash_dublicate: ${hash}`,
+            ).toEqual("");
+          } else {
+            hashset_of_all_transactions.add(hash);
+          }
+        } else {
+          expect(
+            `Transaction is undefined. Something is really wrong. Index of transaction: ${index} ; page №: ${page_num} ; page size: 10`,
+          ).toEqual("");
+        }
+      }
+
+      while (!(undefined === transactions.nextCursor)) {
+        let transactions_2 = await issuerWallet.getIssuerTokenActivity(10, {
+          lastTransactionHash: hexStringToUint8Array(
+            transactions.nextCursor.lastTransactionHash,
+          ),
+          layer: transactions.nextCursor.layer,
+        });
+
+        ++page_num;
+
+        for (
+          let index = 0;
+          index < transactions_2.transactions.length;
+          ++index
+        ) {
+          const element = transactions_2.transactions[index];
+          if (!(element.transaction === undefined)) {
+            let hash: String = "";
+            if (element.transaction.$case === "spark") {
+              hash = element.transaction.spark.transactionHash;
+            } else if (element.transaction.$case === "onChain") {
+              hash = element.transaction.onChain.transactionHash;
+            }
+            if (hashset_of_all_transactions.has(hash)) {
+              expect(
+                `Dublicate found. Pagination is broken? Index of transaction: ${index} ; page №: ${page_num} ; page size: 10 ; hash_dublicate: ${hash}`,
+              ).toEqual("");
+            } else {
+              hashset_of_all_transactions.add(hash);
+            }
+          } else {
+            expect(
+              `Transaction is undefined. Something is really wrong. Index of transaction: ${index} ; page №: ${page_num} ; page size: 10`,
+            ).toEqual("");
+          }
+        }
+
+        transactions = transactions_2;
+      }
+
+      expect(hashset_of_all_transactions.size == 202);
+    }
+  });
+
   it("should announce, mint, and batchtransfer tokens with ECDSA", async () => {
     const tokenAmount: bigint = 999n;
 
@@ -270,8 +417,7 @@ describe("token integration tests", () => {
     expect(destinationBalance.balance).toEqual(tokenAmount);
   });
 
-  // broken because LRC20 does not yet have ISSUER operation types.
-  brokenTestFn("should track token operations in monitoring", async () => {
+  it("should track token operations in monitoring", async () => {
     const tokenAmount: bigint = 1000n;
 
     const { wallet: issuerWallet } = await IssuerSparkWalletTesting.initialize({
@@ -500,6 +646,26 @@ describe("token integration tests", () => {
     expect(issuerTokenBalanceAfterBurn).toEqual(0n);
   });
 
+  it("should announce, mint, and burn tokens with ECDSA and totalSupply has to be equal amount of token minted minus burned tokens", async () => {
+    const tokenAmount_init: bigint = 2000n;
+    const tokenAmount_burn: bigint = 1000n;
+
+    const { wallet: issuerWallet } = await IssuerSparkWalletTesting.initialize({
+      options: LOCAL_WALLET_CONFIG_ECDSA,
+    });
+
+    await fundAndAnnounce(issuerWallet, 100000n, 0, "ECDSATotalSupply", "ETS");
+    await issuerWallet.mintTokens(tokenAmount_init);
+
+    await issuerWallet.burnTokens(tokenAmount_burn);
+
+    const smth_with_total_supply = await issuerWallet.getIssuerTokenInfo();
+
+    expect(smth_with_total_supply?.totalSupply).toEqual(
+      tokenAmount_init - tokenAmount_burn,
+    );
+  });
+
   it("should announce, mint, and burn tokens with Schnorr", async () => {
     const tokenAmount: bigint = 200n;
     const { wallet: issuerWallet } = await IssuerSparkWalletTesting.initialize({
@@ -646,6 +812,87 @@ describe("token integration tests", () => {
     ).balance;
     expect(issuerTokenBalanceAfterBurn).toEqual(0n);
   });
+  it("should correctly assign operation types for complete token lifecycle operations", async () => {
+    const { wallet: issuerWallet } = await IssuerSparkWalletTesting.initialize({
+      options: LOCAL_WALLET_CONFIG_SCHNORR,
+    });
+
+    const { wallet: userWallet } = await SparkWalletTesting.initialize({
+      options: LOCAL_WALLET_CONFIG_SCHNORR,
+    });
+
+    const tokenAmount = 1000n;
+
+    await fundAndAnnounce(issuerWallet, 100000n, 0, "OperationTypeTest", "OTT");
+    await issuerWallet.mintTokens(tokenAmount);
+
+    await issuerWallet.transferTokens({
+      tokenAmount: 500n,
+      tokenPublicKey: await issuerWallet.getIdentityPublicKey(),
+      receiverSparkAddress: await userWallet.getSparkAddress(),
+    });
+
+    const tokenPublicKeyHex = await issuerWallet.getIdentityPublicKey();
+
+    await userWallet.transferTokens({
+      tokenPublicKey: tokenPublicKeyHex,
+      tokenAmount: 250n,
+      receiverSparkAddress: await issuerWallet.getSparkAddress(),
+    });
+
+    // as in userWallet we didn't have burnTokens method, we need to transfer tokens to burn address manually
+    const BURN_ADDRESS = "02".repeat(33);
+    const burnAddress = encodeSparkAddress({
+      identityPublicKey: BURN_ADDRESS,
+      network: "LOCAL",
+    });
+
+    await userWallet.transferTokens({
+      tokenPublicKey: tokenPublicKeyHex,
+      tokenAmount: 250n,
+      receiverSparkAddress: burnAddress,
+    });
+
+    await issuerWallet.burnTokens(250n);
+
+    const activity = await issuerWallet.getIssuerTokenActivity();
+
+    const mintTransaction = activity.transactions.find(
+      (tx) =>
+        tx.transaction?.$case === "spark" &&
+        tx.transaction.spark.operationType === "ISSUER_MINT",
+    );
+
+    const transferTransaction = activity.transactions.find(
+      (tx) =>
+        tx.transaction?.$case === "spark" &&
+        tx.transaction.spark.operationType === "ISSUER_TRANSFER",
+    );
+
+    const burnTransaction = activity.transactions.find(
+      (tx) =>
+        tx.transaction?.$case === "spark" &&
+        tx.transaction.spark.operationType === "ISSUER_BURN",
+    );
+
+    const transferBackTransaction = activity.transactions.find(
+      (tx) =>
+        tx.transaction?.$case === "spark" &&
+        tx.transaction.spark.operationType === "USER_TRANSFER",
+    );
+
+    const userBurnTransaction = activity.transactions.find(
+      (tx) =>
+        tx.transaction?.$case === "spark" &&
+        tx.transaction.spark.operationType === "USER_BURN",
+    );
+
+    expect(mintTransaction).toBeDefined();
+    expect(transferTransaction).toBeDefined();
+    expect(burnTransaction).toBeDefined();
+    expect(transferBackTransaction).toBeDefined();
+    expect(userBurnTransaction).toBeDefined();
+  });
 });
 
 async function fundAndAnnounce(

package/src/types.ts

@@ -1,36 +1,4 @@
-// String enums to replace numeric enums
-export enum LayerType {
-  L1 = "L1",
-  SPARK = "SPARK",
-}
-
-export enum OperationType {
-  USER_TRANSFER = "USER_TRANSFER",
-  USER_BURN = "USER_BURN",
-  ISSUER_ANNOUNCE = "ISSUER_ANNOUNCE",
-  ISSUER_MINT = "ISSUER_MINT",
-  ISSUER_TRANSFER = "ISSUER_TRANSFER",
-  ISSUER_FREEZE = "ISSUER_FREEZE",
-  ISSUER_UNFREEZE = "ISSUER_UNFREEZE",
-  ISSUER_BURN = "ISSUER_BURN",
-}
-
-export enum OnChainTransactionStatus {
-  PENDING = "PENDING",
-  CONFIRMED = "CONFIRMED",
-  WAITING_MINED = "WAITING_MINED",
-  MINED = "MINED",
-  ATTACHING = "ATTACHING",
-  ATTACHED = "ATTACHED",
-}
-
-export enum SparkTransactionStatus {
-  STARTED = "STARTED",
-  SIGNED = "SIGNED",
-  FINALIZED = "FINALIZED",
-}
-
-export type GetTokenActivityResponse = {
+export type TokenActivityResponse = {
   transactions: Transaction[];
   nextCursor?: ListAllTokenTransactionsCursor | undefined;
 };
@@ -70,19 +38,19 @@ export interface OnChainTokenOutput {
   tokenAmount?: string | undefined;
 }
 export interface OnChainTransaction {
-  operationType: OperationType;
+  operationType: string;
   transactionHash: string;
   rawtx: string;
-  status: OnChainTransactionStatus;
+  status: string;
   inputs: OnChainTokenOutput[];
   outputs: OnChainTokenOutput[];
   broadcastedAt: Date | undefined;
   confirmedAt: Date | undefined;
 }
 export interface SparkTransaction {
-  operationType: OperationType;
+  operationType: string;
   transactionHash: string;
-  status: SparkTransactionStatus;
+  status: string;
   confirmedAt: Date | undefined;
   leavesToCreate: SparkLeaf[];
   leavesToSpend: SparkLeaf[];
@@ -105,7 +73,7 @@ export interface SparkLeaf {
 
 export interface ListAllTokenTransactionsCursor {
   lastTransactionHash: string;
-  layer: LayerType;
+  layer: string;
 }
 
 export interface TokenDistribution {

package/src/utils/type-mappers.ts

@@ -1,15 +1,13 @@
-import {
-  ListAllTokenTransactionsResponse,
-  TokenPubkeyInfo,
-} from "@buildonspark/lrc20-sdk";
-import { GetTokenActivityResponse, TokenPubKeyInfoResponse } from "../types.js";
+import { TokenPubkeyInfo } from "@buildonspark/lrc20-sdk";
+import { TokenActivityResponse, TokenPubKeyInfoResponse } from "../types.js";
 import { bytesToHex, bytesToNumberBE } from "@noble/curves/abstract/utils";
 import {
-  mapOperationType,
-  mapOnChainTransactionStatus,
-  mapSparkTransactionStatus,
-  mapLayer,
-} from "./enum-mappers.js";
+  ListAllTokenTransactionsResponse,
+  OperationType,
+  OnChainTransactionStatus,
+  SparkTransactionStatus,
+  Layer,
+} from "@buildonspark/spark-sdk/proto/lrc20";
 
 export function convertToTokenPubKeyInfoResponse(
   tokenPubkeyInfo: TokenPubkeyInfo,
@@ -31,10 +29,16 @@ export function convertToTokenPubKeyInfoResponse(
   };
 }
 
-export function convertTokenActivityToHexEncoded(
+/**
+ * Converts a ListAllTokenTransactionsResponse to a TokenActivityResponse
+ * Main purpose is to convert Uint8Arrays to hex strings
+ * @param rawTransactions - The ListAllTokenTransactionsResponse to convert
+ * @returns The converted TokenActivityResponse
+ */
+export function convertToTokenActivity(
   rawTransactions: ListAllTokenTransactionsResponse,
-): GetTokenActivityResponse {
-  const response: GetTokenActivityResponse = {
+): TokenActivityResponse {
+  const response: TokenActivityResponse = {
     transactions: rawTransactions.transactions.map((transaction) => {
       if (!transaction.transaction) {
         return { transaction: undefined };
@@ -46,10 +50,10 @@ export function convertTokenActivityToHexEncoded(
           transaction: {
             $case: "onChain",
             onChain: {
-              operationType: mapOperationType(onChain.operationType),
+              operationType: getEnumName(OperationType, onChain.operationType),
               transactionHash: bytesToHex(onChain.transactionHash),
               rawtx: bytesToHex(onChain.rawtx),
-              status: mapOnChainTransactionStatus(onChain.status),
+              status: getEnumName(OnChainTransactionStatus, onChain.status),
               inputs: onChain.inputs.map((input) => ({
                 rawTx: bytesToHex(input.rawTx),
                 vout: input.vout,
@@ -79,9 +83,9 @@ export function convertTokenActivityToHexEncoded(
           transaction: {
             $case: "spark",
             spark: {
-              operationType: mapOperationType(spark.operationType),
+              operationType: getEnumName(OperationType, spark.operationType),
               transactionHash: bytesToHex(spark.transactionHash),
-              status: mapSparkTransactionStatus(spark.status),
+              status: getEnumName(SparkTransactionStatus, spark.status),
               confirmedAt: spark.confirmedAt,
               leavesToCreate: spark.leavesToCreate.map((leaf) => ({
                 tokenPublicKey: bytesToHex(leaf.tokenPublicKey),
@@ -131,10 +135,14 @@ export function convertTokenActivityToHexEncoded(
           lastTransactionHash: bytesToHex(
             rawTransactions.nextCursor.lastTransactionHash,
           ),
-          layer: mapLayer(rawTransactions.nextCursor.layer),
+          layer: getEnumName(Layer, rawTransactions.nextCursor.layer),
         }
       : undefined,
   };
 
   return response;
 }
+
+export function getEnumName(enumObj: any, value: number): string {
+  return enumObj[value];
+}

package/dist/chunk-GB7N6I5O.js

@@ -1,48 +0,0 @@
-// buffer.js
-import { Buffer } from "buffer";
-if (typeof globalThis.Buffer === "undefined") {
-  globalThis.Buffer = Buffer;
-}
-if (typeof global === "undefined") {
-  window.global = window.globalThis;
-}
-
-// src/types.ts
-var LayerType = /* @__PURE__ */ ((LayerType2) => {
-  LayerType2["L1"] = "L1";
-  LayerType2["SPARK"] = "SPARK";
-  return LayerType2;
-})(LayerType || {});
-var OperationType = /* @__PURE__ */ ((OperationType2) => {
-  OperationType2["USER_TRANSFER"] = "USER_TRANSFER";
-  OperationType2["USER_BURN"] = "USER_BURN";
-  OperationType2["ISSUER_ANNOUNCE"] = "ISSUER_ANNOUNCE";
-  OperationType2["ISSUER_MINT"] = "ISSUER_MINT";
-  OperationType2["ISSUER_TRANSFER"] = "ISSUER_TRANSFER";
-  OperationType2["ISSUER_FREEZE"] = "ISSUER_FREEZE";
-  OperationType2["ISSUER_UNFREEZE"] = "ISSUER_UNFREEZE";
-  OperationType2["ISSUER_BURN"] = "ISSUER_BURN";
-  return OperationType2;
-})(OperationType || {});
-var OnChainTransactionStatus = /* @__PURE__ */ ((OnChainTransactionStatus2) => {
-  OnChainTransactionStatus2["PENDING"] = "PENDING";
-  OnChainTransactionStatus2["CONFIRMED"] = "CONFIRMED";
-  OnChainTransactionStatus2["WAITING_MINED"] = "WAITING_MINED";
-  OnChainTransactionStatus2["MINED"] = "MINED";
-  OnChainTransactionStatus2["ATTACHING"] = "ATTACHING";
-  OnChainTransactionStatus2["ATTACHED"] = "ATTACHED";
-  return OnChainTransactionStatus2;
-})(OnChainTransactionStatus || {});
-var SparkTransactionStatus = /* @__PURE__ */ ((SparkTransactionStatus2) => {
-  SparkTransactionStatus2["STARTED"] = "STARTED";
-  SparkTransactionStatus2["SIGNED"] = "SIGNED";
-  SparkTransactionStatus2["FINALIZED"] = "FINALIZED";
-  return SparkTransactionStatus2;
-})(SparkTransactionStatus || {});
-
-export {
-  LayerType,
-  OperationType,
-  OnChainTransactionStatus,
-  SparkTransactionStatus
-};