mainnet-js 2.4.3 → 2.6.0

package/src/util/deriveCashaddr.ts

@@ -9,6 +9,7 @@ import {
   decodeCashAddress,
   cashAddressTypeBitsToType,
   decodeCashAddressVersionByte,
+  assertSuccess,
 } from "@bitauth/libauth";
 
 import { hash160 } from "./hash160.js";
@@ -31,7 +32,11 @@ export function deriveCashaddr(
     throw new Error(publicKey);
   }
   let pkh = hash160(publicKey);
-  return encodeCashAddress(networkPrefix, CashAddressType.p2pkh, pkh);
+  return encodeCashAddress({
+    prefix: networkPrefix,
+    type: CashAddressType.p2pkh,
+    payload: pkh,
+  }).address;
 }
 
 export function deriveTokenaddr(
@@ -63,11 +68,11 @@ export function deriveTokenaddr(
     throw new Error("Unsupported type of key");
   }
 
-  return encodeCashAddress(
-    networkPrefix,
-    CashAddressType.p2pkhWithTokens,
-    publicKeyHash
-  );
+  return encodeCashAddress({
+    prefix: networkPrefix,
+    type: CashAddressType.p2pkhWithTokens,
+    payload: publicKeyHash,
+  }).address;
 }
 
 export function toCashaddr(tokenaddr: string): string {
@@ -87,11 +92,11 @@ export function toCashaddr(tokenaddr: string): string {
 
   if (typeof result === "string") throw new Error(result);
 
-  return encodeCashAddress(
-    result.prefix as CashAddressNetworkPrefix,
-    CashAddressType.p2pkh,
-    result.payload
-  );
+  return encodeCashAddress({
+    prefix: result.prefix as CashAddressNetworkPrefix,
+    type: CashAddressType.p2pkh,
+    payload: result.payload,
+  }).address;
 }
 
 export function toTokenaddr(cashaddr: string): string {
@@ -111,11 +116,11 @@ export function toTokenaddr(cashaddr: string): string {
 
   if (typeof result === "string") throw new Error(result);
 
-  return encodeCashAddress(
-    result.prefix as CashAddressNetworkPrefix,
-    CashAddressType.p2pkhWithTokens,
-    result.payload
-  );
+  return encodeCashAddress({
+    prefix: result.prefix as CashAddressNetworkPrefix,
+    type: CashAddressType.p2pkhWithTokens,
+    payload: result.payload,
+  }).address;
 }
 
 export function isTokenaddr(address: string): boolean {

package/src/util/getAddrsByXpubKey.test.ts

@@ -23,7 +23,7 @@ test("Should decode xpubInfo", async () => {
 
 test("Should derive cashaddr given xpub and path", async () => {
   // abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about
-  // m/0
+  // m/44'/145'/0'/0/
   const xpub =
     "xpub6F2iaK2JUPcgrZ6RTGH6t8VybLPu1XzfrHsDsaKvK6NfULznU6i6aw6ZoefDW2DpNruSLw73RwQg46qvpqB3eryeJJ2tkFCF4Z6gbr8Pjja";
   const vectors = [
@@ -37,7 +37,7 @@ test("Should derive cashaddr given xpub and path", async () => {
 
   for (let i = 0; i < vectors.length; i++) {
     // M/44'/145'/0'/0/
-    const publicNode = await derivePublicNodeCashaddr(xpub, 0, `M/${i}`);
+    const publicNode = derivePublicNodeCashaddr(xpub, `${i}`);
     expect(publicNode).toBe(vectors[i]);
   }
 });
@@ -82,7 +82,7 @@ test("Should derive list of change cashaddrs from m/44'/0'/0' given xpub path, &
 
 test("Should derive list of cashaddrs from M/44'/145'/0' given xpub, path and limit", async () => {
   // abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about
-  // m/0
+  // m/44'/145'/0'
   const xpub =
     "xpub6ByHsPNSQXTWZ7PLESMY2FufyYWtLXagSUpMQq7Un96SiThZH2iJB1X7pwviH1WtKVeDP6K8d6xxFzzoaFzF3s8BKCZx8oEDdDkNnp4owAZ";
   const vectors = [
@@ -99,7 +99,7 @@ test("Should derive list of cashaddrs from M/44'/145'/0' given xpub, path and li
 });
 test("Should derive list of change cashaddrs from M/44'/145'/0' given xpub, path and limit", async () => {
   // abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about
-  // m/0
+  // m/44'/145'/0'
   const xpub =
     "xpub6ByHsPNSQXTWZ7PLESMY2FufyYWtLXagSUpMQq7Un96SiThZH2iJB1X7pwviH1WtKVeDP6K8d6xxFzzoaFzF3s8BKCZx8oEDdDkNnp4owAZ";
   const vectors = [

package/src/util/getAddrsByXpubKey.ts

@@ -1,34 +1,35 @@
 import {
-  deriveHdPublicNodeChild,
   decodeHdPublicKey,
   encodeCashAddress,
-  deriveHdPath,
   binToHex,
   CashAddressNetworkPrefix,
   CashAddressType,
+  deriveHdPathRelative,
 } from "@bitauth/libauth";
 
 import { hash160 } from "./hash160.js";
 
+/**
+ * Derive cashsaddresses given the `xpub`, relative `path` and count of addresses to derive.
+ *
+ * @param xpub the parent xpubkey from which to derive child public keys, for example `xpub6ByHsPNSQXTWZ7PLESMY2FufyYWtLXagSUpMQq7Un96SiThZH2iJB1X7pwviH1WtKVeDP6K8d6xxFzzoaFzF3s8BKCZx8oEDdDkNnp4owAZ` at `m/44'/145'/0'`
+ * @param path relative path from the parent xpubkey to derive the child public keys, for example "0/0" for receiving addresses or "1/0" for change addresses
+ * @param count amount of child public keys to derive
+ * @returns array of cashaddresses derived from the xpubkey
+ */
 export function getAddrsByXpubKey(
   xpub: string,
   path: string,
   count: number
 ): Array<string> {
-  let pathComponents = path.split("/");
-  let rootStr = pathComponents.shift()!;
-  let root: number;
-  if (rootStr === "M" || rootStr === "m") {
-    rootStr = pathComponents.shift()!;
-  }
-  root = parseInt(rootStr);
-  let result: Array<string> = [];
+  const pathComponents = path.split("/");
+  const result: Array<string> = [];
 
   const start = parseInt(pathComponents.pop()!);
   const end = start + count;
   for (let curr = start; curr < end; curr++) {
-    let childPath = ["M", root, ...pathComponents, curr].join("/");
-    result.push(derivePublicNodeCashaddr(xpub, root, childPath));
+    const childPath = [...pathComponents, curr].join("/");
+    result.push(derivePublicNodeCashaddr(xpub, childPath));
   }
   return result;
 }
@@ -37,43 +38,35 @@ export function getAddrsByXpubKeyObject(obj): Array<string> {
   return getAddrsByXpubKey(obj.xpubkey, obj.path, obj.count);
 }
 
-export function derivePublicNodeCashaddr(
-  xpub,
-  index: number,
-  path?: string
-): string {
+export function derivePublicNodeCashaddr(xpub: string, path?: string): string {
   const publicParent = decodeHdPublicKey(xpub);
 
   if (typeof publicParent === "string") {
     throw new Error(publicParent);
   }
-  let prefix = (
+  const prefix = (
     publicParent.network === "mainnet" ? "bitcoincash" : "bchtest"
   ) as CashAddressNetworkPrefix;
 
-  let node = deriveHdPublicNodeChild(publicParent.node, index);
-  if (typeof node === "string") {
-    throw new Error(node);
-  }
-
   let cashaddr;
   if (typeof path === "string") {
-    if (path[0] !== "M") {
-      throw Error("use M for public path derivation");
-    }
-    let childNode = deriveHdPath(publicParent.node, path);
+    const childNode = deriveHdPathRelative(publicParent.node, path);
     if (typeof childNode === "string") {
       throw new Error(childNode);
     } else {
-      let childPkh = hash160(childNode.publicKey);
-      cashaddr = encodeCashAddress(prefix, CashAddressType.p2pkh, childPkh);
+      const childPkh = hash160(childNode.publicKey);
+      cashaddr = encodeCashAddress({
+        prefix,
+        type: CashAddressType.p2pkh,
+        payload: childPkh,
+      }).address;
     }
   }
   return cashaddr;
 }
 
 export function getXpubKeyInfo(hdPublicKey: string) {
-  let node = decodeHdPublicKey(hdPublicKey);
+  const node = decodeHdPublicKey(hdPublicKey);
   if (typeof node === "string") {
     throw new Error(node);
   }

package/src/util/getXPubKey.ts

@@ -15,10 +15,10 @@ export function getXPubKey(
   if (typeof seed === "string") {
     seed = hexToBin(seed);
   }
-  let hdNode = deriveHdPrivateNodeFromSeed(seed);
-  if (!hdNode.valid) {
-    throw Error("Invalid private key derived from mnemonic seed");
-  }
+  let hdNode = deriveHdPrivateNodeFromSeed(seed, {
+    assumeValidity: true, // TODO: we should switch to libauth's BIP39 implementation and set this to false
+    throwErrors: true,
+  });
 
   let node = deriveHdPath(hdNode, derivationPath);
   if (typeof node === "string") {
@@ -26,9 +26,14 @@ export function getXPubKey(
   }
   let parentPublicNode = deriveHdPublicNode(node);
 
-  let xPubKey = encodeHdPublicKey({
-    network: network as HdKeyNetwork,
-    node: parentPublicNode,
-  });
+  let xPubKey = encodeHdPublicKey(
+    {
+      network: network as HdKeyNetwork,
+      node: parentPublicNode,
+    },
+    {
+      throwErrors: true,
+    }
+  ).hdPublicKey;
   return xPubKey;
 }

package/src/util/header.ts

@@ -1,15 +1,16 @@
+import { assertSuccess, binToHex, hexToBin, readUint32LE } from "@bitauth/libauth";
 import { HeaderI, HexHeaderI } from "../interface";
 
 export const decodeHeader = (hexHeader: HexHeaderI): HeaderI => {
   const result = {} as HeaderI;
 
-  const header = Buffer.from(hexHeader.hex, "hex");
-  result.version = header.readUInt32LE(0);
-  result.previousBlockHash = header.subarray(4, 36).reverse().toString("hex");
-  result.merkleRoot = header.subarray(36, 68).reverse().toString("hex");
-  result.timestamp = header.readUInt32LE(68);
-  result.bits = header.readUInt32LE(72);
-  result.nonce = header.readUInt32LE(76);
+  const header = hexToBin(hexHeader.hex);
+  result.version = assertSuccess(readUint32LE({bin: header, index: 0})).result;
+  result.previousBlockHash = binToHex(header.slice(4, 36).reverse());
+  result.merkleRoot = binToHex(header.slice(36, 68).reverse());
+  result.timestamp = assertSuccess(readUint32LE({bin: header, index: 68})).result;
+  result.bits = assertSuccess(readUint32LE({bin: header, index: 72})).result;
+  result.nonce = assertSuccess(readUint32LE({bin: header, index: 76})).result;
   result.height = hexHeader.height;
 
   return result;

package/src/wallet/Util.ts

@@ -15,6 +15,10 @@ import {
   hexToBin,
   lockingBytecodeToCashAddress,
   Transaction as LibAuthTransaction,
+  assertSuccess,
+  isPayToPublicKey,
+  publicKeyToP2pkhCashAddress,
+  lockingBytecodeToAddressContents,
 } from "@bitauth/libauth";
 import {
   ElectrumRawTransaction,
@@ -131,10 +135,19 @@ export class Util {
           n: index,
           scriptPubKey: {
             addresses: [
-              lockingBytecodeToCashAddress(
-                output.lockingBytecode,
-                this.wallet.networkPrefix
-              ).toString(),
+              isPayToPublicKey(output.lockingBytecode)
+                ? publicKeyToP2pkhCashAddress({
+                    publicKey: lockingBytecodeToAddressContents(
+                      output.lockingBytecode
+                    ).payload,
+                    prefix: this.wallet.networkPrefix,
+                  })
+                : assertSuccess(
+                    lockingBytecodeToCashAddress({
+                      bytecode: output.lockingBytecode,
+                      prefix: this.wallet.networkPrefix,
+                    })
+                  ).address,
             ],
             hex: binToHex(output.lockingBytecode),
           } as ElectrumRawTransactionVoutScriptPubKey,

package/src/wallet/Wif.bip39.test.ts

@@ -1,6 +1,6 @@
 import { mnemonicToSeedSync } from "@scure/bip39";
 import { hexToBin } from "@bitauth/libauth";
-import { RegTestWallet } from "./Wif";
+import { RegTestWallet, Wallet } from "./Wif";
 
 describe(`Test bip39 edge cases`, () => {
   test("Should match match the abandon seed", async () => {

package/src/wallet/Wif.test.ts

@@ -1025,7 +1025,7 @@ describe(`Wallet extrema behavior regression testing`, () => {
 
     result = await wallet.send([
       [wallet.cashaddr!, 546, "sats"],
-      ["OP_RETURN", Buffer.from([0x00, 0x01, 0x02])],
+      ["OP_RETURN", Uint8Array.from([0x00, 0x01, 0x02])],
     ]);
     transaction = (await wallet.provider!.getRawTransactionObject(
       result.txId!
@@ -1037,7 +1037,7 @@ describe(`Wallet extrema behavior regression testing`, () => {
 
     result = await wallet.send([
       OpReturnData.from(""),
-      OpReturnData.from(Buffer.from([])),
+      OpReturnData.from(Uint8Array.from([])),
     ]);
     transaction = (await wallet.provider!.getRawTransactionObject(
       result.txId!
@@ -1113,11 +1113,14 @@ describe(`Wallet extrema behavior regression testing`, () => {
         binsAreEqual(decoded.inputs[0].unlockingBytecode, Uint8Array.from([]))
       ).toBe(true);
       const toCashAddress = (bytecode) => {
-        const cashaddr = lockingBytecodeToCashAddress(bytecode, "bchreg");
-        if (typeof cashaddr !== "string") {
-          throw Error(cashaddr.error);
+        const cashaddr = lockingBytecodeToCashAddress({
+          bytecode: bytecode,
+          prefix: "bchreg",
+        });
+        if (typeof cashaddr === "string") {
+          throw Error(cashaddr);
         }
-        return cashaddr;
+        return cashaddr.address;
       };
       expect(toCashAddress(decoded.outputs[0].lockingBytecode)).toBe(
         bobWallet.cashaddr

package/src/wallet/Wif.ts

@@ -4,6 +4,7 @@ import {
   decodeCashAddress,
   encodeHdPublicKey,
   HdKeyNetwork,
+  hexToBin,
   secp256k1,
 } from "@bitauth/libauth";
 
@@ -114,6 +115,9 @@ import { TransactionHistoryItem } from "../history/interface.js";
 
 //#endregion Imports
 
+const placeholderPrivateKey =
+  "0000000000000000000000000000000000000000000000000000000000000001";
+
 /**
  * Class to manage a bitcoin cash wallet.
  */
@@ -348,21 +352,17 @@ export class Wallet extends BaseWallet {
     this.mnemonic = generateMnemonic(Config.getWordlist());
     if (this.mnemonic.length == 0)
       throw Error("refusing to create wallet from empty mnemonic");
-    let seed = mnemonicToSeedSync(this.mnemonic!);
+    const seed = mnemonicToSeedSync(this.mnemonic!);
     checkForEmptySeed(seed);
-    let network = this.isTestnet ? "testnet" : "mainnet";
-    this.parentXPubKey = await getXPubKey(
-      seed,
-      this.parentDerivationPath,
-      network
-    );
+    const network = this.isTestnet ? "testnet" : "mainnet";
+    this.parentXPubKey = getXPubKey(seed, this.parentDerivationPath, network);
 
-    let hdNode = deriveHdPrivateNodeFromSeed(seed);
-    if (!hdNode.valid) {
-      throw Error("Invalid private key derived from mnemonic seed");
-    }
+    const hdNode = deriveHdPrivateNodeFromSeed(seed, {
+      assumeValidity: true, // TODO: we should switch to libauth's BIP39 implementation and set this to false
+      throwErrors: true,
+    });
 
-    let zerothChild = deriveHdPath(hdNode, this.derivationPath);
+    const zerothChild = deriveHdPath(hdNode, this.derivationPath);
     if (typeof zerothChild === "string") {
       throw Error(zerothChild);
     }
@@ -373,7 +373,7 @@ export class Wallet extends BaseWallet {
   }
 
   protected fromId = async (walletId: string): Promise<this> => {
-    let [walletType, networkGiven, arg1]: string[] = walletId.split(":");
+    const [walletType, networkGiven, arg1]: string[] = walletId.split(":");
 
     if (this.network != networkGiven) {
       throw Error(`Network prefix ${networkGiven} to a ${this.network} wallet`);
@@ -408,29 +408,29 @@ export class Wallet extends BaseWallet {
 
     if (this.mnemonic.length == 0)
       throw Error("refusing to create wallet from empty mnemonic");
-    let seed = mnemonicToSeedSync(this.mnemonic);
+    const seed = mnemonicToSeedSync(this.mnemonic);
     checkForEmptySeed(seed);
-    let hdNode = deriveHdPrivateNodeFromSeed(seed);
-    if (!hdNode.valid) {
-      throw Error("Invalid private key derived from mnemonic seed");
-    }
+    const hdNode = deriveHdPrivateNodeFromSeed(seed, {
+      assumeValidity: true, // TODO: we should switch to libauth's BIP39 implementation and set this to false
+      throwErrors: true,
+    });
     if (derivationPath) {
       this.derivationPath = derivationPath;
 
       // If the derivation path is for the first account child, set the parent derivation path
-      let path = derivationPath.split("/");
+      const path = derivationPath.split("/");
       if (path.slice(-2).join("/") == "0/0") {
         this.parentDerivationPath = path.slice(0, -2).join("/");
       }
     }
 
-    let zerothChild = deriveHdPath(hdNode, this.derivationPath);
+    const zerothChild = deriveHdPath(hdNode, this.derivationPath);
     if (typeof zerothChild === "string") {
       throw Error(zerothChild);
     }
     this.privateKey = zerothChild.privateKey;
 
-    let network = this.isTestnet ? "testnet" : "mainnet";
+    const network = this.isTestnet ? "testnet" : "mainnet";
     this.parentXPubKey = await getXPubKey(
       seed,
       this.parentDerivationPath,
@@ -446,14 +446,14 @@ export class Wallet extends BaseWallet {
   public async deriveHdPaths(hdPaths: string[]): Promise<any[]> {
     if (!this.mnemonic)
       throw Error("refusing to create wallet from empty mnemonic");
-    let seed = mnemonicToSeedSync(this.mnemonic!);
+    const seed = mnemonicToSeedSync(this.mnemonic!);
     checkForEmptySeed(seed);
-    let hdNode = deriveHdPrivateNodeFromSeed(seed);
-    if (!hdNode.valid) {
-      throw Error("Invalid private key derived from mnemonic seed");
-    }
+    const hdNode = deriveHdPrivateNodeFromSeed(seed, {
+      assumeValidity: true, // TODO: we should switch to libauth's BIP39 implementation and set this to false
+      throwErrors: true,
+    });
 
-    let result: any[] = [];
+    const result: any[] = [];
 
     for (const path of hdPaths) {
       if (path === "m") {
@@ -461,19 +461,24 @@ export class Wallet extends BaseWallet {
           "Storing or sharing of parent public key may lead to loss of funds. Storing or sharing *root* parent public keys is strongly discouraged, although all parent keys have risk. See: https://github.com/bitcoin/bips/blob/master/bip-0032.mediawiki#implications"
         );
       }
-      let childNode = deriveHdPath(hdNode, path);
+      const childNode = deriveHdPath(hdNode, path);
       if (typeof childNode === "string") {
         throw Error(childNode);
       }
-      let node = deriveHdPublicNode(childNode);
+      const node = deriveHdPublicNode(childNode);
       if (typeof node === "string") {
         throw Error(node);
       }
-      let xPubKey = encodeHdPublicKey({
-        network: this.network as HdKeyNetwork,
-        node: node,
-      });
-      let key = new XPubKey({
+      const xPubKey = encodeHdPublicKey(
+        {
+          network: this.network as HdKeyNetwork,
+          node: node,
+        },
+        {
+          throwErrors: true,
+        }
+      ).hdPublicKey;
+      const key = new XPubKey({
         path: path,
         xPubKey: xPubKey,
       });
@@ -488,7 +493,7 @@ export class Wallet extends BaseWallet {
   // Initialize a watch only wallet from a cash addr
   protected async watchOnly(address: string): Promise<this> {
     this.walletType = WalletTypeEnum.Watch;
-    let addressComponents = address.split(":");
+    const addressComponents = address.split(":");
     let addressPrefix, addressBase;
     if (addressComponents.length === 1) {
       addressBase = addressComponents.shift() as string;
@@ -499,7 +504,7 @@ export class Wallet extends BaseWallet {
       if (addressPrefix in networkPrefixMap) {
         if (networkPrefixMap[addressPrefix] != this.network) {
           throw Error(
-            `a ${addressPrefix} address cannot be watched from a ${this.network} Wallet`
+            `a ${addressPrefix} address cannot be watched from a ${this.network} Walconst`
           );
         }
       }
@@ -508,7 +513,7 @@ export class Wallet extends BaseWallet {
     const prefixedAddress = `${addressPrefix}:${addressBase}`;
 
     // check if a token aware address was provided
-    let addressData = decodeCashAddress(prefixedAddress);
+    const addressData = decodeCashAddress(prefixedAddress);
     if (typeof addressData === "string") throw addressData;
 
     this.publicKeyHash = addressData.payload;
@@ -521,11 +526,11 @@ export class Wallet extends BaseWallet {
     if (nonTokenAwareType == CashAddressType.p2pkh)
       this.publicKeyHash = addressData.payload;
 
-    this.cashaddr = encodeCashAddress(
-      addressData.prefix as CashAddressNetworkPrefix,
-      nonTokenAwareType,
-      addressData.payload
-    );
+    this.cashaddr = encodeCashAddress({
+      prefix: addressData.prefix as CashAddressNetworkPrefix,
+      type: nonTokenAwareType,
+      payload: addressData.payload,
+    }).address;
     this.address = this.cashaddr;
     this.tokenaddr = deriveTokenaddr(addressData.payload, this.networkPrefix);
 
@@ -880,7 +885,7 @@ export class Wallet extends BaseWallet {
     const fee = await getFeeAmountSimple({
       utxos: fundingUtxos,
       sendRequests: sendRequests,
-      privateKey: this.privateKey ?? Uint8Array.from([]),
+      privateKey: this.privateKey ?? hexToBin(placeholderPrivateKey),
       sourceAddress: this.cashaddr!,
       relayFeePerByteInSatoshi: relayFeePerByteInSatoshi,
       feePaidBy: feePaidBy,
@@ -1196,7 +1201,7 @@ export class Wallet extends BaseWallet {
     const feeEstimate = await getFeeAmountSimple({
       utxos: utxos,
       sendRequests: sendRequests,
-      privateKey: this.privateKey ?? Uint8Array.from([]),
+      privateKey: this.privateKey ?? hexToBin(placeholderPrivateKey),
       sourceAddress: this.cashaddr!,
       relayFeePerByteInSatoshi: relayFeePerByteInSatoshi,
       feePaidBy: feePaidBy,
@@ -1219,7 +1224,7 @@ export class Wallet extends BaseWallet {
     const fee = await getFeeAmount({
       utxos: fundingUtxos,
       sendRequests: sendRequests,
-      privateKey: this.privateKey ?? Uint8Array.from([]),
+      privateKey: this.privateKey ?? hexToBin(placeholderPrivateKey),
       sourceAddress: this.cashaddr!,
       relayFeePerByteInSatoshi: relayFeePerByteInSatoshi,
       feePaidBy: feePaidBy,
@@ -1228,7 +1233,7 @@ export class Wallet extends BaseWallet {
       {
         inputs: fundingUtxos,
         outputs: sendRequests,
-        signingKey: this.privateKey ?? Uint8Array.from([]),
+        signingKey: this.privateKey ?? hexToBin(placeholderPrivateKey),
         sourceAddress: this.cashaddr!,
         fee,
         discardChange,

package/src/wallet/model.ts

@@ -161,10 +161,10 @@ export class TokenMintRequest {
 }
 
 export class OpReturnData {
-  buffer: Buffer;
+  buffer: Uint8Array;
 
-  public constructor(buffer: Buffer) {
-    this.buffer = Buffer.from(buffer);
+  public constructor(buffer: Uint8Array) {
+    this.buffer = Uint8Array.from(buffer);
   }
 
   /**
@@ -174,7 +174,7 @@ export class OpReturnData {
    *
    * @returns class instance
    */
-  public static from(data: string | Buffer | Uint8Array) {
+  public static from(data: string | Uint8Array) {
     return this.fromArray([data]);
   }
 
@@ -189,21 +189,6 @@ export class OpReturnData {
     return this.fromArray([string]);
   }
 
-  /**
-   * buffer - Accept OP_RETURN data as a binary buffer.
-   * If buffer lacks the OP_RETURN and OP_PUSHDATA opcodes, they will be prepended.
-   *
-   * @param buffer   Data buffer to be assigned to the OP_RETURN outpit
-   *
-   * @returns class instance
-   */
-  public static fromBuffer(buffer: Buffer) {
-    if (buffer[0] !== 0x6a) {
-      return this.fromArray([buffer]);
-    }
-    return new this(buffer);
-  }
-
   /**
    * buffer - Accept OP_RETURN data as a binary buffer.
    * If buffer lacks the OP_RETURN and OP_PUSHDATA opcodes, they will be prepended.
@@ -216,30 +201,27 @@ export class OpReturnData {
     if (uint8Array[0] !== 0x6a) {
       return this.fromArray([uint8Array]);
     }
-    return new this(Buffer.from(uint8Array));
+    return new this(Uint8Array.from(uint8Array));
   }
 
   /**
    * fromArray - Accept array of data
    *
-   * @param array   Array of Buffer or UTF-8 encoded string messages to be converted to OP_RETURN data
+   * @param array   Array of Uint8Array or UTF-8 encoded string messages to be converted to OP_RETURN data
    *
    * @returns class instance
    */
-  public static fromArray(array: Array<string | Buffer | Uint8Array>) {
-    let data: Buffer = Buffer.from([0x6a]); // OP_RETURN
+  public static fromArray(array: Array<string | Uint8Array>) {
+    let data: Uint8Array = Uint8Array.from([0x6a]); // OP_RETURN
     for (const element of array) {
       let length: number;
-      let elementData: Uint8Array | Buffer;
+      let elementData: Uint8Array;
       let lengthData: any;
       if (typeof element === "string") {
         elementData = utf8ToBin(element);
         length = elementData.length;
-      } else if (element instanceof Buffer) {
-        elementData = element;
-        length = elementData.length;
       } else if (element instanceof Uint8Array) {
-        elementData = Buffer.from(element);
+        elementData = element;
         length = elementData.length;
       } else {
         throw new Error("Wrong data array element");
@@ -255,7 +237,7 @@ export class OpReturnData {
         throw new Error("OP_RETURN data can not exceed 220 bytes in size");
       }
 
-      data = Buffer.from([...data, ...lengthData, ...elementData]);
+      data = Uint8Array.from([...data, ...lengthData, ...elementData]);
     }
 
     if (data.length > 220) {
@@ -312,7 +294,7 @@ export class OpReturnData {
   }
 }
 
-export type SendRequestArray = Array<string | number | UnitEnum | Buffer>;
+export type SendRequestArray = Array<string | number | UnitEnum | Uint8Array>;
 
 export type SourceOutput = Input & Output;