wallet-core/extension/background/wallet.js

/// <reference path="../decl/urijs/URIjs.d.ts" />
/// <reference path="../decl/chrome/chrome.d.ts" />
'use strict';
const DB_NAME = "taler";
const DB_VERSION = 1;
/**
 * Return a promise that resolves
 * to the taler wallet db.
 */
function openTalerDb() {
    return new Promise((resolve, reject) => {
        let req = indexedDB.open(DB_NAME, DB_VERSION);
        req.onerror = (e) => {
            reject(e);
        };
        req.onsuccess = (e) => {
            resolve(req.result);
        };
        req.onupgradeneeded = (e) => {
            let db = req.result;
            console.log("DB: upgrade needed: oldVersion = " + e.oldVersion);
            switch (e.oldVersion) {
                case 0:
                    db.createObjectStore("mints", { keyPath: "baseUrl" });
                    db.createObjectStore("reserves", { keyPath: "reserve_pub" });
                    db.createObjectStore("denoms", { keyPath: "denom_pub" });
                    db.createObjectStore("coins", { keyPath: "coin_pub" });
                    db.createObjectStore("withdrawals", { keyPath: "id", autoIncrement: true });
                    db.createObjectStore("transactions", { keyPath: "id", autoIncrement: true });
                    db.createObjectStore("precoins", { keyPath: "coinPub", autoIncrement: true });
                    break;
            }
        };
    });
}
function canonicalizeBaseUrl(url) {
    let x = new URI(url);
    if (!x.protocol()) {
        x.protocol("https");
    }
    x.path(x.path() + "/").normalizePath();
    x.fragment();
    x.query();
    return x.href();
}
function confirmReserve(db, detail, sendResponse) {
    console.log('detail: ' + JSON.stringify(detail));
    let reservePriv = EddsaPrivateKey.create();
    let reservePub = reservePriv.getPublicKey();
    let form = new FormData();
    let now = (new Date()).toString();
    form.append(detail.field_amount, detail.amount_str);
    form.append(detail.field_reserve_pub, reservePub.toCrock());
    form.append(detail.field_mint, detail.mint);
    // XXX: set bank-specified fields.
    let myRequest = new XMLHttpRequest();
    console.log("making request to " + detail.post_url);
    myRequest.open('post', detail.post_url);
    myRequest.send(form);
    let mintBaseUrl = canonicalizeBaseUrl(detail.mint);
    myRequest.addEventListener('readystatechange', (e) => {
        if (myRequest.readyState == XMLHttpRequest.DONE) {
            // TODO: extract as interface
            let resp = {
                status: myRequest.status,
                text: myRequest.responseText,
                success: undefined,
                backlink: undefined
            };
            let reserveRecord = {
                reserve_pub: reservePub.toCrock(),
                reserve_priv: reservePriv.toCrock(),
                mint_base_url: mintBaseUrl,
                created: now,
                last_query: null,
                current_amount: null,
                // XXX: set to actual amount
                initial_amount: null
            };
            // XXX: insert into db.
            switch (myRequest.status) {
                case 200:
                    resp.success = true;
                    // We can't show the page directly, so
                    // we show some generic page from the wallet.
                    resp.backlink = chrome.extension.getURL("pages/reserve-success.html");
                    let tx = db.transaction(['reserves'], 'readwrite');
                    tx.objectStore('reserves').add(reserveRecord);
                    tx.addEventListener('complete', (e) => {
                        console.log('tx complete, pk was ' + reserveRecord.reserve_pub);
                        sendResponse(resp);
                        var mint;
                        updateMintFromUrl(db, reserveRecord.mint_base_url)
                            .then((m) => { mint = m; return updateReserve(db, reservePub, mint); })
                            .then((reserve) => depleteReserve(db, reserve, mint));
                    });
                    break;
                default:
                    resp.success = false;
                    sendResponse(resp);
            }
        }
    });
    // Allow async response
    return true;
}
function copy(o) {
    return JSON.parse(JSON.stringify(o));
}
function rankDenom(denom1, denom2) {
    // Slow ... we should find a better way than to convert it evert time.
    let v1 = new Amount(denom1.value);
    let v2 = new Amount(denom2.value);
    return (-1) * v1.cmp(v2);
}
function withdrawPrepare(db, denom, reserve) {
    console.log("in withdraw prepare");
    let reservePriv = new EddsaPrivateKey();
    console.log("loading reserve priv", reserve.reserve_priv);
    reservePriv.loadCrock(reserve.reserve_priv);
    console.log("reserve priv is", reservePriv.toCrock());
    let reservePub = new EddsaPublicKey();
    reservePub.loadCrock(reserve.reserve_pub);
    let denomPub = RsaPublicKey.fromCrock(denom.denom_pub);
    let coinPriv = EddsaPrivateKey.create();
    let coinPub = coinPriv.getPublicKey();
    let blindingFactor = RsaBlindingKey.create(1024);
    let pubHash = coinPub.hash();
    console.log("about to blind");
    let ev = rsaBlind(pubHash, blindingFactor, denomPub);
    console.log("blinded");
    if (!denom.fee_withdraw) {
        throw Error("Field fee_withdraw missing");
    }
    let amountWithFee = new Amount(denom.value);
    amountWithFee.add(new Amount(denom.fee_withdraw));
    let withdrawFee = new Amount(denom.fee_withdraw);
    // Signature
    let withdrawRequest = new WithdrawRequestPS();
    withdrawRequest.set("reserve_pub", reservePub);
    withdrawRequest.set("amount_with_fee", amountWithFee.toNbo());
    withdrawRequest.set("withdraw_fee", withdrawFee.toNbo());
    withdrawRequest.set("h_denomination_pub", denomPub.encode().hash());
    withdrawRequest.set("h_coin_envelope", ev.hash());
    console.log("about to sign");
    var sig = eddsaSign(withdrawRequest.toPurpose(), reservePriv);
    console.log("signed");
    console.log("crypto done, doing request");
    let preCoin = {
        reservePub: reservePub.toCrock(),
        blindingKey: blindingFactor.toCrock(),
        coinPub: coinPub.toCrock(),
        coinPriv: coinPriv.toCrock(),
        denomPub: denomPub.encode().toCrock(),
        withdrawSig: sig.toCrock(),
        coinEv: ev.toCrock()
    };
    console.log("storing precoin", JSON.stringify(preCoin));
    let tx = db.transaction(['precoins'], 'readwrite');
    tx.objectStore('precoins').add(preCoin);
    return new Promise((resolve, reject) => {
        tx.oncomplete = (e) => {
            resolve(preCoin);
        };
    });
}
function dbGet(db, store, key) {
    let tx = db.transaction([store]);
    let req = tx.objectStore(store).get(key);
    return new Promise((resolve, reject) => {
        req.onsuccess = (e) => resolve(req.result);
    });
}
function withdrawExecute(db, pc) {
    return dbGet(db, 'reserves', pc.reservePub)
        .then((r) => new Promise((resolve, reject) => {
        console.log("loading precoin", JSON.stringify(pc));
        let wd = {};
        wd.denom_pub = pc.denomPub;
        wd.reserve_pub = pc.reservePub;
        wd.reserve_sig = pc.withdrawSig;
        wd.coin_ev = pc.coinEv;
        let reqUrl = URI("reserve/withdraw").absoluteTo(r.mint_base_url);
        let myRequest = new XMLHttpRequest();
        console.log("making request to " + reqUrl.href());
        myRequest.open('post', reqUrl.href());
        myRequest.setRequestHeader("Content-Type", "application/json;charset=UTF-8");
        myRequest.send(JSON.stringify(wd));
        myRequest.addEventListener('readystatechange', (e) => {
            if (myRequest.readyState == XMLHttpRequest.DONE) {
                if (myRequest.status != 200) {
                    console.log("Withdrawal failed, status ", myRequest.status);
                    reject();
                    return;
                }
                console.log("Withdrawal successful");
                console.log(myRequest.responseText);
                let resp = JSON.parse(myRequest.responseText);
                //let denomSig = rsaUnblind(RsaSignature.fromCrock(resp.coin_ev),
                //                            RsaBlindingKey.fromCrock(pc.blindingKey),
                //                            RsaPublicKey.fromCrock(pc.denomPub));
                let coin = {
                    coinPub: pc.coinPub,
                    coinPriv: pc.coinPriv,
                    denomPub: pc.denomPub,
                    reservePub: pc.reservePub,
                    denomSig: "foo" //denomSig.encode().toCrock()
                };
                console.log("unblinded coin");
                resolve(coin);
            }
            else {
                console.log("ready state change to", myRequest.status);
            }
        });
    }));
}
function storeCoin(db, coin) {
}
function withdraw(db, denom, reserve) {
    return withdrawPrepare(db, denom, reserve)
        .then((pc) => withdrawExecute(db, pc))
        .then((c) => storeCoin(db, c));
}
/**
 * Withdraw coins from a reserve until it is empty.
 */
function depleteReserve(db, reserve, mint) {
    let denoms = copy(mint.keys.denoms);
    let remaining = new Amount(reserve.current_amount);
    denoms.sort(rankDenom);
    let workList = [];
    for (let i = 0; i < 1000; i++) {
        let found = false;
        for (let d of denoms) {
            let cost = new Amount(d.value);
            cost.add(new Amount(d.fee_withdraw));
            if (remaining.cmp(cost) < 0) {
                continue;
            }
            found = true;
            remaining.sub(cost);
            workList.push(d);
        }
        if (!found) {
            break;
        }
    }
    // Do the request one by one.
    function next() {
        if (workList.length == 0) {
            return;
        }
        console.log("doing work");
        let d = workList.pop();
        withdraw(db, d, reserve)
            .then(() => next());
    }
    next();
}
function updateReserve(db, reservePub, mint) {
    let reserve;
    return new Promise((resolve, reject) => {
        let tx = db.transaction(['reserves']);
        tx.objectStore('reserves').get(reservePub.toCrock()).onsuccess = (e) => {
            let reserve = e.target.result;
            let reqUrl = URI("reserve/status").absoluteTo(mint.baseUrl);
            reqUrl.query({ 'reserve_pub': reservePub.toCrock() });
            let myRequest = new XMLHttpRequest();
            console.log("making request to " + reqUrl.href());
            myRequest.open('get', reqUrl.href());
            myRequest.send();
            myRequest.addEventListener('readystatechange', (e) => {
                if (myRequest.readyState == XMLHttpRequest.DONE) {
                    if (myRequest.status != 200) {
                        reject();
                        return;
                    }
                    let reserveInfo = JSON.parse(myRequest.responseText);
                    console.log("got response " + JSON.stringify(reserveInfo));
                    reserve.current_amount = reserveInfo.balance;
                    let tx = db.transaction(['reserves'], 'readwrite');
                    console.log("putting updated reserve " + JSON.stringify(reserve));
                    tx.objectStore('reserves').put(reserve);
                    tx.oncomplete = (e) => {
                        resolve(reserve);
                    };
                }
            });
        };
    });
}
/**
 * Update or add mint DB entry by fetching the /keys information.
 * Optionally link the reserve entry to the new or existing
 * mint entry in then DB.
 */
function updateMintFromUrl(db, baseUrl) {
    console.log("base url is " + baseUrl);
    let reqUrl = URI("keys").absoluteTo(baseUrl);
    let myRequest = new XMLHttpRequest();
    myRequest.open('get', reqUrl.href());
    myRequest.send();
    return new Promise((resolve, reject) => {
        myRequest.addEventListener('readystatechange', (e) => {
            console.log("state change to " + myRequest.readyState);
            if (myRequest.readyState == XMLHttpRequest.DONE) {
                if (myRequest.status == 200) {
                    console.log("got /keys");
                    let mintKeysJson = JSON.parse(myRequest.responseText);
                    if (!mintKeysJson) {
                        console.log("keys invalid");
                        reject();
                    }
                    else {
                        let mint = {
                            baseUrl: baseUrl,
                            keys: mintKeysJson
                        };
                        let tx = db.transaction(['mints'], 'readwrite');
                        tx.objectStore('mints').put(mint);
                        tx.oncomplete = (e) => {
                            resolve(mint);
                        };
                    }
                }
                else {
                    console.log("/keys request failed with status " + myRequest.status);
                    // XXX: also write last error to DB to show in the UI
                    reject();
                }
            }
        });
    });
}
function dumpDb(db, detail, sendResponse) {
    let dump = {
        name: db.name,
        version: db.version,
        stores: {}
    };
    console.log("stores: " + JSON.stringify(db.objectStoreNames));
    let tx = db.transaction(db.objectStoreNames);
    tx.addEventListener('complete', (e) => {
        sendResponse(dump);
    });
    for (let i = 0; i < db.objectStoreNames.length; i++) {
        let name = db.objectStoreNames[i];
        let storeDump = {};
        dump.stores[name] = storeDump;
        let store = tx.objectStore(name).openCursor().addEventListener('success', (e) => {
            let cursor = e.target.result;
            if (cursor) {
                storeDump[cursor.key] = cursor.value;
                cursor.continue();
            }
        });
    }
    return true;
}
openTalerDb().then((db) => {
    console.log("db loaded");
    chrome.runtime.onMessage.addListener(function (req, sender, onresponse) {
        let dispatch = {
            "confirm-reserve": confirmReserve,
            "dump-db": dumpDb
        };
        if (req.type in dispatch) {
            return dispatch[req.type](db, req.detail, onresponse);
        }
        console.error(format("Request type unknown, req {0}", JSON.stringify(req)));
        return false;
    });
});