beignet 0.0.1

package/tests/constants.ts

@@ -0,0 +1,9 @@
+export const TEST_MNEMONIC =
+	'decorate grass round powder swarm syrup identify resemble mass online grunt cruise';
+export const TRANSACTION_TEST_MNEMONIC =
+	'magic skull comfort major potato local giggle adjust post very olympic fortune';
+export const EXAMPLE_MNEMONIC =
+	'shaft lottery soda estate trade bounce scout acid axis weather pole indicate';
+export const HIGHT_ACTIVITY_MNEMONIC =
+	'above diet topic latin van chief load early faith clump alpha truly';
+export const NETWORK = 'testnet';

package/tests/derivation.test.ts

@@ -0,0 +1,146 @@
+import * as chai from 'chai';
+import {
+	EAddressType,
+	EAvailableNetworks,
+	getAddressTypeFromPath,
+	getKeyDerivationPath,
+	getKeyDerivationPathObject,
+	getKeyDerivationPathString
+} from '../src';
+
+const expect = chai.expect;
+
+describe('Derivation Methods', () => {
+	it('Should return default derivation path object for p2wpkh', () => {
+		const pathRes = getKeyDerivationPath({
+			addressType: EAddressType.p2wpkh,
+			network: EAvailableNetworks.mainnet
+		});
+		expect(pathRes.isErr()).to.equal(false);
+		if (pathRes.isErr()) return;
+		expect(pathRes.value.purpose).to.equal('84');
+		expect(pathRes.value.coinType).to.equal('0');
+		expect(pathRes.value.account).to.equal('0');
+		expect(pathRes.value.change).to.equal('0');
+		expect(pathRes.value.index).to.equal('0');
+	});
+	it('Should return default derivation path object for p2sh', () => {
+		const pathRes = getKeyDerivationPath({
+			addressType: EAddressType.p2sh,
+			network: EAvailableNetworks.mainnet
+		});
+		expect(pathRes.isErr()).to.equal(false);
+		if (pathRes.isErr()) return;
+		expect(pathRes.value.purpose).to.equal('49');
+		expect(pathRes.value.coinType).to.equal('0');
+		expect(pathRes.value.account).to.equal('0');
+		expect(pathRes.value.change).to.equal('0');
+		expect(pathRes.value.index).to.equal('0');
+	});
+	it('Should return default derivation path object for p2pkh', () => {
+		const pathRes = getKeyDerivationPath({
+			addressType: EAddressType.p2pkh,
+			network: EAvailableNetworks.mainnet
+		});
+		expect(pathRes.isErr()).to.equal(false);
+		if (pathRes.isErr()) return;
+		expect(pathRes.value.purpose).to.equal('44');
+		expect(pathRes.value.coinType).to.equal('0');
+		expect(pathRes.value.account).to.equal('0');
+		expect(pathRes.value.change).to.equal('0');
+		expect(pathRes.value.index).to.equal('0');
+	});
+
+	it('Should return a valid mainnet bech32 change address derivation string at index 0', () => {
+		const pathRes = getKeyDerivationPathString({
+			addressType: EAddressType.p2wpkh,
+			changeAddress: true,
+			index: 0,
+			network: EAvailableNetworks.mainnet
+		});
+		expect(pathRes.isErr()).to.equal(false);
+		if (pathRes.isErr()) return;
+		expect(pathRes.value).to.equal("m/84'/0'/0'/1/0");
+	});
+	it('Should return a valid testnet p2sh derivation string at index 40', () => {
+		const pathRes = getKeyDerivationPathString({
+			addressType: EAddressType.p2sh,
+			changeAddress: false,
+			index: '40',
+			network: EAvailableNetworks.testnet
+		});
+		expect(pathRes.isErr()).to.equal(false);
+		if (pathRes.isErr()) return;
+		expect(pathRes.value).to.equal("m/49'/1'/0'/0/40");
+	});
+	it('Should return a valid mainnet p2pkh derivation string at index 8', () => {
+		const pathRes = getKeyDerivationPathString({
+			addressType: EAddressType.p2pkh,
+			changeAddress: false,
+			index: 8,
+			network: EAvailableNetworks.mainnet
+		});
+		expect(pathRes.isErr()).to.equal(false);
+		if (pathRes.isErr()) return;
+		expect(pathRes.value).to.equal("m/44'/0'/0'/0/8");
+	});
+
+	it('Should return a valid mainnet bech32 change address derivation object at index 0', () => {
+		const pathRes = getKeyDerivationPathObject({
+			path: "m/84'/0'/0'/1/0",
+			network: EAvailableNetworks.mainnet
+		});
+		expect(pathRes.isErr()).to.equal(false);
+		if (pathRes.isErr()) return;
+		expect(pathRes.value.purpose).to.equal('84');
+		expect(pathRes.value.coinType).to.equal('0');
+		expect(pathRes.value.account).to.equal('0');
+		expect(pathRes.value.change).to.equal('1');
+		expect(pathRes.value.index).to.equal('0');
+	});
+	it('Should return a valid testnet p2sh derivation object at index 40', () => {
+		const pathRes = getKeyDerivationPathObject({
+			path: "m/49'/1'/0'/0/40",
+			network: EAvailableNetworks.testnet
+		});
+		expect(pathRes.isErr()).to.equal(false);
+		if (pathRes.isErr()) return;
+		expect(pathRes.value.purpose).to.equal('49');
+		expect(pathRes.value.coinType).to.equal('1');
+		expect(pathRes.value.account).to.equal('0');
+		expect(pathRes.value.change).to.equal('0');
+		expect(pathRes.value.index).to.equal('40');
+	});
+	it('Should return a valid mainnet p2pkh object at index 8', () => {
+		const pathRes = getKeyDerivationPathObject({
+			path: "m/44'/0'/0'/0/8",
+			network: EAvailableNetworks.mainnet
+		});
+		expect(pathRes.isErr()).to.equal(false);
+		if (pathRes.isErr()) return;
+		expect(pathRes.value.purpose).to.equal('44');
+		expect(pathRes.value.coinType).to.equal('0');
+		expect(pathRes.value.account).to.equal('0');
+		expect(pathRes.value.change).to.equal('0');
+		expect(pathRes.value.index).to.equal('8');
+	});
+
+	it('Should return a valid address type from p2wpkh path', () => {
+		const pathRes = getAddressTypeFromPath("m/84'/0'/0'/0/0");
+		expect(pathRes.isErr()).to.equal(false);
+		if (pathRes.isErr()) return;
+		expect(pathRes.value).to.equal(EAddressType.p2wpkh);
+	});
+	it('Should return a valid address type from p2sh path', () => {
+		const pathRes = getAddressTypeFromPath("m/49'/0'/0'/0/0");
+		expect(pathRes.isErr()).to.equal(false);
+		if (pathRes.isErr()) return;
+		expect(pathRes.value).to.equal(EAddressType.p2sh);
+	});
+	it('Should return a valid address type from p2pkh path', () => {
+		const pathRes = getAddressTypeFromPath("m/44'/0'/0'/0/0");
+		expect(pathRes.isErr()).to.equal(false);
+		if (pathRes.isErr()) return;
+		expect(pathRes.value).to.equal(EAddressType.p2pkh);
+	});
+});

package/tests/electrum.test.ts

@@ -0,0 +1,137 @@
+import * as chai from 'chai';
+import { Wallet } from '../';
+import { EAvailableNetworks, EAddressType, IGetUtxosResponse } from '../src';
+import { TEST_MNEMONIC } from './constants';
+import { Result } from '../src';
+const expect = chai.expect;
+
+const testTimeout = 60000;
+
+let wallet;
+
+before(async function () {
+	this.timeout(testTimeout);
+	const res = await Wallet.create({
+		mnemonic: TEST_MNEMONIC,
+		network: EAvailableNetworks.testnet,
+		addressType: EAddressType.p2wpkh
+	});
+	if (res.isErr()) {
+		console.log('error: ', res.error.message);
+		//throw new Error(res.error.message);
+		return;
+	}
+	wallet = res.value;
+});
+
+describe('Electrum Methods', async function (): Promise<void> {
+	this.timeout(testTimeout);
+	it('connectToElectrum: Should connect to a random Electrum server', async () => {
+		const connectResponse = await wallet.connectToElectrum();
+		expect(connectResponse.isErr()).to.equal(false);
+		expect(connectResponse.value).to.equal('Connected to Electrum server.');
+	});
+
+	it('isConnected: Should return true if connected to an Electrum server', async () => {
+		const isConnected = await wallet.electrum.isConnected();
+		expect(isConnected).to.equal(true);
+	});
+
+	it('getAddressBalance: Should return the balance (in sats) of the provided address', async () => {
+		const addressBalance = await wallet.getAddressBalance(
+			'tb1qyvc8r7338383xjshqsz38mfn2eql879nhrf8y0'
+		);
+		expect(addressBalance.isErr()).to.equal(false);
+		if (addressBalance.isErr()) return;
+		expect(addressBalance.value.confirmed).to.equal(20000);
+	});
+
+	it('getNextAvailableAddress: Should return the next available address/change index and the last used address/change index', async () => {
+		const expectedResult = {
+			addressIndex: {
+				address: 'tb1qqcmg5vwk736mmr3fnkx5us9hq4czl6cx5w5g0x',
+				path: "m/84'/1'/0'/0/5",
+				publicKey:
+					'0345f71b1a5f9ce1c08ef2dbb1fb1076296b0fdf1f09f6fe7f53ed22383ad9d1c9',
+				index: 5,
+				scriptHash:
+					'448ae601fb40d7a6de824eb34479286a06d41015250fc75544dbb6d2893bd0e5'
+			},
+			lastUsedChangeAddressIndex: {
+				address: 'tb1q926j5y9mwjc49axf5w25y2jrm0ew8w6uks0vdm',
+				index: 9,
+				path: "m/84'/1'/0'/1/9",
+				publicKey:
+					'02e9085f8d23072244620f0549e6f1c6ff04c8c8b1dd238edce106ce6ef54b358e',
+				scriptHash:
+					'640d69f5b22996bdc95dbac8863e9e94e198f40569c1ec46b6336edd740c0007'
+			},
+			changeAddressIndex: {
+				address: 'tb1q32eaj0c805mry76wa0g6hlcunu7ttu96833072',
+				path: "m/84'/1'/0'/1/10",
+				publicKey:
+					'038813820d10cca28ce1fdb6a8b346a4ab9de6b520adc46e2c4442a7ba94de10a1',
+				index: 10,
+				scriptHash:
+					'3198ad3b2b39efcdeeb6b338c1f28ccede385c2092dbb9854e265b6eec8a0dab'
+			},
+			lastUsedAddressIndex: {
+				address: 'tb1qyxugs6zkcj3r4u09qks7khgf7hkktf8mnzz5ze',
+				path: "m/84'/1'/0'/0/4",
+				publicKey:
+					'03f01a817e07ff424f00d6be3b93f7bec658aaf8fbfed5cd2c18f95f3cfd47f7a8',
+				index: 4,
+				scriptHash:
+					'7f07103d4580005b27b856434bba9be63a7e58a83cb456b603f4af3ae88d1023'
+			}
+		};
+		const r = await wallet.getNextAvailableAddress();
+		expect(r.isErr()).to.equal(false);
+		if (r.isErr()) return;
+		expect(r.value).to.deep.equal(expectedResult);
+	});
+
+	it("Should return available UTXO's", async () => {
+		const expectedResult = {
+			utxos: [
+				{
+					address: 'tb1qy45r5c84eh7tuke772lrvj2q5kqlylp2ghgdlk',
+					path: "m/84'/1'/0'/0/1",
+					publicKey:
+						'03f8c98bf09b3e069714a05a530a735761453d94d1f4355239bfcb6b78c25a2592',
+					index: 1,
+					scriptHash:
+						'bdb8f18267b816706378c2c9282e0be7b05dcc5a3e63dd2468f145c6431f2002',
+					tx_hash:
+						'7a6e9a985de1e5bed1138d1fe1bf2f169a4f838d802ecdf96d1376378391a350',
+					tx_pos: 0,
+					height: 2539268,
+					value: 1000
+				},
+				{
+					address: 'tb1q926j5y9mwjc49axf5w25y2jrm0ew8w6uks0vdm',
+					path: "m/84'/1'/0'/1/9",
+					publicKey:
+						'02e9085f8d23072244620f0549e6f1c6ff04c8c8b1dd238edce106ce6ef54b358e',
+					index: 9,
+					scriptHash:
+						'640d69f5b22996bdc95dbac8863e9e94e198f40569c1ec46b6336edd740c0007',
+					tx_hash:
+						'7a6e9a985de1e5bed1138d1fe1bf2f169a4f838d802ecdf96d1376378391a350',
+					tx_pos: 1,
+					height: 2539268,
+					value: 3855
+				}
+			],
+			balance: 4855
+		};
+
+		const getUtxosRes: Result<IGetUtxosResponse> = await wallet.getUtxos({});
+		expect(getUtxosRes.isErr()).to.equal(false);
+		if (getUtxosRes.isErr()) return;
+		expect(Array.isArray(getUtxosRes.value.utxos)).to.equal(true);
+		expect(getUtxosRes.value.utxos.length).to.equal(2);
+		expect(getUtxosRes.value.balance).to.equal(4855);
+		expect(getUtxosRes.value).to.deep.equal(expectedResult);
+	});
+});

package/tests/storage.test.ts

@@ -0,0 +1,222 @@
+import * as chai from 'chai';
+import { validateMnemonic } from 'bip39';
+import { Wallet } from '../';
+import {
+	EAddressType,
+	EAvailableNetworks,
+	IGetUtxosResponse,
+	Result,
+	generateMnemonic
+} from '../src';
+import { TEST_MNEMONIC } from './constants';
+import { deleteDirectory, getData, setData } from '../example/helpers';
+
+const expect = chai.expect;
+
+const testTimeout = 60000;
+
+let wallet;
+const WALLET_NAME = 'storagetestwallet0';
+
+before(async function () {
+	this.timeout(testTimeout);
+	await deleteDirectory('example/walletData'); // Start test with clean slate.
+	const res = await Wallet.create({
+		mnemonic: TEST_MNEMONIC,
+		network: EAvailableNetworks.testnet,
+		name: WALLET_NAME,
+		addressType: EAddressType.p2wpkh,
+		storage: {
+			getData,
+			setData
+		}
+	});
+	if (res.isErr()) {
+		console.log('error: ', res.error.message);
+		//throw new Error(res.error.message);
+		return;
+	}
+	wallet = res.value;
+});
+
+describe('Storage Test', async function (): Promise<void> {
+	this.timeout(testTimeout);
+	it('Should successfully create a wallet.', () => {
+		expect(wallet).not.to.be.null;
+	});
+
+	it('Should generate a valid, random mnemonic', () => {
+		const randomMnemonic = generateMnemonic();
+		expect(validateMnemonic(randomMnemonic)).to.equal(true);
+	});
+
+	it('Should determine that the wallet mnemonic is invalid', () => {
+		const invalidMnemonic =
+			'corn core humor loud lady wealth avoid purse next subject focus dilemma';
+		const isValid = wallet.isValid(invalidMnemonic);
+		expect(isValid).to.equal(false);
+	});
+
+	it('Should determine that the current wallet instance is valid', () => {
+		const isValid = wallet.isValid(TEST_MNEMONIC);
+		expect(isValid).to.equal(true);
+	});
+
+	it('Should generate a bech32 receiving address at index 0', async () => {
+		const address = await wallet.getAddress({
+			addressType: EAddressType.p2wpkh,
+			changeAddress: false,
+			index: '0'
+		});
+		expect(address).to.equal('tb1qmja98kkd540qtesjqdanfg0ywags845vehfg66');
+	});
+
+	it('Should generate a segwit change address at index 1', async () => {
+		const address = await wallet.getAddress({
+			addressType: EAddressType.p2sh,
+			changeAddress: true,
+			index: '1'
+		});
+		expect(address).to.equal('2NDRG1ZGhWMGGNW7Mp58BKcyBs4Hyat8Law');
+	});
+
+	it('Should generate a legacy receiving address at index 5', async () => {
+		const address = await wallet.getAddress({
+			addressType: EAddressType.p2pkh,
+			changeAddress: false,
+			index: '5'
+		});
+		expect(address).to.equal('mohdq3fadTtT4uSH4oNr4F1Dp3YM4pR3VF');
+	});
+
+	it('Should generate a bech32 receiving address at index 0 via its path', async () => {
+		const address = await wallet.getAddressByPath({ path: "m/84'/1'/0'/0/0" });
+		expect(address.isErr()).to.equal(false);
+		if (address.isErr()) return;
+		expect(address.value.address).to.equal(
+			'tb1qmja98kkd540qtesjqdanfg0ywags845vehfg66'
+		);
+	});
+
+	it('Should generate a segwit change address at index 1 via its path', async () => {
+		const address = await wallet.getAddressByPath({ path: "m/49'/1'/0'/1/1" });
+		expect(address.isErr()).to.equal(false);
+		if (address.isErr()) return;
+		expect(address.value.address).to.equal(
+			'2NDRG1ZGhWMGGNW7Mp58BKcyBs4Hyat8Law'
+		);
+	});
+
+	it('Should generate a testnet legacy receiving address at index 5 via its path', async () => {
+		const address = await wallet.getAddressByPath({ path: "m/44'/1'/0'/0/5" });
+		expect(address.isErr()).to.equal(false);
+		if (address.isErr()) return;
+		expect(address.value.address).to.equal(
+			'mohdq3fadTtT4uSH4oNr4F1Dp3YM4pR3VF'
+		);
+	});
+
+	it('getNextAvailableAddress: Should return the next available address/change index and the last used address/change index', async () => {
+		const expectedResult = {
+			addressIndex: {
+				address: 'tb1qqcmg5vwk736mmr3fnkx5us9hq4czl6cx5w5g0x',
+				path: "m/84'/1'/0'/0/5",
+				publicKey:
+					'0345f71b1a5f9ce1c08ef2dbb1fb1076296b0fdf1f09f6fe7f53ed22383ad9d1c9',
+				index: 5,
+				scriptHash:
+					'448ae601fb40d7a6de824eb34479286a06d41015250fc75544dbb6d2893bd0e5'
+			},
+			lastUsedChangeAddressIndex: {
+				address: 'tb1q926j5y9mwjc49axf5w25y2jrm0ew8w6uks0vdm',
+				index: 9,
+				path: "m/84'/1'/0'/1/9",
+				publicKey:
+					'02e9085f8d23072244620f0549e6f1c6ff04c8c8b1dd238edce106ce6ef54b358e',
+				scriptHash:
+					'640d69f5b22996bdc95dbac8863e9e94e198f40569c1ec46b6336edd740c0007'
+			},
+			changeAddressIndex: {
+				address: 'tb1q32eaj0c805mry76wa0g6hlcunu7ttu96833072',
+				path: "m/84'/1'/0'/1/10",
+				publicKey:
+					'038813820d10cca28ce1fdb6a8b346a4ab9de6b520adc46e2c4442a7ba94de10a1',
+				index: 10,
+				scriptHash:
+					'3198ad3b2b39efcdeeb6b338c1f28ccede385c2092dbb9854e265b6eec8a0dab'
+			},
+			lastUsedAddressIndex: {
+				address: 'tb1qyxugs6zkcj3r4u09qks7khgf7hkktf8mnzz5ze',
+				path: "m/84'/1'/0'/0/4",
+				publicKey:
+					'03f01a817e07ff424f00d6be3b93f7bec658aaf8fbfed5cd2c18f95f3cfd47f7a8',
+				index: 4,
+				scriptHash:
+					'7f07103d4580005b27b856434bba9be63a7e58a83cb456b603f4af3ae88d1023'
+			}
+		};
+		const r = await wallet.getNextAvailableAddress();
+		expect(r.isErr()).to.equal(false);
+		if (r.isErr()) return;
+		expect(r.value).to.deep.equal(expectedResult);
+	});
+
+	it("Should return available UTXO's", async () => {
+		const expectedResult = {
+			utxos: [
+				{
+					address: 'tb1qy45r5c84eh7tuke772lrvj2q5kqlylp2ghgdlk',
+					path: "m/84'/1'/0'/0/1",
+					publicKey:
+						'03f8c98bf09b3e069714a05a530a735761453d94d1f4355239bfcb6b78c25a2592',
+					index: 1,
+					scriptHash:
+						'bdb8f18267b816706378c2c9282e0be7b05dcc5a3e63dd2468f145c6431f2002',
+					tx_hash:
+						'7a6e9a985de1e5bed1138d1fe1bf2f169a4f838d802ecdf96d1376378391a350',
+					tx_pos: 0,
+					height: 2539268,
+					value: 1000
+				},
+				{
+					address: 'tb1q926j5y9mwjc49axf5w25y2jrm0ew8w6uks0vdm',
+					path: "m/84'/1'/0'/1/9",
+					publicKey:
+						'02e9085f8d23072244620f0549e6f1c6ff04c8c8b1dd238edce106ce6ef54b358e',
+					index: 9,
+					scriptHash:
+						'640d69f5b22996bdc95dbac8863e9e94e198f40569c1ec46b6336edd740c0007',
+					tx_hash:
+						'7a6e9a985de1e5bed1138d1fe1bf2f169a4f838d802ecdf96d1376378391a350',
+					tx_pos: 1,
+					height: 2539268,
+					value: 3855
+				}
+			],
+			balance: 4855
+		};
+
+		const getUtxosRes: Result<IGetUtxosResponse> = await wallet.getUtxos({});
+		expect(getUtxosRes.isErr()).to.equal(false);
+		if (getUtxosRes.isErr()) return;
+		expect(Array.isArray(getUtxosRes.value.utxos)).to.equal(true);
+		expect(getUtxosRes.value.utxos.length).to.equal(2);
+		expect(getUtxosRes.value.balance).to.equal(4855);
+		expect(getUtxosRes.value).to.deep.equal(expectedResult);
+	});
+
+	// it('Attempts to create a new wallet using the same name of an existing wallet in storage.', async () => {
+	// 	const createRes = await Wallet.create({
+	// 		mnemonic: generateMnemonic(),
+	// 		network: EAvailableNetworks.testnet,
+	// 		name: WALLET_NAME,
+	// 		addressType: EAddressType.p2wpkh,
+	// 		storage: {
+	// 			getData,
+	// 			setData
+	// 		}
+	// 	});
+	// 	expect(createRes.isOk()).to.equal(false);
+	// 	if (createRes.isOk()) return;
+	// });
+});

package/tests/transaction.test.ts

@@ -0,0 +1,187 @@
+import * as chai from 'chai';
+import { decodeRawTransaction, Wallet } from '../';
+import { EAvailableNetworks } from '../src';
+import { TRANSACTION_TEST_MNEMONIC } from './constants';
+
+const expect = chai.expect;
+
+const testTimeout = 60000;
+
+let wallet;
+
+before(async function () {
+	this.timeout(testTimeout);
+	const res = await Wallet.create({
+		mnemonic: TRANSACTION_TEST_MNEMONIC,
+		network: EAvailableNetworks.testnet
+	});
+	if (res.isErr()) {
+		console.log('error: ', res.error.message);
+		return;
+	}
+	wallet = res.value;
+});
+
+describe('Transaction Test', async function (): Promise<void> {
+	this.timeout(testTimeout);
+
+	it('Should successfully create a wallet.', (): void => {
+		expect(wallet).not.to.be.null;
+	});
+
+	it('Should successfully return fee information.', (): void => {
+		const feeInfo = wallet.getFeeInfo({ satsPerByte: 5 });
+		expect(feeInfo.isErr()).to.equal(false);
+		if (feeInfo.isErr()) return;
+		expect(feeInfo).not.to.be.null;
+		expect(feeInfo.value.satsPerByte).to.equal(5);
+		expect(feeInfo.value.totalFee).to.equal(705);
+		expect(feeInfo.value.transactionByteCount).to.equal(141);
+		expect(feeInfo.value.maxSatPerByte).to.equal(283);
+	});
+
+	it('Should successfully create and decode a transaction.', async (): Promise<void> => {
+		// Get a receiving address.
+		const sendRes = await wallet.send({
+			address: 'tb1q8ud85xqzudmaq9sz4ncu44qrx68d8wuf2cwdqg',
+			amount: 5000,
+			satsPerByte: 5,
+			broadcast: false,
+			shuffleOutputs: false,
+			rbf: true
+		});
+		expect(sendRes.isErr()).to.equal(false);
+		if (sendRes.isErr()) return;
+		expect(sendRes.value).to.equal(
+			'020000000001014b44d379e48a8100d1c26f7220b8bbf7a4894ff015d5bc4064a28d08d25d808d0000000000000000000288130000000000001600143f1a7a1802e377d01602acf1cad403368ed3bb893722010000000000160014a6bd95db4dd6979189cad389daad006e236f4ba8024730440220078f087ba08b79c02e7cb97593d7e698670dd6e7537e3639dec70b4d354f8fa8022018a20a64618a405427eb2e0e67ef9ae2b89bfe1b51cdb365d44b5314b9728a06012102e86b90924963237c59e5389aab1cc5350c114549d1c5e7186a56ef33aea24ff900000000'
+		);
+
+		const decodeRes = decodeRawTransaction(sendRes.value, wallet.network);
+		expect(decodeRes.isErr()).to.equal(false);
+		if (decodeRes.isErr()) return;
+		const expectedDecodeRes = {
+			txid: '786c97889108849e7970651a0dbd10e08ffe7b4ddfd282be54e465441b985308',
+			tx_hash:
+				'a5ad458d02cc905593e4b6d3c88cdbedcfff31a192691f24abdab92b4cef74ea',
+			size: 222,
+			vsize: 141,
+			weight: 561,
+			version: 2,
+			locktime: 0,
+			vin: [
+				{
+					txid: '8d805dd2088da26440bcd515f04f89a4f7bbb820726fc2d100818ae479d3444b',
+					vout: 0,
+					scriptSig: { asm: '', hex: '' },
+					txinwitness: [
+						'30440220078f087ba08b79c02e7cb97593d7e698670dd6e7537e3639dec70b4d354f8fa8022018a20a64618a405427eb2e0e67ef9ae2b89bfe1b51cdb365d44b5314b9728a0601',
+						'02e86b90924963237c59e5389aab1cc5350c114549d1c5e7186a56ef33aea24ff9'
+					],
+					sequence: 0
+				}
+			],
+			vout: [
+				{
+					value: 5000,
+					n: 0,
+					scriptPubKey: {
+						asm: 'OP_0 3f1a7a1802e377d01602acf1cad403368ed3bb89',
+						hex: '00143f1a7a1802e377d01602acf1cad403368ed3bb89',
+						address: 'tb1q8ud85xqzudmaq9sz4ncu44qrx68d8wuf2cwdqg'
+					}
+				},
+				{
+					value: 74295,
+					n: 1,
+					scriptPubKey: {
+						asm: 'OP_0 a6bd95db4dd6979189cad389daad006e236f4ba8',
+						hex: '0014a6bd95db4dd6979189cad389daad006e236f4ba8',
+						address: 'tb1q567etk6d66terzw26wya4tgqdc3k7jag0zcw3r'
+					}
+				}
+			]
+		};
+		expect(decodeRes.value).to.deep.equal(expectedDecodeRes);
+	});
+
+	it('Should successfully create and decode a sendMany transaction.', async (): Promise<void> => {
+		// Get a receiving address.
+		const sendManyRes = await wallet.sendMany({
+			txs: [
+				{
+					address: 'tb1q56mkp64fd2d6jxawj3jal382hec3u8t8af83d7',
+					amount: 5000
+				},
+				{
+					address: 'tb1qd08eypv4uzd4mrmm35pmx6226vzh2u5fqkpeyd',
+					amount: 6000
+				}
+			],
+			broadcast: false,
+			shuffleOutputs: false,
+			satsPerByte: 5,
+			rbf: true
+		});
+		expect(sendManyRes.isErr()).to.equal(false);
+		if (sendManyRes.isErr()) return;
+		expect(sendManyRes.value).to.equal(
+			'020000000001014b44d379e48a8100d1c26f7220b8bbf7a4894ff015d5bc4064a28d08d25d808d000000000000000000038813000000000000160014a6b760eaa96a9ba91bae9465dfc4eabe711e1d6770170000000000001600146bcf920595e09b5d8f7b8d03b3694ad3057572892c0a010000000000160014a6bd95db4dd6979189cad389daad006e236f4ba80247304402207e7b5de41cb9bf33e434c2136390bf40d6b6552b69234a62f6bf48b89f0d44ac022056121c9a9d79d9d84896c9896a6fddb358b48667021ff2832b5c5871d90b701a012102e86b90924963237c59e5389aab1cc5350c114549d1c5e7186a56ef33aea24ff900000000'
+		);
+
+		const decodeRes = decodeRawTransaction(sendManyRes.value, wallet.network);
+		expect(decodeRes.isErr()).to.equal(false);
+		if (decodeRes.isErr()) return;
+		const expectedDecodeRes = {
+			txid: '3fb40fc55d80c46d08f412c2c9a6b18e6b46264a6ae6fd4be8409480d1a53b45',
+			tx_hash:
+				'6b124dc403f6db7ce9c7967b8b3b5b3223d4df98626ece3b5d253450c47c9b88',
+			size: 253,
+			vsize: 172,
+			weight: 685,
+			version: 2,
+			locktime: 0,
+			vin: [
+				{
+					txid: '8d805dd2088da26440bcd515f04f89a4f7bbb820726fc2d100818ae479d3444b',
+					vout: 0,
+					scriptSig: { asm: '', hex: '' },
+					txinwitness: [
+						'304402207e7b5de41cb9bf33e434c2136390bf40d6b6552b69234a62f6bf48b89f0d44ac022056121c9a9d79d9d84896c9896a6fddb358b48667021ff2832b5c5871d90b701a01',
+						'02e86b90924963237c59e5389aab1cc5350c114549d1c5e7186a56ef33aea24ff9'
+					],
+					sequence: 0
+				}
+			],
+			vout: [
+				{
+					value: 5000,
+					n: 0,
+					scriptPubKey: {
+						asm: 'OP_0 a6b760eaa96a9ba91bae9465dfc4eabe711e1d67',
+						hex: '0014a6b760eaa96a9ba91bae9465dfc4eabe711e1d67',
+						address: 'tb1q56mkp64fd2d6jxawj3jal382hec3u8t8af83d7'
+					}
+				},
+				{
+					value: 6000,
+					n: 1,
+					scriptPubKey: {
+						asm: 'OP_0 6bcf920595e09b5d8f7b8d03b3694ad305757289',
+						hex: '00146bcf920595e09b5d8f7b8d03b3694ad305757289',
+						address: 'tb1qd08eypv4uzd4mrmm35pmx6226vzh2u5fqkpeyd'
+					}
+				},
+				{
+					value: 68140,
+					n: 2,
+					scriptPubKey: {
+						asm: 'OP_0 a6bd95db4dd6979189cad389daad006e236f4ba8',
+						hex: '0014a6bd95db4dd6979189cad389daad006e236f4ba8',
+						address: 'tb1q567etk6d66terzw26wya4tgqdc3k7jag0zcw3r'
+					}
+				}
+			]
+		};
+		expect(decodeRes.value).to.deep.equal(expectedDecodeRes);
+	});
+});