mainnet-js 0.5.9 → 1.0.0-rc.3

package/src/transaction/Wif.ts

@@ -2,34 +2,41 @@
 import {
   authenticationTemplateP2pkhNonHd,
   authenticationTemplateToCompilerBCH,
-  bigIntToBinUint64LEClamped,
   cashAddressToLockingBytecode,
   Compiler,
   encodeTransaction,
   generateTransaction,
-  validateAuthenticationTemplate,
-  TransactionContextCommon,
-  AnyCompilationEnvironment,
-  AuthenticationProgramStateBCH,
+  importAuthenticationTemplate,
+  AnyCompilerConfiguration,
+  AuthenticationProgramStateCommon,
+  CompilationContextBCH,
+  Output,
+  hexToBin,
+  binToHex,
 } from "@bitauth/libauth";
-import { UtxoI } from "../interface";
-import { allocateFee } from "./allocateFee";
+import { NFTCapability, TokenI, UtxoI } from "../interface.js";
+import { allocateFee } from "./allocateFee.js";
 
-import { DUST_UTXO_THRESHOLD } from "../constant";
-import { OpReturnData, SendRequest } from "../wallet/model";
-import { amountInSatoshi } from "../util/amountInSatoshi";
-import { sumSendRequestAmounts } from "../util/sumSendRequestAmounts";
-import { sumUtxoValue } from "../util/sumUtxoValue";
-import { FeePaidByEnum } from "../wallet/enum";
+import { DUST_UTXO_THRESHOLD } from "../constant.js";
+import {
+  OpReturnData,
+  SendRequest,
+  SendRequestType,
+  TokenSendRequest,
+} from "../wallet/model.js";
+import { amountInSatoshi } from "../util/amountInSatoshi.js";
+import { sumSendRequestAmounts } from "../util/sumSendRequestAmounts.js";
+import { sumUtxoValue } from "../util/sumUtxoValue.js";
+import { FeePaidByEnum } from "../wallet/enum.js";
 
 // Build a transaction for a p2pkh transaction for a non HD wallet
 export async function buildP2pkhNonHdTransaction(
   inputs: UtxoI[],
-  outputs: Array<SendRequest | OpReturnData>,
+  outputs: Array<SendRequest | TokenSendRequest | OpReturnData>,
   signingKey: Uint8Array,
   fee: number = 0,
   discardChange = false,
-  slpOutputs: any[] = [],
+  slpOutputs: Output[] = [],
   feePaidBy: FeePaidByEnum = FeePaidByEnum.change,
   changeAddress: string = ""
 ) {
@@ -37,7 +44,7 @@ export async function buildP2pkhNonHdTransaction(
     throw new Error("Missing signing key when building transaction");
   }
 
-  const template = validateAuthenticationTemplate(
+  const template = importAuthenticationTemplate(
     authenticationTemplateP2pkhNonHd
   );
   if (typeof template === "string") {
@@ -49,53 +56,52 @@ export async function buildP2pkhNonHdTransaction(
 
   const sendAmount = await sumSendRequestAmounts(outputs);
 
-  try {
-    const changeAmount = BigInt(inputAmount) - BigInt(sendAmount) - BigInt(fee);
+  const changeAmount = BigInt(inputAmount) - BigInt(sendAmount) - BigInt(fee);
 
-    outputs = allocateFee(outputs, fee, feePaidBy, changeAmount);
+  outputs = allocateFee(outputs, fee, feePaidBy, changeAmount);
 
-    let lockedOutputs = await prepareOutputs(outputs);
+  let lockedOutputs = await prepareOutputs(outputs, inputs);
 
-    if (discardChange !== true) {
-      if (changeAmount > DUST_UTXO_THRESHOLD) {
-        let changeLockingBytecode;
-        if (changeAddress) {
-          changeLockingBytecode = cashAddressToLockingBytecode(changeAddress);
-        } else {
-          // Get the change locking bytecode
-          changeLockingBytecode = compiler.generateBytecode("lock", {
+  if (discardChange !== true) {
+    if (changeAmount > DUST_UTXO_THRESHOLD) {
+      let changeLockingBytecode;
+      if (changeAddress) {
+        changeLockingBytecode = cashAddressToLockingBytecode(changeAddress);
+      } else {
+        // Get the change locking bytecode
+        changeLockingBytecode = compiler.generateBytecode({
+          scriptId: "lock",
+          data: {
             keys: { privateKeys: { key: signingKey } },
-          });
-        }
-        if (typeof changeLockingBytecode === "string") {
-          throw new Error(changeLockingBytecode);
-        }
-        lockedOutputs.push({
-          lockingBytecode: changeLockingBytecode.bytecode,
-          satoshis: bigIntToBinUint64LEClamped(BigInt(changeAmount)),
+          },
         });
       }
+      if (typeof changeLockingBytecode === "string") {
+        throw new Error(changeLockingBytecode);
+      }
+      lockedOutputs.push({
+        lockingBytecode: changeLockingBytecode.bytecode,
+        valueSatoshis: BigInt(changeAmount),
+      });
     }
-
-    let signedInputs = prepareInputs(inputs, compiler, signingKey);
-    const result = generateTransaction({
-      inputs: signedInputs,
-      locktime: 0,
-      outputs: [...slpOutputs, ...lockedOutputs],
-      version: 2,
-    });
-    return result;
-  } catch (error: any) {
-    throw Error(error.toString());
   }
+
+  let signedInputs = prepareInputs(inputs, compiler, signingKey);
+  const result = generateTransaction({
+    inputs: signedInputs,
+    locktime: 0,
+    outputs: [...slpOutputs, ...lockedOutputs],
+    version: 2,
+  });
+  return result;
 }
 
 export function prepareInputs(
   inputs: UtxoI[],
   compiler: Compiler<
-    TransactionContextCommon,
-    AnyCompilationEnvironment<TransactionContextCommon>,
-    AuthenticationProgramStateBCH
+    CompilationContextBCH,
+    AnyCompilerConfiguration<CompilationContextBCH>,
+    AuthenticationProgramStateCommon
   >,
   signingKey: Uint8Array
 ) {
@@ -112,6 +118,18 @@ export function prepareInputs(
     if (!utxoOutpointTransactionHash || utxoIndex === undefined) {
       throw new Error("Missing unspent outpoint when building transaction");
     }
+
+    const libAuthToken = i.token && {
+      amount: BigInt(i.token.amount),
+      category: hexToBin(i.token.tokenId),
+      nft:
+        i.token.capability || i.token.commitment
+          ? {
+              capability: i.token.capability,
+              commitment: i.token.commitment && hexToBin(i.token.commitment!),
+            }
+          : undefined,
+    };
     let newInput = {
       outpointIndex: utxoIndex,
       outpointTransactionHash: utxoOutpointTransactionHash,
@@ -121,8 +139,9 @@ export function prepareInputs(
         data: {
           keys: { privateKeys: { key: signingKey } },
         },
-        satoshis: bigIntToBinUint64LEClamped(BigInt(utxoTxnValue)),
+        valueSatoshis: BigInt(utxoTxnValue),
         script: "unlock",
+        token: libAuthToken,
       },
     };
     signedInputs.push(newInput);
@@ -138,37 +157,34 @@ export function prepareInputs(
  * @returns A promise to a list of unspent outputs
  */
 export async function prepareOutputs(
-  outputs: Array<SendRequest | OpReturnData>
+  outputs: Array<SendRequest | TokenSendRequest | OpReturnData>,
+  inputs: UtxoI[]
 ) {
-  let lockedOutputs: any[] = [];
+  let lockedOutputs: Output[] = [];
   for (const output of outputs) {
-    if (output instanceof OpReturnData) {
-      lockedOutputs.push(prepareOpReturnOutput(output));
+    if (output instanceof TokenSendRequest) {
+      lockedOutputs.push(prepareTokenOutputs(output, inputs));
       continue;
     }
 
-    let outputLockingBytecode = cashAddressToLockingBytecode(output.cashaddr);
-    if (
-      !outputLockingBytecode.hasOwnProperty("bytecode") ||
-      !outputLockingBytecode.hasOwnProperty("prefix")
-    ) {
-      throw new Error(outputLockingBytecode.toString());
+    if (output instanceof OpReturnData) {
+      lockedOutputs.push(prepareOpReturnOutput(output));
+      continue;
     }
 
-    outputLockingBytecode = outputLockingBytecode as {
-      bytecode: Uint8Array;
-      prefix: string;
-    };
+    const outputLockingBytecode = cashAddressToLockingBytecode(output.cashaddr);
+    if (typeof outputLockingBytecode === "string")
+      throw new Error(outputLockingBytecode);
 
-    let sendAmount = await amountInSatoshi(output.value, output.unit);
+    const sendAmount = await amountInSatoshi(output.value, output.unit);
     if (sendAmount % 1 !== 0) {
       throw Error(
         `Cannot send ${sendAmount} satoshis, (fractional sats do not exist, yet), please use an integer number.`
       );
     }
-    let lockedOutput = {
+    const lockedOutput: Output = {
       lockingBytecode: outputLockingBytecode.bytecode,
-      satoshis: bigIntToBinUint64LEClamped(BigInt(sendAmount)),
+      valueSatoshis: BigInt(sendAmount),
     };
     lockedOutputs.push(lockedOutput);
   }
@@ -180,11 +196,80 @@ export async function prepareOutputs(
  *
  * @returns A promise to a list of unspent outputs
  */
-export function prepareOpReturnOutput(request: OpReturnData) {
+export function prepareOpReturnOutput(request: OpReturnData): Output {
   return {
     lockingBytecode: request.buffer,
-    satoshis: bigIntToBinUint64LEClamped(BigInt(0)),
+    valueSatoshis: BigInt(0),
+  };
+}
+
+/**
+ * prepareOpReturnOutput - create an output for token data
+ *
+ * @returns A libauth Output
+ */
+export function prepareTokenOutputs(
+  request: TokenSendRequest,
+  inputs: UtxoI[]
+): Output {
+  const token: TokenI = request;
+  const isGenesis = !request.tokenId || (request as any)._isGenesis;
+  let satValue = 0;
+  if (isGenesis) {
+    const genesisInputs = inputs.filter((val) => val.vout === 0);
+    if (genesisInputs.length === 0) {
+      throw new Error(
+        "No suitable inputs with vout=0 available for new token genesis"
+      );
+    }
+    token.tokenId = genesisInputs[0].txid;
+    satValue = request.value || 1000;
+    (request as any)._isGenesis = true;
+  } else {
+    const tokenInputs = inputs.filter(
+      (val) => val.token?.tokenId === request.tokenId
+    );
+    if (!tokenInputs.length) {
+      throw new Error(`No token utxos available to send ${request.tokenId}`);
+    }
+    if (!token.capability && tokenInputs[0].token?.capability) {
+      token.capability = tokenInputs[0].token!.capability;
+    }
+    if (!token.commitment && tokenInputs[0].token?.commitment) {
+      token.commitment = tokenInputs[0].token!.commitment;
+    }
+
+    if (
+      token.capability === NFTCapability.none &&
+      token.commitment !== tokenInputs[0].token?.commitment
+    ) {
+      throw new Error("Can not change the commitment of an immutable token");
+    }
+
+    satValue = request.value || tokenInputs[0].satoshis;
+  }
+
+  let outputLockingBytecode = cashAddressToLockingBytecode(request.cashaddr);
+  if (typeof outputLockingBytecode === "string")
+    throw new Error(outputLockingBytecode);
+
+  const libAuthToken = {
+    amount: BigInt(token.amount),
+    category: hexToBin(token.tokenId),
+    nft:
+      token.capability || token.commitment
+        ? {
+            capability: token.capability,
+            commitment: token.commitment && hexToBin(token.commitment!),
+          }
+        : undefined,
   };
+
+  return {
+    lockingBytecode: outputLockingBytecode.bytecode,
+    valueSatoshis: BigInt(satValue),
+    token: libAuthToken,
+  } as Output;
 }
 
 /**
@@ -197,14 +282,55 @@ export function prepareOpReturnOutput(request: OpReturnData) {
  * @returns A promise to a list of unspent outputs
  */
 export async function getSuitableUtxos(
-  unspentOutputs: UtxoI[],
+  inputs: UtxoI[],
   amountRequired: BigInt | undefined,
   bestHeight: number,
-  feePaidBy: FeePaidByEnum
+  feePaidBy: FeePaidByEnum,
+  requests: SendRequestType[]
 ): Promise<UtxoI[]> {
   let suitableUtxos: UtxoI[] = [];
   let amountAvailable = BigInt(0);
-  for (const u of unspentOutputs) {
+  const tokenAmountsRequired: any[] = [];
+  const tokenRequests = requests.filter(
+    (val) => val instanceof TokenSendRequest
+  ) as TokenSendRequest[];
+  const tokenIds = tokenRequests
+    .map((val) => val.tokenId)
+    .filter((value, index, array) => array.indexOf(value) === index);
+  for (let tokenId of tokenIds) {
+    const requiredAmount = tokenRequests
+      .map((val) => val.amount)
+      .reduce((prev, cur) => prev + cur, 0);
+    tokenAmountsRequired.push({ tokenId, requiredAmount });
+  }
+
+  let filteredInputs = inputs.slice(0);
+
+  // find suitable token inputs first
+  for (const { tokenId, requiredAmount } of tokenAmountsRequired) {
+    let tokenAmountAvailable = 0;
+    for (const input of inputs) {
+      if (input.token?.tokenId === tokenId) {
+        suitableUtxos.push(input);
+        const inputIndex = filteredInputs.indexOf(input);
+        filteredInputs = filteredInputs.filter(
+          (_, index) => inputIndex !== index
+        );
+        tokenAmountAvailable += input.token!.amount;
+        amountAvailable += BigInt(input.satoshis);
+        if (tokenAmountAvailable >= requiredAmount) {
+          break;
+        }
+      }
+    }
+  }
+
+  // find plain outputs
+  for (const u of filteredInputs) {
+    if (u.token) {
+      // continue;
+    }
+
     if (u.coinbase && u.height && bestHeight) {
       let age = bestHeight - u.height;
       if (age > 100) {
@@ -252,10 +378,10 @@ export async function getFeeAmount({
   feePaidBy,
 }: {
   utxos: UtxoI[];
-  sendRequests: Array<SendRequest | OpReturnData>;
+  sendRequests: Array<SendRequest | TokenSendRequest | OpReturnData>;
   privateKey: Uint8Array;
   relayFeePerByteInSatoshi: number;
-  slpOutputs: any[];
+  slpOutputs: Output[];
   feePaidBy: FeePaidByEnum;
 }) {
   // build transaction
@@ -282,11 +408,11 @@ export async function getFeeAmount({
 // Build encoded transaction
 export async function buildEncodedTransaction(
   fundingUtxos: UtxoI[],
-  sendRequests: Array<SendRequest | OpReturnData>,
+  sendRequests: Array<SendRequest | TokenSendRequest | OpReturnData>,
   privateKey: Uint8Array,
   fee: number = 0,
   discardChange = false,
-  slpOutputs: any[] = [],
+  slpOutputs: Output[] = [],
   feePaidBy: FeePaidByEnum = FeePaidByEnum.change,
   changeAddress: string = ""
 ) {

package/src/transaction/allocateFee.ts

@@ -1,6 +1,10 @@
-import { OpReturnData, SendRequest } from "../wallet/model";
-import { FeePaidByEnum } from "../wallet/enum";
-import { DUST_UTXO_THRESHOLD } from "../constant";
+import {
+  OpReturnData,
+  SendRequest,
+  TokenSendRequest,
+} from "../wallet/model.js";
+import { FeePaidByEnum } from "../wallet/enum.js";
+import { DUST_UTXO_THRESHOLD } from "../constant.js";
 
 export function checkFeeForDust(value: number) {
   if (value < DUST_UTXO_THRESHOLD) {
@@ -20,12 +24,17 @@ export function checkSatsAvailable(
   }
 }
 
-export function checkForOpReturn(
-  output: SendRequest | OpReturnData
+export function checkForNonStandardSendRequest(
+  output: SendRequest | TokenSendRequest | OpReturnData
 ): SendRequest {
+  if (output instanceof TokenSendRequest) {
+    throw Error("Cannot specify fee to be paid by TokenSendRequest");
+  }
+
   if (output instanceof OpReturnData) {
     throw Error("Cannot specify fee to be paid by OpReturnData");
   }
+
   return output;
 }
 
@@ -40,7 +49,7 @@ function distributeFees(requests: Array<SendRequest>, fee: number) {
   fee = Number(fee);
   for (let r = 0; r < requests.length; r++) {
     if (fee > 0) {
-      checkForOpReturn(requests[r]);
+      checkForNonStandardSendRequest(requests[r]);
       let perRequestFee = Math.floor(fee / (requests.length - r));
       perRequestFee += fee % (requests.length - r);
       if (requests[r].value - perRequestFee < DUST_UTXO_THRESHOLD) {
@@ -55,25 +64,34 @@ function distributeFees(requests: Array<SendRequest>, fee: number) {
   return requests.filter((r) => r.value >= DUST_UTXO_THRESHOLD);
 }
 
-function firstPays(requests: Array<SendRequest | OpReturnData>, fee: number) {
+function firstPays(
+  requests: Array<SendRequest | TokenSendRequest | OpReturnData>,
+  fee: number
+) {
   let payer = requests.shift()!;
-  payer = checkForOpReturn(payer);
+  payer = checkForNonStandardSendRequest(payer);
   payer.value = payer.value! - fee;
   checkFeeForDust(payer.value);
   requests.unshift(payer);
   return requests;
 }
-function lastPays(requests: Array<SendRequest | OpReturnData>, fee: number) {
+function lastPays(
+  requests: Array<SendRequest | TokenSendRequest | OpReturnData>,
+  fee: number
+) {
   let payer = requests.pop()!;
-  payer = checkForOpReturn(payer);
+  payer = checkForNonStandardSendRequest(payer);
   payer.value = payer.value! - fee;
   checkFeeForDust(payer.value);
   requests.push(payer);
   return requests;
 }
-function anyPays(requests: Array<SendRequest | OpReturnData>, fee: number) {
+function anyPays(
+  requests: Array<SendRequest | TokenSendRequest | OpReturnData>,
+  fee: number
+) {
   for (let r of requests) {
-    checkForOpReturn(r);
+    checkForNonStandardSendRequest(r);
   }
   requests = sortSendRequests(requests as Array<SendRequest>);
   requests = distributeFees(requests as Array<SendRequest>, fee);
@@ -81,7 +99,7 @@ function anyPays(requests: Array<SendRequest | OpReturnData>, fee: number) {
 }
 
 function changeThenFallback(
-  requests: Array<SendRequest | OpReturnData>,
+  requests: Array<SendRequest | TokenSendRequest | OpReturnData>,
   fee: number,
   change: bigint,
   fallbackFn: Function
@@ -94,7 +112,7 @@ function changeThenFallback(
 }
 
 export function allocateFee(
-  requests: Array<SendRequest | OpReturnData>,
+  requests: Array<SendRequest | TokenSendRequest | OpReturnData>,
   fee: number,
   feePaidBy: FeePaidByEnum,
   change: bigint

package/src/util/amountInSatoshi.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 into satoshi

package/src/util/asSendRequestObject.ts

@@ -1,51 +1,63 @@
 import { base64ToBin } from "@bitauth/libauth";
-import { UnitEnum } from "../enum";
-import { OpReturnData, SendRequest, SendRequestArray } from "../wallet/model";
+import { UnitEnum } from "../enum.js";
+import {
+  OpReturnData,
+  SendRequest,
+  SendRequestArray,
+  TokenSendRequest,
+} from "../wallet/model.js";
 
 export function asSendRequestObject(
   requests:
     | SendRequest
+    | TokenSendRequest
     | OpReturnData
-    | Array<SendRequest | OpReturnData>
+    | Array<SendRequest | TokenSendRequest | OpReturnData>
     | Array<SendRequestArray>
-): Array<SendRequest | OpReturnData> {
-  let resp: Array<SendRequest | OpReturnData> = [];
+): Array<SendRequest | TokenSendRequest | OpReturnData> {
+  let resp: Array<SendRequest | TokenSendRequest | OpReturnData> = [];
   if (Array.isArray(requests)) {
-    requests.forEach((r: SendRequest | OpReturnData | SendRequestArray) => {
-      // the SendRequestArray[] case
-      if (Array.isArray(r)) {
-        if (r[0] === "OP_RETURN") {
-          // ['OP_RETURN', Buffer.new('MEMO\x10')],
-          resp.push(OpReturnData.from(r[1] as string | Buffer));
-        } else if (r[0] === "OP_RETURNB64") {
-          resp.push(
-            OpReturnData.fromBuffer(Buffer.from(base64ToBin(r[1] as string)))
-          );
+    requests.forEach(
+      (r: SendRequest | TokenSendRequest | OpReturnData | SendRequestArray) => {
+        // the SendRequestArray[] case
+        if (Array.isArray(r)) {
+          if (r[0] === "OP_RETURN") {
+            // ['OP_RETURN', Buffer.new('MEMO\x10')],
+            resp.push(OpReturnData.from(r[1] as string | Buffer));
+          } else if (r[0] === "OP_RETURNB64") {
+            resp.push(
+              OpReturnData.fromBuffer(Buffer.from(base64ToBin(r[1] as string)))
+            );
+          } else {
+            // ['cashaddr', 120, 'sats'],
+            resp.push(
+              new SendRequest({
+                cashaddr: r[0] as string,
+                value: r[1] as number,
+                unit: r[2] as UnitEnum,
+              })
+            );
+          }
         } else {
-          // ['cashaddr', 120, 'sats'],
-          resp.push(
-            new SendRequest({
-              cashaddr: r[0] as string,
-              value: r[1] as number,
-              unit: r[2] as UnitEnum,
-            })
-          );
+          // SendRequest | TokenSendRequest | OpReturnRequest case
+          resp.push(convertToClass(r));
         }
-      } else {
-        // SendRequest | OpReturnRequest case
-        resp.push(convertToClass(r));
       }
-    });
+    );
   } else {
     // the SendRequest | OpReturnData object case
-    resp.push(convertToClass(requests as SendRequest | OpReturnData));
+    resp.push(
+      convertToClass(requests as SendRequest | TokenSendRequest | OpReturnData)
+    );
   }
   return resp;
 }
 
-function convertToClass(object: SendRequest | OpReturnData) {
-  if (object.hasOwnProperty("cashaddr")) {
+function convertToClass(object: SendRequest | TokenSendRequest | OpReturnData) {
+  if (object.hasOwnProperty("unit")) {
     return new SendRequest(object as SendRequest);
+  } else if (object.hasOwnProperty("tokenId")) {
+    return new TokenSendRequest(object as TokenSendRequest);
   } else if (object.hasOwnProperty("buffer")) {
     return OpReturnData.fromBuffer((object as OpReturnData).buffer);
   }

package/src/util/balanceObjectFromSatoshi.ts

@@ -1,8 +1,8 @@
-import { bchParam } from "../chain";
-import { UnitEnum } from "../enum";
-import { floor } from "./floor";
-import { ExchangeRate } from "../rate/ExchangeRate";
-import { sanitizeUnit } from "./sanitizeUnit";
+import { bchParam } from "../chain.js";
+import { UnitEnum } from "../enum.js";
+import { floor } from "./floor.js";
+import { ExchangeRate } from "../rate/ExchangeRate.js";
+import { sanitizeUnit } from "./sanitizeUnit.js";
 
 export class BalanceResponse {
   bch?: number;

package/src/util/base64.ts

@@ -1,31 +1,12 @@
-import { getRuntimePlatform } from "./getRuntimePlatform";
+import { base64ToBin, binToBase64, isBase64 } from "@bitauth/libauth";
 
 export function btoa(data: string) {
-  if (getRuntimePlatform() !== "node") {
-    return globalThis.btoa(data);
-  } else {
-    const btoa = (str: any) => {
-      var buffer;
-
-      if (str instanceof Buffer) {
-        buffer = str;
-      } else {
-        buffer = Buffer.from(str.toString(), "binary");
-      }
-
-      return buffer.toString("base64");
-    };
-    return btoa(data);
-  }
+  return binToBase64(new TextEncoder().encode(data));
 }
 
 export function atob(data: string) {
-  if (getRuntimePlatform() !== "node") {
-    return globalThis.atob(data);
-  } else {
-    const atob = (str: string) => {
-      return Buffer.from(str, "base64").toString("binary");
-    };
-    return atob(data);
+  if (!isBase64(data)) {
+    throw new Error("Provided data is not a valid base64");
   }
+  return String.fromCharCode(...base64ToBin(data));
 }

package/src/util/browserNotSupported.ts

@@ -1,4 +1,4 @@
-import { getRuntimePlatform } from "./getRuntimePlatform";
+import { getRuntimePlatform } from "./getRuntimePlatform.js";
 
 export function browserNotSupported() {
   if (getRuntimePlatform() !== "node") {

package/src/util/checkWifNetwork.ts

@@ -1,4 +1,4 @@
-import { NetworkType } from "../enum";
+import { NetworkType } from "../enum.js";
 
 export function checkWifNetwork(
   walletImportFormatString: string,

package/src/util/convert.ts

@@ -1,5 +1,5 @@
-import { amountInSatoshi } from "./amountInSatoshi";
-import { satoshiToAmount } from "./satoshiToAmount";
+import { amountInSatoshi } from "./amountInSatoshi.js";
+import { satoshiToAmount } from "./satoshiToAmount.js";
 
 /**
  * convert transforms unit of measurement for some monetary value