shield-bridge-sdk/dist/worker.js

Shield Bridge SDK

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
import { expose } from 'threads/worker';
import { RpcReadAdapter } from '@taquito/taquito';
import { SaplingToolkit, InMemorySpendingKey } from '@taquito/sapling';
import { RpcClient } from '@taquito/rpc';
import { Prefix, prefix, b58cencode } from '@taquito/utils';
import * as sapling from '@airgap/sapling-wasm';
import * as bip39 from 'bip39';
const SECRET_KEY_METHOD = 'secretKey';
const MNEMONIC_METHOD = 'mnemonic';
let iMSK;
let sTk;
const createExtendedSpendingKey = (mnemonic) => __awaiter(void 0, void 0, void 0, function* () {
    const fullSeed = yield bip39.mnemonicToSeed(mnemonic);
    const first32 = fullSeed.subarray(0, 32);
    const second32 = fullSeed.subarray(32);
    const seed = Buffer.from(
    // eslint-disable-next-line no-bitwise
    first32.map((byte, index) => byte ^ second32[index]));
    const spendingKeyArr = new Uint8Array(yield sapling.getExtendedSpendingKey(seed, 'm/'));
    return b58cencode(spendingKeyArr, prefix[Prefix.SASK]);
});
const loadSaplingSecret = (_a) => __awaiter(void 0, [_a], void 0, function* ({ sk, saplingDetails, rpcUrl, skType = MNEMONIC_METHOD, }) {
    try {
        const secretKey = sk;
        const loadAccountMethod = skType;
        if (loadAccountMethod === SECRET_KEY_METHOD) {
            iMSK = new InMemorySpendingKey(secretKey);
        }
        else if (loadAccountMethod === MNEMONIC_METHOD) {
            iMSK = yield InMemorySpendingKey.fromMnemonic(secretKey);
        }
        else {
            throw new Error('Invalid account loading method provided');
        }
    }
    catch (err) {
        iMSK = null;
        sTk = null;
        throw err;
    }
    try {
        sTk = new SaplingToolkit({ saplingSigner: iMSK }, saplingDetails, new RpcReadAdapter(new RpcClient(rpcUrl)));
    }
    catch (err) {
        iMSK = null;
        sTk = null;
        throw err;
    }
});
const getPaymentAddress = () => iMSK
    .getSaplingViewingKeyProvider()
    .then((inMemoryViewingKey) => inMemoryViewingKey.getAddress());
const prepareShieldedTransaction = (shieldTransactions) => sTk
    .prepareShieldedTransaction(shieldTransactions)
    .catch((err) => console.error(err.message));
const prepareUnshieldedTransaction = (unshieldTransaction) => sTk
    .prepareUnshieldedTransaction(unshieldTransaction)
    .catch((err) => console.error(err.message));
const prepareSaplingTransaction = (saplingTransactions = []) => sTk
    .prepareSaplingTransaction(saplingTransactions)
    .catch((err) => console.error(err.message));
const getSaplingBalance = () => sTk
    .getSaplingTransactionViewer()
    .then((txViewer) => txViewer.getBalance().then((balance) => balance.toNumber()))
    .catch((err) => console.error(err.message));
const getSaplingTransactions = () => sTk
    .getSaplingTransactionViewer()
    .then((txViewer) => txViewer.getIncomingAndOutgoingTransactions())
    .then((transactionHistory) => ({
    incoming: transactionHistory.incoming.map((tx) => (Object.assign(Object.assign({}, tx), { value: tx.value.toNumber() }))),
    outgoing: transactionHistory.outgoing.map((tx) => (Object.assign(Object.assign({}, tx), { value: tx.value.toNumber() }))),
}))
    .catch((err) => console.error(err.message));
const reInitializeSapling = () => {
    iMSK = null;
    sTk = null;
};
const saplingWorker = {
    createExtendedSpendingKey,
    loadSaplingSecret,
    getPaymentAddress,
    prepareShieldedTransaction,
    prepareUnshieldedTransaction,
    prepareSaplingTransaction,
    getSaplingBalance,
    getSaplingTransactions,
    reInitializeSapling,
};
expose(saplingWorker);