mainnet-js 0.5.9 → 1.0.0-rc.1

package/src/util/deriveCashaddr.test.ts

@@ -0,0 +1,43 @@
+import { RegTestWallet, Wallet } from "../wallet/Wif";
+import {
+  deriveCashaddr,
+  deriveTokenaddr,
+  isTokenaddr,
+  toCashaddr,
+  toTokenaddr,
+} from "./deriveCashaddr";
+
+test("Should derive cashaddr", async () => {
+  const wallet = await Wallet.newRandom();
+  expect(deriveCashaddr(wallet.privateKey!, wallet.networkPrefix)).toBe(
+    wallet.cashaddr!
+  );
+  expect(deriveTokenaddr(wallet.privateKey!, wallet.networkPrefix)).toBe(
+    wallet.tokenaddr!
+  );
+  expect(deriveTokenaddr(wallet.publicKey!, wallet.networkPrefix)).toBe(
+    wallet.tokenaddr!
+  );
+  expect(
+    deriveTokenaddr(wallet.publicKeyCompressed!, wallet.networkPrefix)
+  ).toBe(wallet.tokenaddr!);
+  expect(deriveTokenaddr(wallet.publicKeyHash!, wallet.networkPrefix)).toBe(
+    wallet.tokenaddr!
+  );
+});
+
+test("Test address conversion", async () => {
+  const wallet = await RegTestWallet.watchOnly(process.env.ADDRESS!);
+  expect(toTokenaddr(wallet.cashaddr!)).toBe(wallet.tokenaddr);
+  expect(toCashaddr(wallet.tokenaddr!)).toBe(wallet.cashaddr);
+
+  expect(toCashaddr(wallet.tokenaddr!)).toBe(
+    "bchreg:qpttdv3qg2usm4nm7talhxhl05mlhms3ys43u76rn0"
+  );
+  expect(toTokenaddr(wallet.cashaddr!)).toBe(
+    "bchreg:zpttdv3qg2usm4nm7talhxhl05mlhms3ysjm0q59vu"
+  );
+
+  expect(isTokenaddr(wallet.cashaddr!)).toBe(false);
+  expect(isTokenaddr(wallet.tokenaddr!)).toBe(true);
+});

package/src/util/deriveCashaddr.ts

@@ -1,17 +1,133 @@
 import {
   CashAddressNetworkPrefix,
-  instantiateSecp256k1,
   encodeCashAddress,
+  CashAddressType,
+  secp256k1,
+  decodeCashAddressFormat,
+  decodeCashAddressFormatWithoutPrefix,
+  CashAddressVersionByte,
 } from "@bitauth/libauth";
 
-import { hash160 } from "./hash160";
+import { hash160 } from "./hash160.js";
 
-export async function deriveCashaddr(
+export function deriveCashaddr(
   privateKey: Uint8Array,
   networkPrefix: CashAddressNetworkPrefix
-) {
-  const secp256k1 = await instantiateSecp256k1();
+): string {
   let publicKey = secp256k1.derivePublicKeyCompressed(privateKey);
-  let pkh = await hash160(publicKey);
-  return encodeCashAddress(networkPrefix, 0, pkh);
+  if (typeof publicKey === "string") {
+    throw new Error(publicKey);
+  }
+  let pkh = hash160(publicKey);
+  return encodeCashAddress(networkPrefix, CashAddressType.p2pkh, pkh);
+}
+
+export function deriveTokenaddr(
+  key: Uint8Array,
+  networkPrefix: CashAddressNetworkPrefix
+): string {
+  let publicKeyHash: Uint8Array;
+  // private key
+  if (key.length === 32) {
+    let publicKeyCompressed = secp256k1.derivePublicKeyCompressed(key);
+    if (typeof publicKeyCompressed === "string") {
+      throw new Error(publicKeyCompressed);
+    }
+    publicKeyHash = hash160(publicKeyCompressed);
+  } else if (key.length === 65) {
+    // uncompressed public key
+    let publicKeyCompressed = secp256k1.compressPublicKey(key);
+    if (typeof publicKeyCompressed === "string") {
+      throw new Error(publicKeyCompressed);
+    }
+    publicKeyHash = hash160(publicKeyCompressed);
+  } else if (key.length === 33) {
+    // compressed public key
+    publicKeyHash = hash160(key);
+  } else if (key.length === 20) {
+    // public key hash
+    publicKeyHash = key;
+  } else {
+    throw new Error("Unsupported type of key");
+  }
+
+  return encodeCashAddress(
+    networkPrefix,
+    CashAddressType.p2pkhWithTokens,
+    publicKeyHash
+  );
+}
+
+export function toCashaddr(tokenaddr: string): string {
+  let result:
+    | string
+    | { payload: Uint8Array; prefix: string; version: number }
+    | undefined;
+
+  // If the address has a prefix decode it as is
+  if (tokenaddr.includes(":")) {
+    result = decodeCashAddressFormat(tokenaddr);
+  }
+  // otherwise, derive the network from the tokenaddr without prefix
+  else {
+    result = decodeCashAddressFormatWithoutPrefix(tokenaddr);
+  }
+
+  if (typeof result === "string") throw new Error(result);
+
+  return encodeCashAddress(
+    result.prefix as CashAddressNetworkPrefix,
+    CashAddressType.p2pkh,
+    result.payload
+  );
+}
+
+export function toTokenaddr(cashaddr: string): string {
+  let result:
+    | string
+    | { payload: Uint8Array; prefix: string; version: number }
+    | undefined;
+
+  // If the address has a prefix decode it as is
+  if (cashaddr.includes(":")) {
+    result = decodeCashAddressFormat(cashaddr);
+  }
+  // otherwise, derive the network from the cashaddr without prefix
+  else {
+    result = decodeCashAddressFormatWithoutPrefix(cashaddr);
+  }
+
+  if (typeof result === "string") throw new Error(result);
+
+  return encodeCashAddress(
+    result.prefix as CashAddressNetworkPrefix,
+    CashAddressType.p2pkhWithTokens,
+    result.payload
+  );
+}
+
+export function isTokenaddr(address: string): boolean {
+  let result:
+    | string
+    | { payload: Uint8Array; prefix: string; version: number }
+    | undefined;
+
+  // If the address has a prefix decode it as is
+  if (address.includes(":")) {
+    result = decodeCashAddressFormat(address);
+  }
+  // otherwise, derive the network from the address without prefix
+  else {
+    result = decodeCashAddressFormatWithoutPrefix(address);
+  }
+
+  if (typeof result === "string") throw new Error(result);
+
+  return (
+    [
+      CashAddressVersionByte.p2pkhWithTokens,
+      CashAddressVersionByte.p2sh20WithTokens,
+      CashAddressVersionByte.p2sh32WithTokens,
+    ].indexOf(result.version) !== -1
+  );
 }

package/src/util/deriveNetwork.ts

@@ -1,5 +1,5 @@
-import { derivePrefix } from "./derivePublicKeyHash";
-import { networkPrefixMap } from "../enum";
+import { derivePrefix } from "./derivePublicKeyHash.js";
+import { networkPrefixMap } from "../enum.js";
 
 // This function if for assuring that a list of addresses are on the name network
 // for a single address use: networkPrefixMap[derivePrefix(address)]

package/src/util/derivePublicKeyHash.test.ts

@@ -43,6 +43,9 @@ test("Should calculate public key hash consistent with hash160", async () => {
   let pkh = derivePublicKeyHash(w.getDepositAddress());
   // manually from compressed public key
   let publicKeyCompressed = secp256k1.derivePublicKeyCompressed(w.privateKey!);
+  if (typeof publicKeyCompressed === "string") {
+    throw new Error(publicKeyCompressed);
+  }
   let pkh2 = ripemd160.hash(sha256.hash(publicKeyCompressed));
   let pkh3 = w.publicKeyHash!;
   expect(pkh2.length).toBe(20);

package/src/util/derivePublicKeyHash.ts

@@ -1,4 +1,5 @@
 import {
+  CashAddressNetworkPrefix,
   decodeCashAddressFormat,
   decodeCashAddressFormatWithoutPrefix,
 } from "@bitauth/libauth";
@@ -11,7 +12,13 @@ import {
  * @returns a public key hash corresponding to the passed address
  */
 export function derivePublicKeyHash(address: string): Uint8Array {
-  let result;
+  let result:
+    | string
+    | {
+        payload: Uint8Array;
+        prefix: string;
+        version: number;
+      };
 
   // If the address has a prefix decode it as is
   if (address.includes(":")) {
@@ -25,7 +32,7 @@ export function derivePublicKeyHash(address: string): Uint8Array {
   if (typeof result === "string") throw new Error(result);
 
   // return the public key hash
-  return result.hash;
+  return result.payload;
 }
 
 /**
@@ -35,8 +42,14 @@ export function derivePublicKeyHash(address: string): Uint8Array {
  *
  * @returns the address prefix
  */
-export function derivePrefix(address: string): string {
-  let result;
+export function derivePrefix(address: string): CashAddressNetworkPrefix {
+  let result:
+    | string
+    | {
+        payload: Uint8Array;
+        prefix: string;
+        version: number;
+      };
 
   if (address.includes(":")) {
     result = decodeCashAddressFormat(address);
@@ -47,5 +60,5 @@ export function derivePrefix(address: string): string {
   if (typeof result === "string") throw new Error(result);
 
   // TODO pass the network in and check it or raise Error
-  return result.prefix;
+  return result.prefix as CashAddressNetworkPrefix;
 }

package/src/util/eventsource.ts

@@ -1,10 +1,12 @@
-import { getRuntimePlatform } from "./getRuntimePlatform";
+import { getRuntimePlatform } from "./getRuntimePlatform.js";
+
+import { default as ES } from "eventsource";
 
 let EventSource;
 if (getRuntimePlatform() != "node") {
   EventSource = globalThis.EventSource;
 } else {
-  EventSource = eval("require")("eventsource/");
+  EventSource = ES;
 }
 
 export default EventSource;

package/src/util/getAddrsByXpubKey.test.ts

@@ -7,7 +7,7 @@ import {
 test("Should decode xpubInfo", async () => {
   let xpub =
     "xpub6BosfCnifzxcFwrSzQiqu2DBVTshkCXacvNsWGYJVVhhawA7d4R5WSWGFNbi8Aw6ZRc1brxMyWMzG3DSSSSoekkudhUd9yLb6qx39T9nMdj";
-  let xpubInfo = await getXpubKeyInfo(xpub);
+  let xpubInfo = getXpubKeyInfo(xpub);
   expect(xpubInfo.version).toBe("mainnet");
   expect(xpubInfo.depth).toBe(3);
   expect(xpubInfo.parentFingerprint).toBe("155bca59");
@@ -57,7 +57,7 @@ test("Should derive list of cashaddrs from m/44'/0'/0' given xpub path, & limit"
   ];
 
   // M/44'/0'/0'/0/i
-  const cashaddrs = await getAddrsByXpubKey(xpub, "0/0", 3);
+  const cashaddrs = getAddrsByXpubKey(xpub, "0/0", 3);
   expect(cashaddrs).toStrictEqual(vectors);
 });
 
@@ -76,7 +76,7 @@ test("Should derive list of change cashaddrs from m/44'/0'/0' given xpub path, &
   ];
 
   // M/44'/0'/0'/0/i
-  const cashaddrs = await getAddrsByXpubKey(xpub, "1/0", 3);
+  const cashaddrs = getAddrsByXpubKey(xpub, "1/0", 3);
   expect(cashaddrs).toStrictEqual(vectors);
 });
 
@@ -94,7 +94,7 @@ test("Should derive list of cashaddrs from M/44'/145'/0' given xpub, path and li
     "bitcoincash:qqkuy34ntrye9a2h4xpdstcu4aq5wfrwscjtaphenr",
   ];
 
-  const cashaddrs = await getAddrsByXpubKey(xpub, "0/0", 3);
+  const cashaddrs = getAddrsByXpubKey(xpub, "0/0", 3);
   expect(cashaddrs).toStrictEqual(vectors);
 });
 test("Should derive list of change cashaddrs from M/44'/145'/0' given xpub, path and limit", async () => {
@@ -110,6 +110,6 @@ test("Should derive list of change cashaddrs from M/44'/145'/0' given xpub, path
     //  M/44'/145'/0'/1/2
     "bitcoincash:qp57cex47jtyhedphe2c63gpzsx3zs0ryvejxly47d",
   ];
-  const cashaddrs = await getAddrsByXpubKey(xpub, "1/0", 3);
+  const cashaddrs = getAddrsByXpubKey(xpub, "1/0", 3);
   expect(cashaddrs).toStrictEqual(vectors);
 });

package/src/util/getAddrsByXpubKey.ts

@@ -1,23 +1,20 @@
 import {
   deriveHdPublicNodeChild,
   decodeHdPublicKey,
-  encodeHdPublicKey,
   encodeCashAddress,
-  instantiateBIP32Crypto,
   deriveHdPath,
-  HdPublicNode,
-  HdKeyNetwork,
   binToHex,
+  CashAddressNetworkPrefix,
+  CashAddressType,
 } from "@bitauth/libauth";
-import path from "path";
 
-import { hash160 } from "./hash160";
+import { hash160 } from "./hash160.js";
 
-export async function getAddrsByXpubKey(
+export function getAddrsByXpubKey(
   xpub: string,
   path: string,
   count: number
-) {
+): Array<string> {
   let pathComponents = path.split("/");
   let rootStr = pathComponents.shift()!;
   let root: number;
@@ -25,7 +22,7 @@ export async function getAddrsByXpubKey(
     rootStr = pathComponents.shift()!;
   }
   root = parseInt(rootStr);
-  let result: any = [];
+  let result: Array<string> = [];
 
   const start = parseInt(pathComponents.pop()!);
   const end = start + count;
@@ -33,29 +30,28 @@ export async function getAddrsByXpubKey(
     let childPath = ["M", root, ...pathComponents, curr].join("/");
     result.push(derivePublicNodeCashaddr(xpub, root, childPath));
   }
-  return await Promise.all(result).then((result) => {
-    return result;
-  });
+  return result;
 }
 
-export async function getAddrsByXpubKeyObject(obj) {
-  return await getAddrsByXpubKey(obj.xpubkey, obj.path, obj.count);
+export function getAddrsByXpubKeyObject(obj): Array<string> {
+  return getAddrsByXpubKey(obj.xpubkey, obj.path, obj.count);
 }
 
-export async function derivePublicNodeCashaddr(
+export function derivePublicNodeCashaddr(
   xpub,
   index: number,
   path?: string
-) {
-  const crypto = await instantiateBIP32Crypto();
-  const publicParent = await decodeHdPublicKey(crypto, xpub);
+): string {
+  const publicParent = decodeHdPublicKey(xpub);
 
   if (typeof publicParent === "string") {
     throw new Error(publicParent);
   }
-  let prefix = publicParent.network === "mainnet" ? "bitcoincash" : "bchtest";
+  let prefix = (
+    publicParent.network === "mainnet" ? "bitcoincash" : "bchtest"
+  ) as CashAddressNetworkPrefix;
 
-  let node = await deriveHdPublicNodeChild(crypto, publicParent.node, index);
+  let node = deriveHdPublicNodeChild(publicParent.node, index);
   if (typeof node === "string") {
     throw new Error(node);
   }
@@ -65,20 +61,19 @@ export async function derivePublicNodeCashaddr(
     if (path[0] !== "M") {
       throw Error("use M for public path derivation");
     }
-    let childNode = deriveHdPath(crypto, publicParent.node, path);
+    let childNode = deriveHdPath(publicParent.node, path);
     if (typeof childNode === "string") {
       throw new Error(childNode);
     } else {
-      let childPkh = await hash160(childNode.publicKey);
-      cashaddr = encodeCashAddress(prefix, 0, childPkh);
+      let childPkh = hash160(childNode.publicKey);
+      cashaddr = encodeCashAddress(prefix, CashAddressType.p2pkh, childPkh);
     }
   }
   return cashaddr;
 }
 
-export async function getXpubKeyInfo(hdPublicKey) {
-  const crypto = await instantiateBIP32Crypto();
-  let node = decodeHdPublicKey(crypto, hdPublicKey);
+export function getXpubKeyInfo(hdPublicKey: string) {
+  let node = decodeHdPublicKey(hdPublicKey);
   if (typeof node === "string") {
     throw new Error(node);
   }
@@ -89,10 +84,10 @@ export async function getXpubKeyInfo(hdPublicKey) {
     childNumber: node.node.childIndex,
     chain: binToHex(node.node.chainCode),
     data: binToHex(node.node.publicKey),
-    fingerprint: binToHex((await hash160(node.node.publicKey)).slice(0, 4)),
+    fingerprint: binToHex(hash160(node.node.publicKey).slice(0, 4)),
   };
 }
 
 export async function getXpubKeyInfoObject(obj) {
-  return await getXpubKeyInfo(obj.xpubkey);
+  return getXpubKeyInfo(obj.xpubkey);
 }

package/src/util/getUsdRate.ts

@@ -1,4 +1,4 @@
-import { ExchangeRate } from "../rate/ExchangeRate";
+import { ExchangeRate } from "../rate/ExchangeRate.js";
 
 export function getUsdRate() {
   return ExchangeRate.get("usd");

package/src/util/getXPubKey.ts

@@ -4,11 +4,10 @@ import {
   deriveHdPublicNode,
   encodeHdPublicKey,
   HdKeyNetwork,
-  instantiateBIP32Crypto,
   hexToBin,
 } from "@bitauth/libauth";
 
-export async function getXPubKey(
+export function getXPubKey(
   seed: Uint8Array | string,
   derivationPath: string,
   network: string
@@ -16,19 +15,18 @@ export async function getXPubKey(
   if (typeof seed === "string") {
     seed = hexToBin(seed);
   }
-  const crypto = await instantiateBIP32Crypto();
-  let hdNode = deriveHdPrivateNodeFromSeed(crypto, seed);
+  let hdNode = deriveHdPrivateNodeFromSeed(seed);
   if (!hdNode.valid) {
     throw Error("Invalid private key derived from mnemonic seed");
   }
 
-  let node = deriveHdPath(crypto, hdNode, derivationPath);
+  let node = deriveHdPath(hdNode, derivationPath);
   if (typeof node === "string") {
     throw node;
   }
-  let parentPublicNode = deriveHdPublicNode(crypto, node);
+  let parentPublicNode = deriveHdPublicNode(node);
 
-  let xPubKey = encodeHdPublicKey(crypto, {
+  let xPubKey = encodeHdPublicKey({
     network: network as HdKeyNetwork,
     node: parentPublicNode,
   });

package/src/util/hash160.test.ts

@@ -3,7 +3,7 @@ import { hexToBin } from "@bitauth/libauth";
 
 test("Should calculate the correct hash from a publicKey", async () => {
   let pk = "02d531ce83a065cdc342b1e709106741bb070ea7aaec29d012f2dba956b9027675";
-  let pkh = await hash160(hexToBin(pk));
+  let pkh = hash160(hexToBin(pk));
   expect(pkh).toStrictEqual(
     hexToBin("e8f538181a07625fc5b2194ea9fa3815f42900a2")
   );
@@ -11,7 +11,7 @@ test("Should calculate the correct hash from a publicKey", async () => {
 
 test("Should calculate the correct hash from a publicKey", async () => {
   let pk = "02b4632d08485ff1df2db55b9dafd23347d1c47a457072a1e87be26896549a8737";
-  let pkh = await hash160(hexToBin(pk));
+  let pkh = hash160(hexToBin(pk));
   expect(pkh).toStrictEqual(
     hexToBin("93ce48570b55c42c2af816aeaba06cfee1224fae")
   );

package/src/util/hash160.ts

@@ -1,4 +1,4 @@
-import { instantiateSha256, instantiateRipemd160 } from "@bitauth/libauth";
+import { ripemd160, sha256 } from "@bitauth/libauth";
 
 /**
  * hash160 - Calculate the sha256, ripemd160 hash of a value
@@ -7,8 +7,6 @@ import { instantiateSha256, instantiateRipemd160 } from "@bitauth/libauth";
  *
  * @returns a promise to the hash160 value of the input
  */
-export async function hash160(message: Uint8Array) {
-  const ripemd160 = await instantiateRipemd160();
-  const sha256 = await instantiateSha256();
+export function hash160(message: Uint8Array) {
   return ripemd160.hash(sha256.hash(message));
 }

package/src/util/index.ts

@@ -1,30 +1,36 @@
-export { amountInSatoshi } from "./amountInSatoshi";
-export { asSendRequestObject } from "./asSendRequestObject";
-export { atob, btoa } from "./base64";
-export { binToHex, hexToBin } from "@bitauth/libauth";
-export { convert, convertObject } from "./convert";
-export { delay } from "./delay";
-export { derivedNetwork } from "./deriveNetwork";
-export { derivePublicKeyHash } from "./derivePublicKeyHash";
+export { amountInSatoshi } from "./amountInSatoshi.js";
+export { asSendRequestObject } from "./asSendRequestObject.js";
+export { atob, btoa } from "./base64.js";
+export {
+  binToHex,
+  hexToBin,
+  utf8ToBin,
+  binToBase64,
+  sha256,
+} from "@bitauth/libauth";
+export { convert, convertObject } from "./convert.js";
+export { delay } from "./delay.js";
+export { derivedNetwork } from "./deriveNetwork.js";
+export { derivePublicKeyHash } from "./derivePublicKeyHash.js";
 export {
   getAddrsByXpubKey,
   getAddrsByXpubKeyObject,
   getXpubKeyInfo,
   getXpubKeyInfoObject,
-} from "../util/getAddrsByXpubKey";
-export { getRuntimePlatform, RuntimePlatform } from "./getRuntimePlatform";
-export { getUsdRate } from "./getUsdRate";
-export { hash160 } from "./hash160";
-export { ExchangeRate } from "../rate/ExchangeRate";
-export { sanitizeAddress } from "./sanitizeAddress";
-export { sanitizeUnit } from "./sanitizeUnit";
-export { getRandomInt } from "./randomInt";
-export { getXPubKey } from "../util/getXPubKey";
-import * as randomValues from "./randomValues";
+} from "../util/getAddrsByXpubKey.js";
+export { getRuntimePlatform, RuntimePlatform } from "./getRuntimePlatform.js";
+export { getUsdRate } from "./getUsdRate.js";
+export { hash160 } from "./hash160.js";
+export { ExchangeRate } from "../rate/ExchangeRate.js";
+export { sanitizeAddress } from "./sanitizeAddress.js";
+export { sanitizeUnit } from "./sanitizeUnit.js";
+export { getRandomInt } from "./randomInt.js";
+export { getXPubKey } from "../util/getXPubKey.js";
+import * as randomValues from "./randomValues.js";
 export { randomValues };
-export { sumUtxoValue } from "./sumUtxoValue";
+export { sumUtxoValue } from "./sumUtxoValue.js";
 export {
   BalanceResponse,
   balanceFromSatoshi,
   balanceResponseFromSatoshi,
-} from "./balanceObjectFromSatoshi";
+} from "./balanceObjectFromSatoshi.js";

package/src/util/randomBytes.ts

@@ -1,10 +1,9 @@
-import { getRuntimePlatform } from "./getRuntimePlatform";
+import { getRuntimePlatform } from "./getRuntimePlatform.js";
+import crypto from "crypto";
 
 export function generateRandomBytes(len = 32) {
   // nodejs
   if (getRuntimePlatform() === "node") {
-    //
-    const crypto = eval("require")("crypto");
     return crypto.randomBytes(len);
   }
   // window, webworkers, service workers

package/src/util/randomValues.ts

@@ -1,13 +1,13 @@
-import { getRuntimePlatform } from "./getRuntimePlatform";
+import { getRuntimePlatform } from "./getRuntimePlatform.js";
+import crypto from "crypto";
 
 if (getRuntimePlatform() === "node") {
   if (!globalThis.crypto || !globalThis.crypto.getRandomValues) {
-    const crypto = require("crypto");
-    globalThis.crypto = crypto;
-    (globalThis.crypto as any).getRandomValues = (buf: Uint8Array) => {
-      const bytes = crypto.randomBytes(buf.length);
-      buf.set(bytes);
-      return buf;
-    };
+    (globalThis as any).crypto = crypto;
+    // (globalThis.crypto as any).getRandomValues = (buf: Uint8Array) => {
+    //   const bytes = crypto.randomBytes(buf.length);
+    //   buf.set(bytes);
+    //   return buf;
+    // };
   }
 }

package/src/util/sanitizeAddress.ts

@@ -1,4 +1,4 @@
-import { derivePrefix } from "./derivePublicKeyHash";
+import { derivePrefix } from "./derivePublicKeyHash.js";
 
 // Assure address is prefixed.
 export function sanitizeAddress(address: string) {

package/src/util/sanitizeUnit.ts

@@ -1,4 +1,4 @@
-import { UnitEnum } from "../enum";
+import { UnitEnum } from "../enum.js";
 
 export function sanitizeUnit(rawUnit: any): UnitEnum {
   if (rawUnit) {

package/src/util/satoshiToAmount.ts

@@ -1,7 +1,7 @@
-import { bchParam } from "../chain";
-import { UnitEnum } from "../enum";
-import { ExchangeRate } from "../rate/ExchangeRate";
-import { sanitizeUnit } from "../util/sanitizeUnit";
+import { bchParam } from "../chain.js";
+import { UnitEnum } from "../enum.js";
+import { ExchangeRate } from "../rate/ExchangeRate.js";
+import { sanitizeUnit } from "../util/sanitizeUnit.js";
 
 /**
  * converts given value and unit from satoshi

package/src/util/sumSendRequestAmounts.ts

@@ -1,15 +1,21 @@
-import { OpReturnData, SendRequest } from "../wallet/model";
-import { amountInSatoshi } from "./amountInSatoshi";
+import {
+  OpReturnData,
+  SendRequest,
+  TokenSendRequest,
+} from "../wallet/model.js";
+import { amountInSatoshi } from "./amountInSatoshi.js";
 
 // This function sums a list of send request objects
 export async function sumSendRequestAmounts(
-  requests: Array<SendRequest | OpReturnData>
+  requests: Array<SendRequest | TokenSendRequest | OpReturnData>
 ) {
   if (requests) {
     const balanceArray: (BigInt | Error)[] = await Promise.all(
-      requests.map(async (r: SendRequest | OpReturnData) => {
+      requests.map(async (r: SendRequest | TokenSendRequest | OpReturnData) => {
         if (r instanceof SendRequest) {
           return BigInt(await amountInSatoshi(r.value, r.unit));
+        } else if (r instanceof TokenSendRequest) {
+          return BigInt(r.value || 1000);
         } else return BigInt(0);
       })
     );