@arkade-os/sdk 0.0.16

package/dist/esm/utils/coinselect.js

@@ -0,0 +1,69 @@
+/**
+ * Select coins to reach a target amount, prioritizing those closer to expiry
+ * @param coins List of coins to select from
+ * @param targetAmount Target amount to reach in satoshis
+ * @returns Selected coins and change amount, or null if insufficient funds
+ */
+export function selectCoins(coins, targetAmount) {
+    // Sort coins by amount (descending)
+    const sortedCoins = [...coins].sort((a, b) => b.value - a.value);
+    const selectedCoins = [];
+    let selectedAmount = 0;
+    // Select coins until we have enough
+    for (const coin of sortedCoins) {
+        selectedCoins.push(coin);
+        selectedAmount += coin.value;
+        if (selectedAmount >= targetAmount) {
+            break;
+        }
+    }
+    // Check if we have enough
+    if (selectedAmount < targetAmount) {
+        return { inputs: null, changeAmount: 0 };
+    }
+    // Calculate change
+    const changeAmount = selectedAmount - targetAmount;
+    return {
+        inputs: selectedCoins,
+        changeAmount,
+    };
+}
+/**
+ * Select virtual coins to reach a target amount, prioritizing those closer to expiry
+ * @param coins List of virtual coins to select from
+ * @param targetAmount Target amount to reach in satoshis
+ * @returns Selected coins and change amount, or null if insufficient funds
+ */
+export function selectVirtualCoins(coins, targetAmount) {
+    // Sort VTXOs by expiry (ascending) and amount (descending)
+    const sortedCoins = [...coins].sort((a, b) => {
+        // First sort by expiry if available
+        const expiryA = a.virtualStatus.batchExpiry || Number.MAX_SAFE_INTEGER;
+        const expiryB = b.virtualStatus.batchExpiry || Number.MAX_SAFE_INTEGER;
+        if (expiryA !== expiryB) {
+            return expiryA - expiryB; // Earlier expiry first
+        }
+        // Then sort by amount
+        return b.value - a.value; // Larger amount first
+    });
+    const selectedCoins = [];
+    let selectedAmount = 0;
+    // Select coins until we have enough
+    for (const coin of sortedCoins) {
+        selectedCoins.push(coin);
+        selectedAmount += coin.value;
+        if (selectedAmount >= targetAmount) {
+            break;
+        }
+    }
+    // Check if we have enough
+    if (selectedAmount < targetAmount) {
+        return { inputs: null, changeAmount: 0 };
+    }
+    // Calculate change
+    const changeAmount = selectedAmount - targetAmount;
+    return {
+        inputs: selectedCoins,
+        changeAmount,
+    };
+}

package/dist/esm/utils/psbt.js

@@ -0,0 +1,118 @@
+import { DEFAULT_SEQUENCE, RawWitness, Transaction } from "@scure/btc-signer";
+import { CLTVMultisigTapscript, decodeTapscript } from '../script/tapscript.js';
+import { scriptFromTapLeafScript, VtxoScript, } from '../script/base.js';
+import { ArkAddress } from '../script/address.js';
+import { hex } from "@scure/base";
+const ARK_UNKNOWN_KEY_TYPE = 255;
+// Constant for condition witness key prefix
+export const CONDITION_WITNESS_KEY_PREFIX = new TextEncoder().encode("condition");
+export const VTXO_TAPROOT_TREE_KEY_PREFIX = new TextEncoder().encode("taptree");
+export function addVtxoTaprootTree(inIndex, tx, scripts) {
+    tx.updateInput(inIndex, {
+        unknown: [
+            ...(tx.getInput(inIndex)?.unknown ?? []),
+            [
+                {
+                    type: ARK_UNKNOWN_KEY_TYPE,
+                    key: VTXO_TAPROOT_TREE_KEY_PREFIX,
+                },
+                encodeTaprootTree(scripts),
+            ],
+        ],
+    });
+}
+export function addConditionWitness(inIndex, tx, witness) {
+    const witnessBytes = RawWitness.encode(witness);
+    tx.updateInput(inIndex, {
+        unknown: [
+            ...(tx.getInput(inIndex)?.unknown ?? []),
+            [
+                {
+                    type: ARK_UNKNOWN_KEY_TYPE,
+                    key: CONDITION_WITNESS_KEY_PREFIX,
+                },
+                witnessBytes,
+            ],
+        ],
+    });
+}
+export function createVirtualTx(inputs, outputs) {
+    let lockTime;
+    for (const input of inputs) {
+        const tapscript = decodeTapscript(scriptFromTapLeafScript(input.tapLeafScript));
+        if (CLTVMultisigTapscript.is(tapscript)) {
+            lockTime = Number(tapscript.params.absoluteTimelock);
+        }
+    }
+    const tx = new Transaction({
+        allowUnknown: true,
+        lockTime,
+    });
+    for (const [i, input] of inputs.entries()) {
+        tx.addInput({
+            txid: input.txid,
+            index: input.vout,
+            sequence: lockTime ? DEFAULT_SEQUENCE - 1 : undefined,
+            witnessUtxo: {
+                script: VtxoScript.decode(input.scripts).pkScript,
+                amount: BigInt(input.value),
+            },
+            tapLeafScript: [input.tapLeafScript],
+        });
+        // add BIP371 encoded taproot tree to the unknown key field
+        addVtxoTaprootTree(i, tx, input.scripts.map(hex.decode));
+    }
+    for (const output of outputs) {
+        tx.addOutput({
+            amount: output.amount,
+            script: ArkAddress.decode(output.address).pkScript,
+        });
+    }
+    return tx;
+}
+function encodeTaprootTree(leaves) {
+    const chunks = [];
+    // Write number of leaves as compact size uint
+    chunks.push(encodeCompactSizeUint(leaves.length));
+    for (const tapscript of leaves) {
+        // Write depth (always 1 for now)
+        chunks.push(new Uint8Array([1]));
+        // Write leaf version (0xc0 for tapscript)
+        chunks.push(new Uint8Array([0xc0]));
+        // Write script length and script
+        chunks.push(encodeCompactSizeUint(tapscript.length));
+        chunks.push(tapscript);
+    }
+    // Concatenate all chunks
+    const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+        result.set(chunk, offset);
+        offset += chunk.length;
+    }
+    return result;
+}
+function encodeCompactSizeUint(value) {
+    if (value < 0xfd) {
+        return new Uint8Array([value]);
+    }
+    else if (value <= 0xffff) {
+        const buffer = new Uint8Array(3);
+        buffer[0] = 0xfd;
+        new DataView(buffer.buffer).setUint16(1, value, true);
+        return buffer;
+    }
+    else if (value <= 0xffffffff) {
+        const buffer = new Uint8Array(5);
+        buffer[0] = 0xfe;
+        new DataView(buffer.buffer).setUint32(1, value, true);
+        return buffer;
+    }
+    else {
+        const buffer = new Uint8Array(9);
+        buffer[0] = 0xff;
+        new DataView(buffer.buffer).setBigUint64(1, BigInt(value), true);
+        return buffer;
+    }
+}

package/dist/esm/utils/transactionHistory.js

@@ -0,0 +1,145 @@
+import { TxType } from '../wallet/index.js';
+/**
+ * Helper function to find vtxos that were spent in a settlement
+ */
+function findVtxosSpentInSettlement(vtxos, vtxo) {
+    if (vtxo.virtualStatus.state === "pending") {
+        return [];
+    }
+    return vtxos.filter((v) => {
+        if (!v.spentBy)
+            return false;
+        return v.spentBy === vtxo.virtualStatus.batchTxID;
+    });
+}
+/**
+ * Helper function to find vtxos that were spent in a payment
+ */
+function findVtxosSpentInPayment(vtxos, vtxo) {
+    return vtxos.filter((v) => {
+        if (!v.spentBy)
+            return false;
+        return v.spentBy === vtxo.txid;
+    });
+}
+/**
+ * Helper function to find vtxos that resulted from a spentBy transaction
+ */
+function findVtxosResultedFromSpentBy(vtxos, spentBy) {
+    return vtxos.filter((v) => {
+        if (v.virtualStatus.state !== "pending" &&
+            v.virtualStatus.batchTxID === spentBy) {
+            return true;
+        }
+        return v.txid === spentBy;
+    });
+}
+/**
+ * Helper function to reduce vtxos to their total amount
+ */
+function reduceVtxosAmount(vtxos) {
+    return vtxos.reduce((sum, v) => sum + v.value, 0);
+}
+/**
+ * Helper function to get a vtxo from a list of vtxos
+ */
+function getVtxo(resultedVtxos, spentVtxos) {
+    if (resultedVtxos.length === 0) {
+        return spentVtxos[0];
+    }
+    return resultedVtxos[0];
+}
+export function vtxosToTxs(spendable, spent, boardingRounds) {
+    const txs = [];
+    // Receive case
+    // All vtxos are received unless:
+    // - they resulted from a settlement (either boarding or refresh)
+    // - they are the change of a spend tx
+    let vtxosLeftToCheck = [...spent];
+    for (const vtxo of [...spendable, ...spent]) {
+        if (vtxo.virtualStatus.state !== "pending" &&
+            boardingRounds.has(vtxo.virtualStatus.batchTxID || "")) {
+            continue;
+        }
+        const settleVtxos = findVtxosSpentInSettlement(vtxosLeftToCheck, vtxo);
+        vtxosLeftToCheck = removeVtxosFromList(vtxosLeftToCheck, settleVtxos);
+        const settleAmount = reduceVtxosAmount(settleVtxos);
+        if (vtxo.value <= settleAmount) {
+            continue; // settlement or change, ignore
+        }
+        const spentVtxos = findVtxosSpentInPayment(vtxosLeftToCheck, vtxo);
+        vtxosLeftToCheck = removeVtxosFromList(vtxosLeftToCheck, spentVtxos);
+        const spentAmount = reduceVtxosAmount(spentVtxos);
+        if (vtxo.value <= spentAmount) {
+            continue; // settlement or change, ignore
+        }
+        const txKey = {
+            roundTxid: vtxo.virtualStatus.batchTxID || "",
+            boardingTxid: "",
+            redeemTxid: "",
+        };
+        let settled = vtxo.virtualStatus.state !== "pending";
+        if (vtxo.virtualStatus.state === "pending") {
+            txKey.redeemTxid = vtxo.txid;
+            if (vtxo.spentBy) {
+                settled = true;
+            }
+        }
+        txs.push({
+            key: txKey,
+            amount: vtxo.value - settleAmount - spentAmount,
+            type: TxType.TxReceived,
+            createdAt: vtxo.createdAt.getTime(),
+            settled,
+        });
+    }
+    // send case
+    // All "spentBy" vtxos are payments unless:
+    // - they are settlements
+    // aggregate spent by spentId
+    const vtxosBySpentBy = new Map();
+    for (const v of spent) {
+        if (!v.spentBy)
+            continue;
+        if (!vtxosBySpentBy.has(v.spentBy)) {
+            vtxosBySpentBy.set(v.spentBy, []);
+        }
+        const currentVtxos = vtxosBySpentBy.get(v.spentBy);
+        vtxosBySpentBy.set(v.spentBy, [...currentVtxos, v]);
+    }
+    for (const [sb, vtxos] of vtxosBySpentBy) {
+        const resultedVtxos = findVtxosResultedFromSpentBy([...spendable, ...spent], sb);
+        const resultedAmount = reduceVtxosAmount(resultedVtxos);
+        const spentAmount = reduceVtxosAmount(vtxos);
+        if (spentAmount <= resultedAmount) {
+            continue; // settlement or change, ignore
+        }
+        const vtxo = getVtxo(resultedVtxos, vtxos);
+        const txKey = {
+            roundTxid: vtxo.virtualStatus.batchTxID || "",
+            boardingTxid: "",
+            redeemTxid: "",
+        };
+        if (vtxo.virtualStatus.state === "pending") {
+            txKey.redeemTxid = vtxo.txid;
+        }
+        txs.push({
+            key: txKey,
+            amount: spentAmount - resultedAmount,
+            type: TxType.TxSent,
+            createdAt: vtxo.createdAt.getTime(),
+            settled: true,
+        });
+    }
+    return txs;
+}
+function removeVtxosFromList(vtxos, vtxosToRemove) {
+    return vtxos.filter((v) => {
+        for (const vtxoToRemove of vtxosToRemove) {
+            if (v.txid === vtxoToRemove.txid && v.vout === vtxoToRemove.vout) {
+                return false;
+            }
+        }
+        return true;
+    });
+}

package/dist/esm/utils/txSizeEstimator.js

@@ -0,0 +1,91 @@
+export class TxWeightEstimator {
+    constructor(hasWitness, inputCount, outputCount, inputSize, inputWitnessSize, outputSize) {
+        this.hasWitness = hasWitness;
+        this.inputCount = inputCount;
+        this.outputCount = outputCount;
+        this.inputSize = inputSize;
+        this.inputWitnessSize = inputWitnessSize;
+        this.outputSize = outputSize;
+    }
+    static create() {
+        return new TxWeightEstimator(false, 0, 0, 0, 0, 0);
+    }
+    addKeySpendInput(isDefault = true) {
+        this.inputCount++;
+        this.inputWitnessSize += 64 + 1 + (isDefault ? 0 : 1);
+        this.inputSize += TxWeightEstimator.INPUT_SIZE;
+        this.hasWitness = true;
+        return this;
+    }
+    addP2PKHInput() {
+        this.inputCount++;
+        this.inputWitnessSize++;
+        this.inputSize +=
+            TxWeightEstimator.INPUT_SIZE +
+                TxWeightEstimator.P2PKH_SCRIPT_SIG_SIZE;
+        return this;
+    }
+    addTapscriptInput(leafWitnessSize, leafScriptSize, leafControlBlockSize) {
+        const controlBlockWitnessSize = 1 +
+            TxWeightEstimator.BASE_CONTROL_BLOCK_SIZE +
+            1 +
+            leafScriptSize +
+            1 +
+            leafControlBlockSize;
+        this.inputCount++;
+        this.inputWitnessSize += leafWitnessSize + controlBlockWitnessSize;
+        this.inputSize += TxWeightEstimator.INPUT_SIZE;
+        this.hasWitness = true;
+        this.inputCount++;
+        return this;
+    }
+    addP2WKHOutput() {
+        this.outputCount++;
+        this.outputSize +=
+            TxWeightEstimator.OUTPUT_SIZE + TxWeightEstimator.P2WKH_OUTPUT_SIZE;
+        return this;
+    }
+    vsize() {
+        const getVarIntSize = (n) => {
+            if (n < 0xfd)
+                return 1;
+            if (n < 0xffff)
+                return 3;
+            if (n < 0xffffffff)
+                return 5;
+            return 9;
+        };
+        const inputCount = getVarIntSize(this.inputCount);
+        const outputCount = getVarIntSize(this.outputCount);
+        // Calculate the size of the transaction without witness data
+        const txSizeStripped = TxWeightEstimator.BASE_TX_SIZE +
+            inputCount +
+            this.inputSize +
+            outputCount +
+            this.outputSize;
+        // Calculate the total weight
+        let weight = txSizeStripped * TxWeightEstimator.WITNESS_SCALE_FACTOR;
+        // Add witness data if present
+        if (this.hasWitness) {
+            weight +=
+                TxWeightEstimator.WITNESS_HEADER_SIZE + this.inputWitnessSize;
+        }
+        // Convert weight to vsize (weight / 4, rounded up)
+        return vsize(weight);
+    }
+}
+TxWeightEstimator.P2PKH_SCRIPT_SIG_SIZE = 1 + 73 + 1 + 33;
+TxWeightEstimator.INPUT_SIZE = 32 + 4 + 1 + 4;
+TxWeightEstimator.BASE_CONTROL_BLOCK_SIZE = 1 + 32;
+TxWeightEstimator.OUTPUT_SIZE = 8 + 1;
+TxWeightEstimator.P2WKH_OUTPUT_SIZE = 1 + 1 + 20;
+TxWeightEstimator.BASE_TX_SIZE = 8 + 2; // Version + LockTime
+TxWeightEstimator.WITNESS_HEADER_SIZE = 2; // Flag + Marker
+TxWeightEstimator.WITNESS_SCALE_FACTOR = 4;
+const vsize = (weight) => {
+    const value = BigInt(Math.ceil(weight / TxWeightEstimator.WITNESS_SCALE_FACTOR));
+    return {
+        value,
+        fee: (feeRate) => feeRate * value,
+    };
+};

package/dist/esm/wallet/index.js

@@ -0,0 +1,5 @@
+export var TxType;
+(function (TxType) {
+    TxType["TxSent"] = "SENT";
+    TxType["TxReceived"] = "RECEIVED";
+})(TxType || (TxType = {}));

package/dist/esm/wallet/serviceWorker/db/vtxo/idb.js

@@ -0,0 +1,149 @@
+export class IndexedDBVtxoRepository {
+    constructor() {
+        this.db = null;
+    }
+    static delete() {
+        return new Promise((resolve, reject) => {
+            try {
+                const request = indexedDB.deleteDatabase(IndexedDBVtxoRepository.DB_NAME);
+                request.onblocked = () => {
+                    // If blocked, wait a bit and try again
+                    setTimeout(() => {
+                        const retryRequest = indexedDB.deleteDatabase(IndexedDBVtxoRepository.DB_NAME);
+                        retryRequest.onsuccess = () => resolve();
+                        retryRequest.onerror = () => reject(retryRequest.error ||
+                            new Error("Failed to delete database"));
+                    }, 100);
+                };
+                request.onsuccess = () => {
+                    resolve();
+                };
+                request.onerror = () => {
+                    reject(request.error || new Error("Failed to delete database"));
+                };
+            }
+            catch (error) {
+                reject(error instanceof Error
+                    ? error
+                    : new Error("Failed to delete database"));
+            }
+        });
+    }
+    async close() {
+        if (this.db) {
+            this.db.close();
+            this.db = null;
+        }
+    }
+    async open() {
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(IndexedDBVtxoRepository.DB_NAME, IndexedDBVtxoRepository.DB_VERSION);
+            request.onerror = () => {
+                reject(request.error);
+            };
+            request.onsuccess = () => {
+                this.db = request.result;
+                resolve();
+            };
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                if (!db.objectStoreNames.contains(IndexedDBVtxoRepository.STORE_NAME)) {
+                    const store = db.createObjectStore(IndexedDBVtxoRepository.STORE_NAME, {
+                        keyPath: ["txid", "vout"],
+                    });
+                    store.createIndex("state", "virtualStatus.state", {
+                        unique: false,
+                    });
+                    store.createIndex("spentBy", "spentBy", {
+                        unique: false,
+                    });
+                }
+            };
+        });
+    }
+    async addOrUpdate(vtxos) {
+        if (!this.db) {
+            throw new Error("Database not opened");
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readwrite");
+            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
+            const requests = vtxos.map((vtxo) => {
+                return new Promise((resolveRequest, rejectRequest) => {
+                    const request = store.put(vtxo);
+                    request.onsuccess = () => resolveRequest();
+                    request.onerror = () => rejectRequest(request.error);
+                });
+            });
+            Promise.all(requests)
+                .then(() => resolve())
+                .catch(reject);
+        });
+    }
+    async deleteAll() {
+        if (!this.db) {
+            throw new Error("Database not opened");
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readwrite");
+            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
+            const request = store.clear();
+            request.onsuccess = () => resolve();
+            request.onerror = () => reject(request.error);
+        });
+    }
+    async getSpendableVtxos() {
+        if (!this.db) {
+            throw new Error("Database not opened");
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readonly");
+            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
+            const spentByIndex = store.index("spentBy");
+            // Get vtxos where spentBy is empty string
+            const request = spentByIndex.getAll(IDBKeyRange.only(""));
+            request.onsuccess = () => {
+                resolve(request.result);
+            };
+            request.onerror = () => reject(request.error);
+        });
+    }
+    async getAllVtxos() {
+        if (!this.db) {
+            throw new Error("Database not opened");
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction(IndexedDBVtxoRepository.STORE_NAME, "readonly");
+            const store = transaction.objectStore(IndexedDBVtxoRepository.STORE_NAME);
+            const spentByIndex = store.index("spentBy");
+            // Get vtxos where spentBy is empty string
+            const spendableRequest = spentByIndex.getAll(IDBKeyRange.only(""));
+            // Get all vtxos where spentBy is populated
+            const spentRequest = spentByIndex.getAll(IDBKeyRange.lowerBound("", true));
+            Promise.all([
+                new Promise((resolveSpendable, rejectSpendable) => {
+                    spendableRequest.onsuccess = () => {
+                        resolveSpendable(spendableRequest.result);
+                    };
+                    spendableRequest.onerror = () => rejectSpendable(spendableRequest.error);
+                }),
+                new Promise((resolveSpent, rejectSpent) => {
+                    spentRequest.onsuccess = () => {
+                        resolveSpent(spentRequest.result);
+                    };
+                    spentRequest.onerror = () => rejectSpent(spentRequest.error);
+                }),
+            ])
+                .then(([spendableVtxos, spentVtxos]) => {
+                resolve({
+                    spendable: spendableVtxos,
+                    spent: spentVtxos,
+                });
+            })
+                .catch(reject);
+        });
+    }
+}
+IndexedDBVtxoRepository.DB_NAME = "wallet-db";
+IndexedDBVtxoRepository.STORE_NAME = "vtxos";
+IndexedDBVtxoRepository.DB_VERSION = 1;

package/dist/esm/wallet/serviceWorker/db/vtxo/index.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/wallet/serviceWorker/request.js

@@ -0,0 +1,72 @@
+export var Request;
+(function (Request) {
+    function isBase(message) {
+        return (typeof message === "object" && message !== null && "type" in message);
+    }
+    Request.isBase = isBase;
+    function isInitWallet(message) {
+        return (message.type === "INIT_WALLET" &&
+            "privateKey" in message &&
+            typeof message.privateKey === "string" &&
+            "arkServerUrl" in message &&
+            typeof message.arkServerUrl === "string" &&
+            "network" in message &&
+            typeof message.network === "string" &&
+            ("arkServerPublicKey" in message
+                ? typeof message.arkServerPublicKey === "string" ||
+                    message.arkServerPublicKey === undefined
+                : true));
+    }
+    Request.isInitWallet = isInitWallet;
+    function isSettle(message) {
+        return message.type === "SETTLE";
+    }
+    Request.isSettle = isSettle;
+    function isGetAddress(message) {
+        return message.type === "GET_ADDRESS";
+    }
+    Request.isGetAddress = isGetAddress;
+    function isGetAddressInfo(message) {
+        return message.type === "GET_ADDRESS_INFO";
+    }
+    Request.isGetAddressInfo = isGetAddressInfo;
+    function isGetBalance(message) {
+        return message.type === "GET_BALANCE";
+    }
+    Request.isGetBalance = isGetBalance;
+    function isGetCoins(message) {
+        return message.type === "GET_COINS";
+    }
+    Request.isGetCoins = isGetCoins;
+    function isGetVtxos(message) {
+        return message.type === "GET_VTXOS";
+    }
+    Request.isGetVtxos = isGetVtxos;
+    function isGetVirtualCoins(message) {
+        return message.type === "GET_VIRTUAL_COINS";
+    }
+    Request.isGetVirtualCoins = isGetVirtualCoins;
+    function isGetBoardingUtxos(message) {
+        return message.type === "GET_BOARDING_UTXOS";
+    }
+    Request.isGetBoardingUtxos = isGetBoardingUtxos;
+    function isSendBitcoin(message) {
+        return (message.type === "SEND_BITCOIN" &&
+            "params" in message &&
+            message.params !== null &&
+            typeof message.params === "object" &&
+            "address" in message.params &&
+            typeof message.params.address === "string" &&
+            "amount" in message.params &&
+            typeof message.params.amount === "number");
+    }
+    Request.isSendBitcoin = isSendBitcoin;
+    function isGetTransactionHistory(message) {
+        return message.type === "GET_TRANSACTION_HISTORY";
+    }
+    Request.isGetTransactionHistory = isGetTransactionHistory;
+    function isGetStatus(message) {
+        return message.type === "GET_STATUS";
+    }
+    Request.isGetStatus = isGetStatus;
+})(Request || (Request = {}));