for depositing a cheque or cash.
2264 OTItem* pItem =
nullptr;
2265 OTItem* pItemCheque =
nullptr;
2266 OTItem* pItemCash =
nullptr;
2267 OTItem* pBalanceItem =
nullptr;
2268 OTItem* pResponseItem =
nullptr;
2269 OTItem* pResponseBalanceItem =
nullptr;
2274 OTString strInReferenceTo;
2275 OTString strBalanceItem;
2279 const OTIdentifier SERVER_ID(server_->m_strServerID), USER_ID(theNym),
2280 ACCOUNT_ID(theAccount), SERVER_USER_ID(server_->m_nymServer),
2281 ASSET_TYPE_ID(theAccount.GetAssetTypeID());
2283 const OTString strUserID(USER_ID), strAccountID(ACCOUNT_ID);
2285 Mint* pMint =
nullptr;
2286 OTAccount* pMintCashReserveAcct =
2294 if (
nullptr == pItemCheque) {
2300 pItem = pItemCheque;
2306 tranOut.AddItem(*pResponseItem);
2309 pResponseBalanceItem =
2312 tranOut.AddItem(*pResponseBalanceItem);
2315 if (
nullptr == pItem) {
2316 OTString strTemp(tranIn);
2317 OTLog::vOutput(0,
"Notary::NotarizeDeposit: Expected OTItem::deposit "
2318 "or OTItem::depositCheque in trans# %ld: \n\n%s\n\n",
2319 tranIn.GetTransactionNum(),
2322 :
" (ERROR LOADING TRANSACTION INTO STRING) ");
2332 OTLog::vOutput(0,
"Notary::NotarizeDeposit: User %s cannot do this "
2333 "transaction (All deposits are disallowed in "
2338 else if ((
nullptr != pItemCheque) &&
2342 OTLog::vOutput(0,
"Notary::NotarizeDeposit: User %s cannot do this "
2343 "transaction (depositCheque is disallowed in "
2348 else if ((
nullptr != pItemCash) &&
2352 OTLog::vOutput(0,
"Notary::NotarizeDeposit: User %s cannot do this "
2353 "transaction (deposit cash is disallowed in "
2361 OTString strTemp(tranIn);
2363 0,
"Notary::NotarizeDeposit: Expected OTItem::balanceStatement, "
2364 "but not found in trans # %ld: \n\n%s\n\n",
2365 tranIn.GetTransactionNum(),
2366 strTemp.Exists() ? strTemp.Get()
2367 :
" (ERROR LOADING TRANSACTION INTO STRING) ");
2377 pItem->SaveContractRaw(strInReferenceTo);
2378 pBalanceItem->SaveContractRaw(strBalanceItem);
2384 pResponseItem->SetReferenceString(strInReferenceTo);
2389 pResponseItem->SetReferenceToNum(
2390 pItem->GetTransactionNum());
2393 pResponseBalanceItem->SetReferenceString(
2396 pResponseBalanceItem->SetReferenceToNum(
2397 pItem->GetTransactionNum());
2399 std::unique_ptr<OTLedger> pInbox(
2400 theAccount.LoadInbox(server_->m_nymServer));
2401 std::unique_ptr<OTLedger> pOutbox(
2402 theAccount.LoadOutbox(server_->m_nymServer));
2408 OTLog::Error(
"Notary::NotarizeDeposit: Error loading or "
2409 "verifying inbox for depositor account.\n");
2415 OTLog::Error(
"Notary::NotarizeDeposit: Error loading or "
2416 "verifying outbox for depositor account.\n");
2423 else if (ACCOUNT_ID != pItem->GetPurportedAccountID()) {
2430 OTLog::Output(0,
"Notary::NotarizeDeposit: Error: account ID "
2431 "does not match account ID on the deposit "
2437 pItem->GetAttachment(strCheque);
2438 OTCheque theCheque(SERVER_ID,
2440 bool bLoadContractFromString =
2441 theCheque.LoadContractFromString(strCheque);
2443 if (!bLoadContractFromString) {
2444 OTLog::vError(
"%s: ERROR loading cheque from string:\n%s\n",
2445 __FUNCTION__, strCheque.Get());
2451 else if (SERVER_ID != theCheque.GetServerID()) {
2452 const OTString strSenderUserID(theCheque.GetSenderUserID());
2453 const OTString strRecipientUserID(
2454 theCheque.GetRecipientUserID());
2456 "Incorrect Server ID on cheque. Sender User "
2457 "ID: %s\nRecipient User ID is: %s\n",
2458 __FUNCTION__, theCheque.GetTransactionNum(),
2459 strSenderUserID.Get(), strRecipientUserID.Get());
2463 else if (!theCheque.VerifyCurrentDate()) {
2464 const OTString strSenderUserID(theCheque.GetSenderUserID());
2465 const OTString strRecipientUserID(
2466 theCheque.GetRecipientUserID());
2468 "Not within valid date range. Sender User "
2469 "ID: %s\nRecipient User ID: %s\n",
2470 __FUNCTION__, theCheque.GetTransactionNum(),
2471 strSenderUserID.Get(), strRecipientUserID.Get());
2490 else if (ACCOUNT_ID ==
2491 theCheque.GetSenderAcctID())
2500 const OTString strSenderUserID(theCheque.GetSenderUserID());
2501 const OTString strRecipientUserID(
2502 theCheque.GetRecipientUserID());
2503 if (theCheque.GetSenderUserID() != USER_ID) {
2506 "%s: Failure verifying cheque: Strange: while the "
2507 "depositing account has the "
2508 "same ID as the cheque sender acct, somehow the user "
2509 "IDs do not match. (Should never happen.)\n"
2510 "Cheque Sender User ID: %s\n Depositor User ID: %s\n",
2511 __FUNCTION__, strSenderUserID.Get(), strUserID.Get());
2513 else if (theCheque.GetAmount() != 0) {
2515 0,
"%s: Failure verifying cheque: While attempting to "
2516 "perform cancellation, "
2517 "the cheque has a non-zero amount.\n"
2518 "Sender User ID: %s\nRecipient User ID: %s\n",
2519 __FUNCTION__, strSenderUserID.Get(),
2520 strRecipientUserID.Get());
2527 theNym, theCheque.GetTransactionNum())) {
2529 0,
"%s: Failure verifying cheque: Bad transaction "
2531 "Sender User ID: %s\nRecipient User ID: %s\n",
2532 __FUNCTION__, strSenderUserID.Get(),
2533 strRecipientUserID.Get());
2537 else if (!theCheque.VerifySignature(theNym)) {
2539 "%s: Failure verifying cheque signature for "
2540 "sender ID: %s\nRecipient User ID: %s\n "
2541 "Cheque:\n\n%s\n\n",
2542 __FUNCTION__, strSenderUserID.Get(),
2543 strRecipientUserID.Get(), strCheque.Get());
2545 else if (!(pBalanceItem->VerifyBalanceStatement(
2546 theCheque.GetAmount(),
2549 theNym, *pInbox, *pOutbox, theAccount,
2552 "while cancelling cheque %ld. Acct "
2554 __FUNCTION__, theCheque.GetTransactionNum(),
2555 strAccountID.Get());
2558 pResponseBalanceItem->SetStatus(
2572 theNym, theCheque.GetTransactionNum(),
2576 "number as in use. (Should never "
2584 int64_t lNewTransactionNumber = 0;
2587 server_->m_nymServer, lNewTransactionNumber,
2590 OTTransaction* pInboxTransaction =
2593 lNewTransactionNumber);
2599 pInboxTransaction->SetReferenceString(strInReferenceTo);
2600 pInboxTransaction->SetReferenceToNum(
2601 pItem->GetTransactionNum());
2603 pInboxTransaction->SetAsCancelled();
2608 pInboxTransaction->SignContract(server_->m_nymServer);
2609 pInboxTransaction->SaveContract();
2613 pInbox->AddTransaction(*pInboxTransaction);
2620 pInbox->ReleaseSignatures();
2621 pInbox->SignContract(server_->m_nymServer);
2622 pInbox->SaveContract();
2624 theAccount.SaveInbox(*pInbox);
2637 pInboxTransaction->SaveBoxReceipt(*pInbox);
2645 theAccount.ReleaseSignatures();
2646 theAccount.SignContract(server_->m_nymServer);
2647 theAccount.SaveContract();
2648 theAccount.SaveAccount();
2671 0,
"%s: SUCCESS cancelling cheque %ld, which had "
2672 "been drawn from account: %s\n",
2673 __FUNCTION__, theCheque.GetTransactionNum(),
2674 strAccountID.Get());
2676 tranOut.SetAsCancelled();
2697 const OTIdentifier& SOURCE_ACCT_ID(
2698 theCheque.GetSenderAcctID());
2700 const OTIdentifier& SENDER_USER_ID(theCheque.GetSenderUserID());
2702 const OTIdentifier& REMITTER_ACCT_ID(
2703 theCheque.GetRemitterAcctID());
2705 const OTIdentifier& REMITTER_USER_ID(
2706 theCheque.GetRemitterUserID());
2712 const bool bHasRemitter = theCheque.HasRemitter();
2713 const bool bRemitterCancelling =
2715 (USER_ID == theCheque.GetRemitterUserID()));
2721 const OTIdentifier& RECIPIENT_USER_ID(
2722 bRemitterCancelling ? USER_ID
2723 : theCheque.GetRecipientUserID());
2728 const OTString strSenderUserID(SENDER_USER_ID),
2729 strSourceAcctID(SOURCE_ACCT_ID),
2730 strRecipientUserID(RECIPIENT_USER_ID),
2731 strRemitterUserID(REMITTER_USER_ID),
2732 strRemitterAcctID(REMITTER_ACCT_ID);
2733 OTLedger theSenderInbox(SENDER_USER_ID, SOURCE_ACCT_ID,
2735 OTLedger theRemitterInbox(
2736 REMITTER_USER_ID, REMITTER_ACCT_ID,
2738 OTLedger* pSenderInbox = &theSenderInbox;
2739 OTLedger* pRemitterInbox = &theRemitterInbox;
2740 OTAccount* pRemitterAcct =
2742 std::unique_ptr<OTAccount> theRemitterAcctGuardian;
2743 OTAccount* pSourceAcct =
2747 std::unique_ptr<OTAccount> theSourceAcctGuardian;
2749 OTPseudonym theRemitterNym(REMITTER_USER_ID);
2750 OTPseudonym* pRemitterNym = &theRemitterNym;
2751 OTPseudonym theSenderNym(SENDER_USER_ID);
2752 OTPseudonym* pSenderNym = &theSenderNym;
2818 bool bDepositorIsServer = (USER_ID == SERVER_USER_ID);
2819 bool bDepositorIsSender = (USER_ID == SENDER_USER_ID);
2820 bool bDepositorIsRemitter = (USER_ID == REMITTER_USER_ID);
2821 bool bDepositAcctIsRemitter = (ACCOUNT_ID == REMITTER_ACCT_ID);
2822 bool bSourceAcctIsRemitter =
2823 (SOURCE_ACCT_ID == REMITTER_ACCT_ID);
2824 bool bSenderIsServer = (SENDER_USER_ID == SERVER_USER_ID);
2825 bool bRemitterIsServer = (REMITTER_USER_ID == SERVER_USER_ID);
2826 bool bSenderUserAlreadyLoaded =
false;
2827 bool bSourceAcctAlreadyLoaded =
false;
2828 bool bRemitterUserAlreadyLoaded =
false;
2829 bool bRemitterAcctAlreadyLoaded =
false;
2837 if (bDepositorIsServer) {
2850 if (bDepositorIsSender) {
2851 pSenderNym = &theNym;
2852 bSenderUserAlreadyLoaded =
true;
2856 if (bSenderIsServer) {
2857 pSenderNym = &server_->m_nymServer;
2858 bSenderUserAlreadyLoaded =
true;
2860 bool bSuccessLoadSenderInbox =
false;
2861 bool bSuccessLoadRemitterInbox =
false;
2864 pSenderInbox =
nullptr;
2868 if (bDepositorIsRemitter) {
2869 pRemitterNym = &theNym;
2870 bRemitterUserAlreadyLoaded =
true;
2874 if (bRemitterIsServer) {
2875 pRemitterNym = &server_->m_nymServer;
2876 bRemitterUserAlreadyLoaded =
true;
2880 if (bDepositAcctIsRemitter) {
2881 pRemitterAcct = &theAccount;
2882 pRemitterInbox = pInbox.get();
2884 bRemitterAcctAlreadyLoaded =
true;
2885 bSuccessLoadRemitterInbox =
true;
2891 if (bSourceAcctIsRemitter) {
2892 pSourceAcct = pRemitterAcct;
2893 pSenderInbox = pRemitterInbox;
2895 bSourceAcctAlreadyLoaded =
true;
2896 bSuccessLoadSenderInbox =
true;
2906 bSuccessLoadSenderInbox = pSenderInbox->LoadInbox();
2909 if (bSuccessLoadSenderInbox)
2910 bSuccessLoadSenderInbox =
2911 pSenderInbox->VerifyAccount(server_->m_nymServer);
2914 "for %s source account.\n",
2916 (bHasRemitter) ?
"cheque" :
"voucher");
2949 if (bHasRemitter && !bSenderIsServer) {
2951 "'sender' who is not the server: %s\n",
2952 __FUNCTION__, strSenderUserID.Get());
2962 else if (!bSenderUserAlreadyLoaded &&
2964 theSenderNym.LoadPublicKey())
2977 0,
"Notary::%s: Error loading public key for %s "
2979 "deposit: %s\nRecipient User ID: %s\n",
2980 __FUNCTION__, (bHasRemitter) ?
"cheque" :
"voucher",
2981 strSenderUserID.Get(), strRecipientUserID.Get());
2986 else if (!pSenderNym->VerifyPseudonym()) {
2988 0,
"Notary::%s: Failure verifying %s: "
2989 "Bad Sender User ID (fails hash check of pubkey)"
2990 ": %s\nRecipient User ID: %s\n",
2991 __FUNCTION__, (bHasRemitter) ?
"cheque" :
"voucher",
2992 strSenderUserID.Get(), strRecipientUserID.Get());
3001 else if (!bSenderUserAlreadyLoaded &&
3003 theSenderNym.LoadSignedNymfile(
3004 server_->m_nymServer))) {
3006 0,
"Notary::%s: Error loading nymfile for %s signer "
3007 "during deposit, user ID: %s\n"
3008 "Recipient User ID: %s\n",
3009 __FUNCTION__, (bHasRemitter) ?
"cheque" :
"voucher",
3010 strSenderUserID.Get(), strRecipientUserID.Get());
3018 else if (bHasRemitter && !bRemitterUserAlreadyLoaded &&
3020 theRemitterNym.LoadPublicKey())
3034 0,
"Notary::%s: Error loading public key for "
3036 "voucher deposit: %s\nRecipient User ID: %s\n",
3037 __FUNCTION__, strRemitterUserID.Get(),
3038 strRecipientUserID.Get());
3043 else if (bHasRemitter && !pRemitterNym->VerifyPseudonym()) {
3045 0,
"Notary::%s: Failure verifying voucher: "
3046 "Bad Remitter User ID (fails hash check of pubkey)"
3047 ": %s\nRecipient User ID: %s\n",
3048 __FUNCTION__, strRemitterUserID.Get(),
3049 strRecipientUserID.Get());
3058 else if (bHasRemitter && !bRemitterUserAlreadyLoaded &&
3060 theRemitterNym.LoadSignedNymfile(
3061 server_->m_nymServer))) {
3063 "remitter during voucher deposit: %s\n"
3064 "Recipient User ID: %s\n",
3065 __FUNCTION__, strRemitterUserID.Get(),
3066 strRecipientUserID.Get());
3072 *(bHasRemitter ? pRemitterNym : pSenderNym),
3073 theCheque.GetTransactionNum())) {
3075 "transaction number.\n"
3076 "Recipient User ID: %s\n",
3078 (bHasRemitter) ?
"cheque" :
"voucher",
3079 strRecipientUserID.Get());
3084 theCheque.VerifySignature(*pSenderNym))
3089 0,
"Notary::%s: Failure verifying %s signature for "
3090 "sender ID: %s Recipient User ID: %s",
3091 __FUNCTION__, (bHasRemitter) ?
"cheque" :
"voucher",
3092 strSenderUserID.Get(), strRecipientUserID.Get());
3095 strRemitterUserID.Get());
3103 else if (theCheque.HasRecipient() &&
3104 !(USER_ID == RECIPIENT_USER_ID)) {
3106 "depositor. Depositor User ID: %s "
3107 "Recipient User ID: %s\n",
3109 (bHasRemitter) ?
"cheque" :
"voucher",
3110 strUserID.Get(), strRecipientUserID.Get());
3116 else if (!bSourceAcctAlreadyLoaded &&
3119 SOURCE_ACCT_ID, SERVER_ID))) ||
3120 (theSourceAcctGuardian.reset(pSourceAcct),
3127 0,
"%s: %s deposit failure, "
3128 "trying to load source acct, ID: %s Recipient User "
3130 __FUNCTION__, (bHasRemitter) ?
"Cheque" :
"Voucher",
3131 strSourceAcctID.Get(), strRecipientUserID.Get());
3134 strRemitterUserID.Get());
3146 else if (!bSuccessLoadSenderInbox &&
3147 !pSourceAcct->IsInternalServerAcct()) {
3148 OTLog::vError(
"%s: ERROR verifying inbox ledger for source "
3150 __FUNCTION__, strSourceAcctID.Get());
3163 else if (!pSourceAcct->VerifySignature(server_->m_nymServer)) {
3165 0,
"%s: ERROR verifying signature on source account "
3166 "while depositing %s. Acct ID: %s\n",
3167 __FUNCTION__, (bHasRemitter) ?
"cheque" :
"voucher",
3168 strAccountID.Get());
3172 else if (!pSourceAcct->VerifyOwner(*pSenderNym)) {
3174 "ownership of source account while "
3175 "depositing %s. Source Acct ID: %s\n",
3177 (bHasRemitter) ?
"cheque" :
"voucher",
3178 strAccountID.Get());
3181 if (bSourceAcctIsRemitter) {
3182 pRemitterAcct = pSourceAcct;
3183 bRemitterAcctAlreadyLoaded =
true;
3185 pRemitterInbox = pSenderInbox;
3187 if (
nullptr != pRemitterInbox)
3191 bSuccessLoadRemitterInbox =
3202 if (bHasRemitter && !bRemitterAcctAlreadyLoaded &&
3205 REMITTER_ACCT_ID, SERVER_ID))) ||
3206 (theRemitterAcctGuardian.reset(pRemitterAcct),
3213 0,
"%s: Voucher deposit, failure "
3214 "trying to load remitter acct, ID: %s Recipient "
3215 "User ID: %s Remitter User ID: %s\n",
3216 __FUNCTION__, strRemitterAcctID.Get(),
3217 strRecipientUserID.Get(), strRemitterUserID.Get());
3225 else if (bHasRemitter &&
3226 !pRemitterAcct->VerifySignature(
3227 server_->m_nymServer)) {
3229 "remitter account while depositing "
3231 "Remitter Acct ID: %s\n",
3232 __FUNCTION__, strRemitterAcctID.Get());
3236 else if (bHasRemitter &&
3237 !pRemitterAcct->VerifyOwner(*pRemitterNym)) {
3239 0,
"Notary::%s: ERROR verifying remitter's "
3240 "ownership of remitter account while "
3241 "depositing voucher. Remitter Acct ID: %s\n",
3242 __FUNCTION__, strRemitterAcctID.Get());
3244 else if (bHasRemitter &&
3247 !bSourceAcctIsRemitter &&
3252 !bSuccessLoadRemitterInbox &&
3258 (!pRemitterInbox->LoadInbox() ||
3259 !pRemitterInbox->VerifyAccount(
3260 server_->m_nymServer)))
3264 "ledger for remitter acct ID: %s\n",
3265 __FUNCTION__, strRemitterAcctID.Get());
3269 else if (!(theCheque.GetAssetID() ==
3270 pSourceAcct->GetAssetTypeID()) ||
3271 !(theCheque.GetAssetID() ==
3272 theAccount.GetAssetTypeID()) ||
3274 !(theCheque.GetAssetID() ==
3275 pRemitterAcct->GetAssetTypeID()))) {
3276 OTString strSourceAssetID(
3277 pSourceAcct->GetAssetTypeID()),
3278 strRecipientAssetID(theAccount.GetAssetTypeID());
3280 0,
"Notary::%s: ERROR - user attempted to "
3281 "deposit cheque between accounts of different "
3282 "asset types. Source Acct: %s\nType: "
3283 "%s\nRecipient Acct: %s\nType: %s\n",
3284 __FUNCTION__, strSourceAcctID.Get(),
3285 strSourceAssetID.Get(), strAccountID.Get(),
3286 strRecipientAssetID.Get());
3289 OTString strRemitterAssetID(
3290 pRemitterAcct->GetAssetTypeID());
3292 strRemitterAcctID.Get(),
3293 strRemitterAssetID.Get());
3332 else if (!(pBalanceItem->VerifyBalanceStatement(
3333 theCheque.GetAmount(), theNym, *pInbox,
3334 *pOutbox, theAccount, tranIn))) {
3336 "balance statement while depositing "
3337 "cheque. Acct ID:\n%s\n",
3338 __FUNCTION__, strAccountID.Get());
3348 pResponseBalanceItem->SetStatus(
3356 pSourceAcct->Debit(theCheque.GetAmount())) {
3358 "source account.\n",
3362 theAccount.Credit(theCheque.GetAmount())) {
3364 "destination account.\n",
3368 pSourceAcct->Credit(theCheque.GetAmount()))
3370 "back source account.\n",
3389 *(bHasRemitter ? pRemitterNym : pSenderNym),
3390 theCheque.GetTransactionNum(),
3394 "transaction number from sender or "
3395 "remitter, even though "
3396 "it verified just earlier...\n",
3399 pSourceAcct->Credit(theCheque.GetAmount()))
3401 "crediting-back source "
3406 theAccount.Debit(theCheque.GetAmount()))
3408 "debiting-back destination "
3418 OTAccount* pAcctWhereReceiptGoes =
nullptr;
3419 OTLedger* pInboxWhereReceiptGoes =
nullptr;
3422 pAcctWhereReceiptGoes = pRemitterAcct;
3423 pInboxWhereReceiptGoes = pRemitterInbox;
3427 pAcctWhereReceiptGoes = pSourceAcct;
3428 pInboxWhereReceiptGoes = pSenderInbox;
3441 if (pAcctWhereReceiptGoes
3442 ->IsInternalServerAcct())
3457 if (!bHasRemitter || !bRemitterIsServer)
3459 "%s: Error: Apparently this is a "
3460 "voucher remitted directly by the "
3461 "server (such as a dividend payment) "
3462 "but one of these values is false: "
3464 "bRemitterIsServer()\n",
3466 bHasRemitter ?
"true" :
"false",
3467 bRemitterIsServer ?
"true" :
"false");
3502 if (!server_->transactor_
3505 theCheque.GetTransactionNum(),
3508 "%s: Strange: Failed removing "
3509 "issued number from remitter (the "
3510 "server nym, in this case), "
3511 "even though the number verified "
3512 "just earlier...\n",
3524 int64_t lNewTransactionNumber = 0;
3527 server_->m_nymServer, lNewTransactionNumber,
3530 OTTransaction* pInboxTransaction =
3532 *pInboxWhereReceiptGoes,
3533 theCheque.HasRemitter()
3536 lNewTransactionNumber);
3545 pInboxTransaction->SetReferenceToNum(
3546 pItem->GetTransactionNum());
3547 pInboxTransaction->SetNumberOfOrigin(
3548 theCheque.GetTransactionNum());
3550 if (bRemitterCancelling)
3551 pInboxTransaction->SetAsCancelled();
3557 pInboxTransaction->SignContract(
3558 server_->m_nymServer);
3559 pInboxTransaction->SaveContract();
3564 pInboxWhereReceiptGoes->AddTransaction(
3565 *pInboxTransaction);
3572 pInboxWhereReceiptGoes->ReleaseSignatures();
3573 pInboxWhereReceiptGoes->SignContract(
3574 server_->m_nymServer);
3575 pInboxWhereReceiptGoes->SaveContract();
3577 pAcctWhereReceiptGoes->SaveInbox(
3578 *pInboxWhereReceiptGoes);
3597 pAcctWhereReceiptGoes->ReleaseSignatures();
3598 pAcctWhereReceiptGoes->SignContract(
3599 server_->m_nymServer);
3600 pAcctWhereReceiptGoes->SaveContract();
3601 pAcctWhereReceiptGoes->SaveAccount();
3615 pInboxTransaction->SaveBoxReceipt(
3616 *pInboxWhereReceiptGoes);
3627 pSourceAcct->ReleaseSignatures();
3628 theAccount.ReleaseSignatures();
3630 pSourceAcct->SignContract(server_->m_nymServer);
3631 theAccount.SignContract(server_->m_nymServer);
3633 pSourceAcct->SaveContract();
3634 theAccount.SaveContract();
3636 pSourceAcct->SaveAccount();
3637 theAccount.SaveAccount();
3663 if (bRemitterCancelling) {
3664 tranOut.SetAsCancelled();
3666 "crediting remitter account "
3673 "crediting account from "
3674 "cheque deposit.\n",
3713 pItem->SaveContractRaw(strInReferenceTo);
3714 pBalanceItem->SaveContractRaw(strBalanceItem);
3720 pResponseItem->SetReferenceString(strInReferenceTo);
3725 pResponseItem->SetReferenceToNum(
3726 pItem->GetTransactionNum());
3729 pResponseBalanceItem->SetReferenceString(
3732 pResponseBalanceItem->SetReferenceToNum(
3733 pItem->GetTransactionNum());
3738 if (ACCOUNT_ID != pItem->GetPurportedAccountID()) {
3740 "account ID on the transaction does not match "
3741 "'from' account ID on the deposit item.\n");
3744 std::unique_ptr<OTLedger> pInbox(
3745 theAccount.LoadInbox(server_->m_nymServer));
3746 std::unique_ptr<OTLedger> pOutbox(
3747 theAccount.LoadOutbox(server_->m_nymServer));
3749 if (
nullptr == pInbox) {
3750 OTLog::Error(
"Notary::NotarizeDeposit: Error loading or "
3751 "verifying inbox.\n");
3754 else if (
nullptr == pOutbox) {
3755 OTLog::Error(
"Notary::NotarizeDeposit: Error loading or "
3756 "verifying outbox.\n");
3760 pItem->GetAttachment(strPurse);
3762 Purse thePurse(SERVER_ID, ASSET_TYPE_ID);
3764 bool bLoadContractFromString =
3765 thePurse.LoadContractFromString(strPurse);
3767 if (!bLoadContractFromString) {
3768 OTLog::vError(
"Notary::NotarizeDeposit: ERROR loading purse "
3769 "from string:\n%s\n",
3772 else if (!(pBalanceItem->VerifyBalanceStatement(
3773 thePurse.GetTotalValue(), theNym, *pInbox, *pOutbox,
3774 theAccount, tranIn))) {
3776 "balance statement while depositing cash. "
3778 strAccountID.Get());
3785 pResponseBalanceItem->SetStatus(
3789 bool bSuccess =
false;
3794 std::unique_ptr<Token> pToken(
3795 thePurse.Pop(server_->m_nymServer));
3800 pMint = server_->transactor_.
getMint(ASSET_TYPE_ID,
3801 pToken->GetSeries());
3803 if (
nullptr == pMint) {
3808 else if ((pMintCashReserveAcct =
3809 pMint->GetCashReserveAccount()) !=
3811 OTString strSpendableToken;
3812 bool bToken = pToken->GetSpendableString(
3813 server_->m_nymServer, strSpendableToken);
3820 "ERROR verifying token: Failure "
3821 "retrieving token data. \n");
3824 else if (!(pToken->GetAssetID() ==
3830 "ERROR verifying token: Wrong "
3834 else if (!(pToken->GetServerID() ==
3840 "ERROR verifying token: Wrong "
3855 else if (!(pMint->VerifyToken(
3856 server_->m_nymServer, strSpendableToken,
3857 pToken->GetDenomination()))) {
3860 "ERROR verifying token: Token "
3861 "verification failed. \n");
3867 else if (pToken->IsTokenAlreadySpent(
3868 strSpendableToken)) {
3881 "ERROR verifying token: Token "
3882 "was already spent. \n");
3887 "SUCCESS verifying token... "
3900 pMintCashReserveAcct->Debit(
3901 pToken->GetDenomination())) {
3903 "debiting the mint cash reserve "
3905 "SHOULD NEVER HAPPEN...\n");
3912 pToken->GetDenomination())) {
3914 "crediting the user's asset "
3918 pMintCashReserveAcct->Credit(
3919 pToken->GetDenomination()))
3921 "Failure crediting-back "
3922 "mint's cash reserve account "
3923 "while depositing cash.\n");
3931 pToken->RecordTokenAsSpent(
3932 strSpendableToken)) {
3934 "Failed recording token as "
3938 pMintCashReserveAcct->Credit(
3939 pToken->GetDenomination()))
3941 "Failure crediting-back "
3942 "mint's cash reserve account "
3943 "while depositing cash.\n");
3946 theAccount.Debit(pToken->GetDenomination()))
3948 "Failure debiting-back user's "
3949 "asset account while "
3950 "depositing cash.\n");
3958 "SUCCESS crediting account "
3959 "with cash token...\n");
3969 "cash reserve account for Mint.\n");
3978 theAccount.ReleaseSignatures();
3981 theAccount.SignContract(server_->m_nymServer);
3984 theAccount.SaveContract();
3987 theAccount.SaveAccount();
3997 pMintCashReserveAcct->ReleaseSignatures();
3998 pMintCashReserveAcct->SignContract(server_->m_nymServer);
3999 pMintCashReserveAcct->SaveContract();
4000 pMintCashReserveAcct->SaveAccount();
4007 "-- crediting account from cash "
4023 OTString strTemp(tranIn);
4025 "OTItem::depositCheque on trans# %ld: \n\n%s\n\n",
4026 __FUNCTION__, tranIn.GetTransactionNum(),
4029 :
" (ERROR CREATING STRING FROM TRANSACTION.) ");
4037 pResponseItem->SignContract(server_->m_nymServer);
4038 pResponseItem->SaveContract();
4041 pResponseBalanceItem->SignContract(server_->m_nymServer);
4042 pResponseBalanceItem->SaveContract();
static EXPORT void vError(const char *szError,...)
static EXPORT OTTransaction * GenerateTransaction(const OTIdentifier &theUserID, const OTIdentifier &theAccountID, const OTIdentifier &theServerID, transactionType theType, int64_t lTransactionNum=0)
static EXPORT void Output(int32_t nVerbosity, const char *szOutput)
bool issueNextTransactionNumber(OTPseudonym &nym, int64_t &txNumber, bool storeNumber=true)
#define NYM_IS_ALLOWED(SZ_NYM_ID, BOOL_VAR_NAME)
bool verifyTransactionNumber(OTPseudonym &nym, const int64_t &transactionNumber)
bool removeTransactionNumber(OTPseudonym &nym, const int64_t &transactionNumber, bool save=false)
static EXPORT OTItem * CreateItemFromTransaction(const OTTransaction &theOwner, OTItem::itemType theType, const OTIdentifier *pDestinationAcctID=nullptr)
static EXPORT void Error(const char *szError)
Mint * getMint(const OTIdentifier &assetTypeId, int32_t seriesCount)
Lookup the current mint for any given asset type ID and series.
EXPORT void SetReferenceString(const OTString &theStr)
bool removeIssuedNumber(OTPseudonym &nym, const int64_t &transactionNumber, bool save=false)
static bool __transact_deposit
static bool __transact_deposit_cash
static bool __transact_deposit_cheque
static EXPORT void vOutput(int32_t nVerbosity, const char *szOutput,...)
static EXPORT OTAccount * LoadExistingAccount(const OTIdentifier &accountId, const OTIdentifier &serverId)