/*jslint node: true */ "use strict"; var async = require('async'); var _ = require('lodash'); var constants = require('./constants.js'); var storage = require('./storage.js'); var objectHash = require("./object_hash.js"); var db = require('./db.js'); var composer = require("./composer.js"); var ValidationUtils = require('./validation_utils.js'); var validation = require('./validation.js'); var writer = require('./writer.js'); var inputs = require('./inputs.js'); var conf = require('./conf.js'); var mutex = require('./mutex.js'); function validateAndSavePrivatePaymentChain(conn, arrPrivateElements, callbacks){ // we always have only one element validateAndSaveDivisiblePrivatePayment(conn, arrPrivateElements[0], callbacks); } function validateAndSaveDivisiblePrivatePayment(conn, objPrivateElement, callbacks){ validateDivisiblePrivatePayment(conn, objPrivateElement, { ifError: callbacks.ifError, ifOk: function(bStable, arrAuthorAddresses){ console.log("private validation OK "+bStable); var unit = objPrivateElement.unit; var message_index = objPrivateElement.message_index; var payload = objPrivateElement.payload; var arrQueries = []; for (var j=0; j o.amount === 0)) bAlreadyHaveChange = true; if (params.outputs_by_asset && params.outputs_by_asset.base && params.outputs_by_asset.base.find(o => o.amount === 0)) bAlreadyHaveChange = true; var arrBaseOutputs = bAlreadyHaveChange ? [] : [{address: params.fee_paying_addresses[0], amount: 0}]; // public outputs: the change only if (params.base_outputs) arrBaseOutputs = arrBaseOutputs.concat(params.base_outputs); if (params.outputs_by_asset && params.outputs_by_asset.base) arrBaseOutputs = arrBaseOutputs.concat(params.outputs_by_asset.base); var arrAssetPayments = []; if (params.to_address) arrAssetPayments.push({ asset: params.asset, outputs: [{ address: params.to_address, amount: params.amount }] }); else if (params.asset_outputs) arrAssetPayments.push({ asset: params.asset, outputs: params.asset_outputs }); else if (params.outputs_by_asset) for (var a in params.outputs_by_asset) if (a !== 'base') arrAssetPayments.push({ asset: a, outputs: params.outputs_by_asset[a] }); composer.composeJoint({ paying_addresses: _.union(params.paying_addresses, params.fee_paying_addresses), // addresses that pay for the transfer and commissions signing_addresses: params.signing_addresses, minimal: params.minimal, outputs: arrBaseOutputs, messages:params.messages, spend_unconfirmed: params.spend_unconfirmed || conf.spend_unconfirmed || 'own', max_fee_ratio: params.max_fee_ratio, burn_fee: params.burn_fee, max_aa_responses: params.max_aa_responses, // function that creates additional messages to be added to the joint retrieveMessages: function(conn, last_ball_mci, bMultiAuthored, arrPayingAddresses, onDone){ var arrAssetPayingAddresses = _.intersection(arrPayingAddresses, params.paying_addresses); var messages = []; var assocPrivatePayloads = {}; async.eachSeries( arrAssetPayments, function (payment, cb) { storage.loadAssetWithListOfAttestedAuthors(conn, payment.asset, last_ball_mci, arrAssetPayingAddresses, function(err, objAsset){ if (err) return cb(err); if (objAsset.fixed_denominations) return cb("fixed denominations asset type"); // fix: also check change address when not transferrable if (!objAsset.is_transferrable && params.to_address !== objAsset.definer_address && arrAssetPayingAddresses.indexOf(objAsset.definer_address) === -1) return cb("the asset is not transferrable and definer not found on either side of the deal"); if (objAsset.cosigned_by_definer && arrPayingAddresses.concat(params.signing_addresses || []).indexOf(objAsset.definer_address) === -1) return cb("the asset must be cosigned by definer"); if (!conf.bLight && objAsset.spender_attested && objAsset.arrAttestedAddresses.length === 0) return cb("none of the authors is attested"); var target_amount = payment.outputs.reduce(function(accumulator, output){ return accumulator + output.amount; }, 0); inputs.pickDivisibleCoinsForAmount( conn, objAsset, arrAssetPayingAddresses, last_ball_mci, target_amount, 0, 0, bMultiAuthored, params.spend_unconfirmed || conf.spend_unconfirmed || 'own', function(arrInputsWithProofs, total_input){ console.log("pick coins callback "+JSON.stringify(arrInputsWithProofs)); if (!arrInputsWithProofs) return cb({error_code: "NOT_ENOUGH_FUNDS", error: "not enough asset coins"}); var arrOutputs = payment.outputs; var change = total_input - target_amount; if (change > 0){ var objChangeOutput = {address: params.change_address, amount: change}; arrOutputs.push(objChangeOutput); } if (objAsset.is_private) arrOutputs.forEach(function(output){ output.blinding = composer.generateBlinding(); }); arrOutputs.sort(composer.sortOutputs); var payload = { asset: payment.asset, inputs: arrInputsWithProofs.map(function(objInputWithProof){ return objInputWithProof.input; }), outputs: arrOutputs }; var objMessage = { app: "payment", payload_location: objAsset.is_private ? "none" : "inline", payload_hash: objectHash.getBase64Hash(payload, last_ball_mci >= constants.timestampUpgradeMci) }; if (objAsset.is_private){ objMessage.spend_proofs = arrInputsWithProofs.map(function(objInputWithProof){ return objInputWithProof.spend_proof; }); private_payload = payload; assocPrivatePayloads[objMessage.payload_hash] = private_payload; } else objMessage.payload = payload; messages.push(objMessage); cb(); } ); }); }, function (err) { if (err) return onDone(err); onDone(null, messages, assocPrivatePayloads); } ); }, signer: params.signer, callbacks: { ifError: params.callbacks.ifError, ifNotEnoughFunds: params.callbacks.ifNotEnoughFunds, ifOk: function(objJoint, assocPrivatePayloads, composer_unlock_callback){ // adding private_payload params.callbacks.ifOk(objJoint, assocPrivatePayloads, composer_unlock_callback); } } }); } // ifOk validates and saves before calling back function getSavingCallbacks(callbacks){ return { ifError: callbacks.ifError, ifNotEnoughFunds: callbacks.ifNotEnoughFunds, ifOk: async function(objJoint, assocPrivatePayloads, composer_unlock){ var objUnit = objJoint.unit; var unit = objUnit.unit; const validate_and_save_unlock = await mutex.lock('handleJoint'); const combined_unlock = () => { validate_and_save_unlock(); composer_unlock(); }; validation.validate(objJoint, { ifUnitError: function(err){ combined_unlock(); callbacks.ifError("Validation error: "+err); // throw Error("unexpected validation error: "+err); }, ifJointError: function(err){ throw Error("unexpected validation joint error: "+err); }, ifTransientError: function(err){ throw Error("unexpected validation transient error: "+err); }, ifNeedHashTree: function(){ throw Error("unexpected need hash tree"); }, ifNeedParentUnits: function(arrMissingUnits){ throw Error("unexpected dependencies: "+arrMissingUnits.join(", ")); }, ifOk: function(objValidationState, validation_unlock){ console.log("divisible asset OK "+objValidationState.sequence); if (objValidationState.sequence !== 'good'){ validation_unlock(); combined_unlock(); return callbacks.ifError("Divisible asset bad sequence "+objValidationState.sequence); } var bPrivate = !!assocPrivatePayloads; var arrPrivateElements = []; var preCommitCallback = null; if (bPrivate){ preCommitCallback = function(conn, cb){ async.eachSeries( Object.keys(assocPrivatePayloads), function(payload_hash, cb2){ var payload = assocPrivatePayloads[payload_hash]; var message_index = composer.getMessageIndexByPayloadHash(objUnit, payload_hash); var objPrivateElement = { unit: unit, message_index: message_index, payload: payload }; validateAndSaveDivisiblePrivatePayment(conn, objPrivateElement, { ifError: function(err){ cb2(err); }, ifOk: function(){ arrPrivateElements.push(objPrivateElement); cb2(); } }); }, cb ); }; } else { if (typeof callbacks.preCommitCb === "function") { preCommitCallback = function(conn, cb){ callbacks.preCommitCb(conn, objJoint, cb); } } } composer.postJointToLightVendorIfNecessaryAndSave( objJoint, function onLightError(err){ // light only console.log("failed to post divisible payment "+unit); validation_unlock(); combined_unlock(); callbacks.ifError(err); }, function save(){ writer.saveJoint( objJoint, objValidationState, preCommitCallback, function onDone(err){ console.log("saved unit "+unit+", err="+err, arrPrivateElements); validation_unlock(); combined_unlock(); var arrChains = arrPrivateElements.length ? arrPrivateElements.map(function(objPrivateElement){ return [objPrivateElement]; }) : null; // each chain consists of one element callbacks.ifOk(objJoint, arrChains, arrChains); } ); } ); } // ifOk validation }); // validate } }; } // {asset: asset, paying_addresses: arrPayingAddresses, fee_paying_addresses: arrFeePayingAddresses, change_address: change_address, to_address: to_address, amount: amount, signer: signer, callbacks: callbacks} function composeAndSaveDivisibleAssetPaymentJoint(params){ var params_with_save = _.clone(params); params_with_save.callbacks = params.compose_only ? composer.getNonsavingCallbacks(params.callbacks) : getSavingCallbacks(params.callbacks); composeDivisibleAssetPaymentJoint(params_with_save); } var TYPICAL_FEE = 1000; // {asset: asset, available_paying_addresses: arrAvailablePayingAddresses, available_fee_paying_addresses: arrAvailableFeePayingAddresses, change_address: change_address, to_address: to_address, amount: amount, signer: signer, callbacks: callbacks} function composeMinimalDivisibleAssetPaymentJoint(params){ if (!ValidationUtils.isNonemptyArray(params.available_paying_addresses)) throw Error('no available_paying_addresses'); if (!ValidationUtils.isNonemptyArray(params.available_fee_paying_addresses)) throw Error('no available_fee_paying_addresses'); composer.readSortedFundedAddresses(params.asset, params.available_paying_addresses, params.amount, params.spend_unconfirmed || conf.spend_unconfirmed || 'own', function(arrFundedPayingAddresses){ if (arrFundedPayingAddresses.length === 0){ // special case for issuing uncapped asset. If it is not issuing, not-enough-funds will pop anyway if (params.available_paying_addresses.length === 1) arrFundedPayingAddresses = params.available_paying_addresses.concat(); else return params.callbacks.ifNotEnoughFunds("all paying addresses are unfunded in asset, make sure all your funds are confirmed"); } composer.readSortedFundedAddresses(null, params.available_fee_paying_addresses, TYPICAL_FEE, params.spend_unconfirmed || 'own', function(arrFundedFeePayingAddresses){ if (arrFundedFeePayingAddresses.length === 0) return params.callbacks.ifNotEnoughFunds("all paying addresses are unfunded in bytes necessary for fees, make sure all your funds are confirmed"); var minimal_params = _.clone(params); delete minimal_params.available_paying_addresses; delete minimal_params.available_fee_paying_addresses; minimal_params.minimal = true; minimal_params.paying_addresses = arrFundedPayingAddresses; minimal_params.fee_paying_addresses = arrFundedFeePayingAddresses; composeDivisibleAssetPaymentJoint(minimal_params); }); }); } // {asset: asset, available_paying_addresses: arrAvailablePayingAddresses, available_fee_paying_addresses: arrAvailableFeePayingAddresses, change_address: change_address, to_address: to_address, amount: amount, signer: signer, callbacks: callbacks} function composeAndSaveMinimalDivisibleAssetPaymentJoint(params){ var params_with_save = _.clone(params); params_with_save.callbacks = getSavingCallbacks(params.callbacks); composeMinimalDivisibleAssetPaymentJoint(params_with_save); } exports.validateAndSavePrivatePaymentChain = validateAndSavePrivatePaymentChain; exports.composeAndSaveDivisibleAssetPaymentJoint = composeAndSaveDivisibleAssetPaymentJoint; exports.composeAndSaveMinimalDivisibleAssetPaymentJoint = composeAndSaveMinimalDivisibleAssetPaymentJoint;