mainnet-js 1.0.18 → 1.1.1

package/src/wallet/Cashtokens.test.ts

@@ -110,6 +110,8 @@ describe(`Test cashtokens`, () => {
     expect(newTokenUtxos.length).toBe(2);
     expect(await alice.getTokenBalance(tokenId)).toBe(75);
     expect(await bob.getTokenBalance(tokenId)).toBe(25);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(0);
+    expect((await bob.getAllNftTokenBalances())[tokenId] || 0).toBe(0);
   });
 
   test("Test NFT cashtoken genesis and sending", async () => {
@@ -167,7 +169,7 @@ describe(`Test cashtokens`, () => {
           commitment: "abcd02",
         }),
       ])
-    ).rejects.toThrow("Can not change the commitment of an immutable token");
+    ).rejects.toThrow("No suitable token utxos available to send token");
   });
 
   test("Test mutable NFT cashtoken genesis and mutation", async () => {
@@ -615,6 +617,192 @@ describe(`Test cashtokens`, () => {
     expect(tokenUtxos2.length).toBe(1);
   });
 
+  test("Test minting NFTs not burn tokens", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const bob = await RegTestWallet.newRandom();
+    const charlie = await RegTestWallet.newRandom();
+
+    // prepare inputs for two token geneses
+    await alice.send({ cashaddr: bob.cashaddr!, value: 10000, unit: "sat" });
+
+    const genesisResponse = await bob.tokenGenesis({
+      capability: "minting",
+      commitment: "",
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(1);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(1);
+
+    await bob.tokenMint(tokenId, {
+      capability: "none",
+      commitment: "0a",
+    });
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(2);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(2);
+
+    await bob.send(
+      new TokenSendRequest({
+        tokenId: tokenId,
+        capability: "none",
+        commitment: "0a",
+        cashaddr: charlie.cashaddr!,
+      })
+    );
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(1);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(1);
+
+    expect(await charlie.getTokenBalance(tokenId)).toBe(0);
+    expect(await charlie.getNftTokenBalance(tokenId)).toBe(1);
+    expect((await charlie.getTokenUtxos(tokenId)).length).toBe(1);
+  });
+
+  test("Test sending NFTs after burning minting token", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const bob = await RegTestWallet.newRandom();
+    const charlie = await RegTestWallet.newRandom();
+
+    // prepare inputs for two token geneses
+    await alice.send({ cashaddr: bob.cashaddr!, value: 10000, unit: "sat" });
+
+    const genesisResponse = await bob.tokenGenesis({
+      capability: "minting",
+      commitment: "",
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(1);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(1);
+
+    await bob.tokenMint(tokenId, {
+      capability: "none",
+      commitment: "0a",
+    });
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(2);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(2);
+
+    await bob.tokenMint(tokenId, {
+      capability: "none",
+      commitment: "0b",
+    });
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(3);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(3);
+
+    await bob.tokenBurn({
+      tokenId: tokenId,
+      capability: "minting",
+      commitment: "",
+    });
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(2);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(2);
+
+    await bob.send(
+      new TokenSendRequest({
+        tokenId: tokenId,
+        capability: "none",
+        commitment: "0a",
+        cashaddr: charlie.cashaddr!,
+      })
+    );
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(1);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(1);
+
+    expect(await charlie.getTokenBalance(tokenId)).toBe(0);
+    expect(await charlie.getNftTokenBalance(tokenId)).toBe(1);
+    expect((await charlie.getTokenUtxos(tokenId)).length).toBe(1);
+
+    await bob.send(
+      new TokenSendRequest({
+        tokenId: tokenId,
+        capability: "none",
+        commitment: "0b",
+        cashaddr: charlie.cashaddr!,
+      })
+    );
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(0);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(0);
+
+    expect(await charlie.getTokenBalance(tokenId)).toBe(0);
+    expect(await charlie.getNftTokenBalance(tokenId)).toBe(2);
+    expect((await charlie.getTokenUtxos(tokenId)).length).toBe(2);
+  });
+
+  test("Test sending NFTs with empty commitment", async () => {
+    const alice = await RegTestWallet.fromId(process.env.ALICE_ID!);
+    const bob = await RegTestWallet.newRandom();
+    const charlie = await RegTestWallet.newRandom();
+
+    // prepare inputs for two token geneses
+    await alice.send({ cashaddr: bob.cashaddr!, value: 10000, unit: "sat" });
+
+    const genesisResponse = await bob.tokenGenesis({
+      capability: "minting",
+      commitment: "00",
+    });
+
+    const tokenId = genesisResponse.tokenIds![0];
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(1);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(1);
+
+    await bob.tokenMint(tokenId, {
+      capability: "none",
+      commitment: "0a",
+    });
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(2);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(2);
+
+    await bob.tokenMint(tokenId, {
+      capability: "none",
+      commitment: "0b",
+    });
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(3);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(3);
+
+    await bob.tokenBurn({
+      tokenId: tokenId,
+      capability: "minting",
+      commitment: "00",
+    });
+
+    expect(await bob.getTokenBalance(tokenId)).toBe(0);
+    expect(await bob.getNftTokenBalance(tokenId)).toBe(2);
+    expect((await bob.getTokenUtxos(tokenId)).length).toBe(2);
+
+    await expect(
+      bob.send(
+        new TokenSendRequest({
+          tokenId: tokenId,
+          capability: "none",
+          commitment: "",
+          cashaddr: charlie.cashaddr!,
+        })
+      )
+    ).rejects.toThrow(
+      "No suitable token utxos available to send token with id"
+    );
+  });
+
   test("Test enforcing token addresses", async () => {
     const bob = await RegTestWallet.newRandom();
 

package/src/wallet/Util.test.ts

@@ -31,21 +31,21 @@ test("Should throw on non-existent transaction and invalid hash", async () => {
 
 test("Should get raw transaction", async () => {
   let wallet = await RegTestWallet.fromId(process.env.ALICE_ID!);
-  const utxo = (await wallet.getUtxos()).utxos![0];
+  const utxo = (await wallet.getUtxos())[0];
   const transaction = (await wallet.provider!.getRawTransactionObject(
-    utxo.txId
+    utxo.txid
   )) as ElectrumRawTransaction;
   expect((await wallet.util.decodeTransaction(transaction.hash)).hash).toBe(
-    utxo.txId
+    utxo.txid
   );
   expect((await wallet.util.decodeTransaction(transaction.hex)).txid).toBe(
-    utxo.txId
+    utxo.txid
   );
 
   // test static accessor
   expect(
     (await RegTestWallet.util.decodeTransaction(transaction.hex)).txid
-  ).toBe(utxo.txId);
+  ).toBe(utxo.txid);
 });
 
 test("Should decode a transaction from fist block", async () => {

package/src/wallet/Wif.ts

@@ -33,6 +33,7 @@ import {
 } from "./interface.js";
 
 import {
+  fromUtxoId,
   OpReturnData,
   SendRequest,
   SendRequestArray,
@@ -42,8 +43,6 @@ import {
   TokenGenesisRequest,
   TokenMintRequest,
   TokenSendRequest,
-  UtxoItem,
-  UtxoResponse,
   XPubKey,
 } from "./model.js";
 
@@ -659,14 +658,7 @@ export class Wallet extends BaseWallet {
     if (!this.cashaddr) {
       throw Error("Attempted to get utxos without an address");
     }
-    let utxos = await this.getAddressUtxos(this.cashaddr);
-    let resp = new UtxoResponse();
-    resp.utxos = await Promise.all(
-      utxos.map(async (o: UtxoI) => {
-        return UtxoItem.fromElectrum(o);
-      })
-    );
-    return resp;
+    return await this.getAddressUtxos(this.cashaddr);
   }
 
   // gets wallet balance in sats, bch and usd
@@ -882,8 +874,8 @@ export class Wallet extends BaseWallet {
     // get inputs
     let utxos: UtxoI[];
     if (params.options && params.options.utxoIds) {
-      utxos = params.options.utxoIds.map((utxoId) =>
-        UtxoItem.fromId(utxoId).asElectrum()
+      utxos = params.options.utxoIds.map((utxoId: UtxoI | string) =>
+        typeof utxoId === "string" ? fromUtxoId(utxoId) : utxoId
       );
     } else {
       utxos = (await this.getAddressUtxos(this.cashaddr)).filter(
@@ -1117,10 +1109,8 @@ export class Wallet extends BaseWallet {
     // get inputs from options or query all inputs
     let utxos: UtxoI[];
     if (options && options.utxoIds) {
-      utxos = options.utxoIds.map((utxoId) =>
-        typeof utxoId === "string"
-          ? UtxoItem.fromId(utxoId).asElectrum()
-          : utxoId
+      utxos = options.utxoIds.map((utxoId: UtxoI | string) =>
+        typeof utxoId === "string" ? fromUtxoId(utxoId) : utxoId
       );
     } else {
       utxos = await this.getAddressUtxos(this.cashaddr);
@@ -1491,6 +1481,10 @@ export class Wallet extends BaseWallet {
     mintRequests: TokenMintRequest | Array<TokenMintRequest>,
     deductTokenAmount: boolean = false
   ): Promise<SendResponse> {
+    if (tokenId?.length !== 64) {
+      throw Error(`Invalid tokenId supplied: ${tokenId}`);
+    }
+
     if (!Array.isArray(mintRequests)) {
       mintRequests = [mintRequests];
     }
@@ -1560,6 +1554,10 @@ export class Wallet extends BaseWallet {
     burnRequest: TokenBurnRequest,
     message?: string
   ): Promise<SendResponse> {
+    if (burnRequest.tokenId?.length !== 64) {
+      throw Error(`Invalid tokenId supplied: ${burnRequest.tokenId}`);
+    }
+
     const utxos = await this.getAddressUtxos(this.cashaddr!);
     const tokenUtxos = utxos.filter(
       (val) =>
@@ -1651,7 +1649,9 @@ export class Wallet extends BaseWallet {
    * @returns  {number} fungible token balance
    */
   public async getTokenBalance(tokenId: string): Promise<number> {
-    const utxos = await this.getAddressUtxos(this.cashaddr!);
+    const utxos = (await this.getTokenUtxos(tokenId)).filter(
+      (val) => val.token?.amount
+    );
     return sumTokenAmounts(utxos, tokenId);
   }
 
@@ -1663,7 +1663,9 @@ export class Wallet extends BaseWallet {
    * @returns  {number} non-fungible token balance
    */
   public async getNftTokenBalance(tokenId: string): Promise<number> {
-    const utxos = await this.getTokenUtxos(tokenId);
+    const utxos = (await this.getTokenUtxos(tokenId)).filter(
+      (val) => val.token?.commitment !== undefined
+    );
     return utxos.length;
   }
 
@@ -1671,9 +1673,11 @@ export class Wallet extends BaseWallet {
    * getAllTokenBalances Gets all fungible token balances in this wallet
    * @returns  {Object} a map [tokenId => balance] for all tokens in this wallet
    */
-  public async getAllTokenBalances(): Promise<Object> {
+  public async getAllTokenBalances(): Promise<{ [tokenId: string]: number }> {
     const result = {};
-    const utxos = await this.getTokenUtxos();
+    const utxos = (await this.getTokenUtxos()).filter(
+      (val) => val.token?.amount
+    );
     for (const utxo of utxos) {
       if (!result[utxo.token!.tokenId]) {
         result[utxo.token!.tokenId] = 0;
@@ -1687,9 +1691,13 @@ export class Wallet extends BaseWallet {
    * getAllNftTokenBalances Gets all non-fungible token (NFT) balances in this wallet
    * @returns  {Object} a map [tokenId => balance] for all NFTs in this wallet
    */
-  public async getAllNftTokenBalances(): Promise<Object> {
+  public async getAllNftTokenBalances(): Promise<{
+    [tokenId: string]: number;
+  }> {
     const result = {};
-    const utxos = await this.getTokenUtxos();
+    const utxos = (await this.getTokenUtxos()).filter(
+      (val) => val.token?.commitment !== undefined
+    );
     for (const utxo of utxos) {
       if (!result[utxo.token!.tokenId]) {
         result[utxo.token!.tokenId] = 0;

package/src/wallet/model.test.ts

@@ -1,32 +1,27 @@
 import { UtxoI } from "../interface";
-import { UtxoItem } from "./model";
+import { fromUtxoId, toUtxoId } from "./model";
 
 test("Should serialize utxo", () => {
-  let utxo = new UtxoItem({
-    txId: "this",
-    index: 42,
-    value: 1,
+  const utxo = toUtxoId({
+    txid: "this",
+    vout: 42,
+    satoshis: 1,
   }).toString();
-  expect(utxo.toString()).toBe("this:42:1");
+  expect(utxo).toBe("this:42:1");
 });
 
 test("Should deserialize utxo", () => {
-  let utxo = UtxoItem.fromId("this:42:1");
-  expect(utxo!.txId).toBe("this");
-  expect(utxo!.index).toBe(42);
-  expect(utxo!.value).toBe(1);
-  expect(utxo!.toString()).toBe("this:42:1");
+  const utxo = fromUtxoId("this:42:1");
+  expect(utxo.txid).toBe("this");
+  expect(utxo.vout).toBe(42);
+  expect(utxo.satoshis).toBe(1);
 });
 
 test("Should deserialize utxo", () => {
-  let u = {
+  const u = {
     txid: "this",
     vout: 42,
     satoshis: 1,
   } as UtxoI;
-  let utxo = UtxoItem.fromElectrum(u);
-  expect(utxo!.txId).toBe("this");
-  expect(utxo!.index).toBe(42);
-  expect(utxo!.value).toBe(1);
-  expect(utxo!.toString()).toBe("this:42:1");
+  expect(toUtxoId(u)).toBe("this:42:1");
 });

package/src/wallet/model.ts

@@ -312,60 +312,6 @@ export class OpReturnData {
 
 export type SendRequestArray = Array<string | number | UnitEnum | Buffer>;
 
-export class UtxoItem {
-  index: number;
-  value: number;
-  utxoId: string;
-  txId: string;
-
-  constructor({
-    index,
-    value,
-    txId,
-  }: {
-    index: number;
-    value: number;
-    txId: string;
-  }) {
-    this.value = value;
-    this.txId = txId;
-    this.index = index;
-    this.utxoId = this.toString();
-  }
-
-  public toString() {
-    return [this.txId, this.index, this.value].join(DELIMITER);
-  }
-
-  public static fromId(utxoId: string) {
-    let [txid, vout, satoshis] = utxoId.split(DELIMITER);
-    return new this({
-      txId: txid,
-      index: parseInt(vout),
-      value: parseInt(satoshis),
-    });
-  }
-  public static fromElectrum(u: UtxoI) {
-    return new this({
-      txId: u.txid,
-      index: u.vout,
-      value: u.satoshis,
-    });
-  }
-
-  public asElectrum(): UtxoI {
-    return {
-      txid: this.txId,
-      vout: this.index,
-      satoshis: this.value,
-    } as UtxoI;
-  }
-}
-
-export class UtxoResponse {
-  "utxos"?: Array<UtxoItem>;
-}
-
 export class SendResponse {
   txId?: string;
   balance?: BalanceResponse;
@@ -408,3 +354,35 @@ export class XPubKey {
     };
   }
 }
+
+export const fromUtxoId = (utxoId: string): UtxoI => {
+  const [txid, vout, satoshis, tokenId, amount, capability, commitment] =
+    utxoId.split(DELIMITER);
+  return {
+    satoshis: satoshis ? parseInt(satoshis) : 0,
+    vout: parseInt(vout),
+    txid,
+    token: tokenId
+      ? {
+          tokenId,
+          amount: parseInt(amount),
+          capability: capability || undefined,
+          commitment: commitment || undefined,
+        }
+      : undefined,
+  } as UtxoI;
+};
+
+export const toUtxoId = (utxo: UtxoI): string => {
+  return [
+    utxo.txid,
+    utxo.vout,
+    utxo.satoshis,
+    utxo.token?.tokenId,
+    utxo.token?.amount,
+    utxo.token?.capability,
+    utxo.token?.commitment,
+  ]
+    .join(DELIMITER)
+    .replace(/:+$/, "");
+};