183 0,
"UserCommandProcessor::ProcessUserCommand: Nym %s: failed "
184 "attempt to message the server, while server is in "
185 "**LOCK DOWN MODE**.\n",
193 OTLog::Error(
"UserCommandProcessor::ProcessUserCommand: Invalid server "
195 "command request.\n");
199 OTLog::Output(4,
"Received valid Server ID with command request.\n");
212 "UserCommandProcessor::ProcessUserCommand: NymID on the optional "
215 "does NOT match the NymID on theMessage (%s). (Returning false.)\n",
228 const bool bNymIsServerNym =
234 if (bNymIsServerNym) pNym = &server_->m_nymServer;
337 "\n==> Received a checkServerID message. Nym: %s ...\n",
340 std::unique_ptr<OTAsymmetricKey> pNymAuthentKey(
342 std::unique_ptr<OTAsymmetricKey> pNymEncryptKey(
348 const bool bIfNymPublicKey =
354 if (bIfNymPublicKey) {
361 3,
"Signature verified! The message WAS signed by "
362 "the Private Authentication Key inside the message.\n");
369 if (
nullptr != pConnection)
376 UserCmdCheckServerID(*pNym, theMessage, msgOut);
381 0,
"checkServerID: Signature verification failed!\n");
386 OTLog::Error(
"Failure reading Nym's signing and/or encryption keys "
414 0,
"\n==> Received a createUserAccount message. Nym: %s ...\n",
417 if (bNymIsServerNym) {
419 "**** Sorry, the server Nym is forbidden from using "
420 "the createUserAccount message as a client. "
421 "PLEASE REMOVE THAT NYM FROM YOUR WALLET!! Create a "
422 "fresh Nym to use. ***\n");
431 const bool bHasCredentials = (ascArmor.
Exists() && ascArmor2.
Exists());
437 OTString strCredentialList(ascArmor);
439 if (strCredentialList.
Exists()) {
446 "StringMap object.\n",
475 "%s: @createUserAccount: Failure loading nym %s "
476 "from credential string.\n",
490 "%s: @createUserAccount: Loaded nym %s "
491 "from credentials, but then it failed verifying.\n",
512 "Authentication signature -- "
513 "verification failed!\n");
519 "Signature verified! The message WAS signed by "
520 "the Nym\'s private authentication key.\n");
524 std::string str_nym_id =
527 strFilename.
Format(
"%s.cred", str_nym_id.c_str());
529 bool bStoredList =
false;
535 "CREDENTIAL LIST") &&
543 "trying to armor or store: %s\n",
544 __FUNCTION__, strFilename.
Get());
549 "saving public credential "
550 "list for Nym: %s\n",
552 for (
auto& it : theMap) {
553 std::string str_cred_id = it.first;
555 bool bStoredCredential =
false;
558 if (ascLoopArmor.
Exists() &&
568 str_nym_id, str_cred_id);
569 if (!bStoredCredential)
571 "%s: @createUserAccount: Failed "
572 "trying to store credential %s for "
574 __FUNCTION__, str_cred_id.c_str(),
581 str_cred_id.c_str());
587 OTString strPublicEncrKey, strPublicSignKey;
606 if (strPublicSignKey.
Exists())
616 if (strPublicEncrKey.
Exists() &&
617 (
nullptr != pConnection))
633 0,
"Verifying account doesn't already exist... "
634 "(IGNORE ANY ERRORS, IMMEDIATELY BELOW, "
635 "ABOUT FAILURE OPENING FILES)\n");
640 "@createUserAccount";
644 server_->m_strServerID;
660 bool bLoadedSignedNymfile =
668 if (bLoadedSignedNymfile &&
672 "(Allowed in order to prevent sync issues) "
673 "==> User is registering nym that already "
680 SERVER_ID(server_->m_strServerID);
682 OTLedger theNymbox(theNewNymID, theNewNymID,
684 bool bSuccessLoadingNymbox =
687 if (
true == bSuccessLoadingNymbox)
688 bSuccessLoadingNymbox =
691 server_->m_nymServer));
698 bSuccessLoadingNymbox =
700 theNewNymID, SERVER_ID,
704 if (bSuccessLoadingNymbox) {
705 bSuccessLoadingNymbox =
707 server_->m_nymServer);
709 if (bSuccessLoadingNymbox) {
710 bSuccessLoadingNymbox =
713 if (bSuccessLoadingNymbox)
714 bSuccessLoadingNymbox =
723 if (!bSuccessLoadingNymbox) {
725 "re-registration. Failed "
726 "verifying or generating "
727 "nymbox for user: %s\n",
763 "account verification "
767 SERVER_ID(server_->m_strServerID);
769 OTLedger theNymbox(theNewNymID, theNewNymID,
771 bool bSuccessLoadingNymbox =
774 if (
true == bSuccessLoadingNymbox)
788 bSuccessLoadingNymbox =
791 server_->m_nymServer));
798 bSuccessLoadingNymbox =
800 theNewNymID, SERVER_ID,
803 if (bSuccessLoadingNymbox) {
804 bSuccessLoadingNymbox =
806 server_->m_nymServer);
807 if (bSuccessLoadingNymbox) {
808 bSuccessLoadingNymbox =
811 if (bSuccessLoadingNymbox)
812 bSuccessLoadingNymbox =
821 if (!bSuccessLoadingNymbox) {
823 "Error during user account "
824 "registration. Failed verifying or "
825 "generating nymbox for user: %s\n",
833 else if (bLoadedSignedNymfile ||
835 server_->m_nymServer)) {
847 server_->m_nymServer);
853 server_->m_nymServer);
860 "account verification "
884 if (!bNymIsServerNym &&
889 OTLog::vError(
"Failure loading public credentials for Nym: %s\n",
895 "(Failed) attempt by client to use a deleted Nym: %s\n",
910 OTLog::Output(3,
"Signature verified! The message WAS signed by "
911 "the Nym\'s private key.\n");
919 if (
nullptr != pConnection)
925 if (bNymIsServerNym ||
927 OTLog::Output(2,
"Successfully loaded Nymfile into memory.\n");
945 int64_t lRequestNumber = 0;
951 "Apparently first-ever request to "
952 "server--but everything checks out. "
953 "(Shouldn't this request number have been "
954 "created already when the NymFile was "
955 "first created???????\n");
963 server_->m_strServerID);
969 "file, apparently first-ever request. "
970 "(Shouldn't this have been created "
971 "already when the NymFile was first "
992 if (lRequestNumber !=
1003 "%ld does not match the one in the "
1031 const int64_t& lUsageCredits =
1034 if (0 == lUsageCredits)
1040 "Credits, while server is in "
1041 "**REQUIRE USAGE CREDITS "
1047 const int64_t lUsageFinal = (lUsageCredits - 1);
1052 "%ld DOES match the one in the "
1062 server_->m_strServerID);
1121 0,
"Pseudonym failed to verify. Hash of public key doesn't match "
1122 "Nym ID that was sent.\n");
1181 bool bIsDirtyNym =
false;
1184 std::set<int64_t> numlist_ack_reply;
1192 if (theNymbox.LoadNymbox() &&
1193 theNymbox.VerifySignature(server_->m_nymServer)) {
1196 bool bIsDirtyNymbox =
false;
1198 for (
auto& it : numlist_ack_reply) {
1199 const int64_t lRequestNum = it;
1217 theNymbox.GetReplyNotice(lRequestNum);
1219 if (
nullptr != pReplyNotice) {
1222 const bool bDeleted =
1224 const bool bRemoved = theNymbox.RemoveTransaction(
1226 pReplyNotice =
nullptr;
1230 if (!bDeleted || !bRemoved)
1232 "UserCommandProcessor::ProcessUserCommand: "
1234 "to delete a box receipt, or "
1235 "while removing its stub from the Nymbox.\n");
1241 server_->m_strServerID,
1248 bIsDirtyNymbox =
true;
1257 if (bIsDirtyNymbox) {
1258 theNymbox.ReleaseSignatures();
1259 theNymbox.SignContract(server_->m_nymServer);
1260 theNymbox.SaveContract();
1261 theNymbox.SaveNymbox();
1279 const int32_t nAcknowledgedNumCount =
1282 if (nAcknowledgedNumCount > 0) {
1283 for (int32_t i = 0; i < nAcknowledgedNumCount; i++) {
1284 const int64_t lAcknowledgedNum =
1295 numlist_to_remove.Add(lAcknowledgedNum);
1298 if (numlist_to_remove.
Count() > 0) {
1299 std::set<int64_t> set_server_ack;
1300 if (numlist_to_remove.
Output(set_server_ack)) {
1301 for (
auto& it : set_server_ack) {
1302 const int64_t lRequestNum = it;
1304 server_->m_nymServer, server_->m_strServerID,
1305 lRequestNum,
false))
1356 OTLog::vOutput(0,
"\n==> Received a getRequest message. Nym: %s ...\n",
1361 UserCmdGetRequest(*pNym, theMessage, msgOut);
1367 0,
"\n==> Received a getTransactionNum message. Nym: %s ...\n",
1372 UserCmdGetTransactionNum(*pNym, theMessage, msgOut);
1377 OTLog::vOutput(0,
"\n==> Received a checkUser message. Nym: %s ...\n",
1382 UserCmdCheckUser(*pNym, theMessage, msgOut);
1388 0,
"\n==> Received a sendUserMessage message. Nym: %s ...\n",
1393 UserCmdSendUserMessage(*pNym, theMessage, msgOut);
1399 0,
"\n==> Received a sendUserInstrument message. Nym: %s ...\n",
1404 UserCmdSendUserInstrument(*pNym, theMessage, msgOut);
1410 0,
"\n==> Received a deleteUserAccount message. Nym: %s ...\n",
1415 UserCmdDeleteUser(*pNym, theMessage, msgOut);
1421 0,
"\n==> Received a deleteAssetAccount message. Nym: %s ...\n",
1426 UserCmdDeleteAssetAcct(*pNym, theMessage, msgOut);
1432 "\n==> Received a createAccount message. Nym: %s ...\n",
1437 UserCmdCreateAccount(*pNym, theMessage, msgOut);
1443 0,
"\n==> Received an issueAssetType message. Nym: %s ...\n",
1448 UserCmdIssueAssetType(*pNym, theMessage, msgOut);
1454 "\n==> Received an issueBasket message. Nym: %s ...\n",
1459 UserCmdIssueBasket(*pNym, theMessage, msgOut);
1464 OTLog::vOutput(0,
"\n==> Received a notarizeTransactions message. "
1465 "Acct: %s Nym: %s ...\n",
1470 UserCmdNotarizeTransactions(*pNym, theMessage, msgOut);
1475 OTLog::vOutput(0,
"\n==> Received a getNymbox message. Nym: %s ...\n",
1480 UserCmdGetNymbox(*pNym, theMessage, msgOut);
1486 "\n==> Received a getBoxReceipt message. Nym: %s ...\n",
1499 if (bRunIt) UserCmdGetBoxReceipt(*pNym, theMessage, msgOut);
1505 0,
"\n==> Received a getInbox message. Acct: %s Nym: %s ...\n",
1510 UserCmdGetInbox(*pNym, theMessage, msgOut);
1516 0,
"\n==> Received a getOutbox message. Acct: %s Nym: %s ...\n",
1521 UserCmdGetOutbox(*pNym, theMessage, msgOut);
1527 0,
"\n==> Received a getAccount message. Acct: %s Nym: %s ...\n",
1532 UserCmdGetAccount(*pNym, theMessage, msgOut);
1537 OTLog::vOutput(0,
"\n==> Received a getAccountFiles message. Acct: %s "
1545 UserCmdGetAccountFiles(*pNym, theMessage, msgOut);
1551 "\n==> Received a processNymbox message. Nym: %s ...\n",
1556 UserCmdProcessNymbox(*pNym, theMessage, msgOut);
1562 0,
"\n==> Received a processInbox message. Acct: %s Nym: %s ...\n",
1567 UserCmdProcessInbox(*pNym, theMessage, msgOut);
1573 0,
"\n==> Received a queryAssetTypes message. Nym: %s ...\n",
1578 UserCmdQueryAssetTypes(*pNym, theMessage, msgOut);
1583 OTLog::vOutput(0,
"\n==> Received a getContract message. Nym: %s ...\n",
1588 UserCmdGetContract(*pNym, theMessage, msgOut);
1593 OTLog::vOutput(0,
"\n==> Received a getMint message. Nym: %s ...\n",
1598 UserCmdGetMint(*pNym, theMessage, msgOut);
1604 "\n==> Received a getMarketList message. Nym: %s ...\n",
1609 UserCmdGetMarketList(*pNym, theMessage, msgOut);
1615 0,
"\n==> Received a getMarketOffers message. Nym: %s ...\n",
1620 UserCmdGetMarketOffers(*pNym, theMessage, msgOut);
1626 0,
"\n==> Received a getMarketRecentTrades message. Nym: %s ...\n",
1632 UserCmdGetMarketRecentTrades(*pNym, theMessage, msgOut);
1638 0,
"\n==> Received a getNym_MarketOffers message. Nym: %s ...\n",
1643 UserCmdGetNym_MarketOffers(*pNym, theMessage, msgOut);
1649 "\n==> Received a triggerClause message. Nym: %s ...\n",
1654 UserCmdTriggerClause(*pNym, theMessage, msgOut);
1660 "\n==> Received a usageCredits message. Nym: %s ...\n",
1665 UserCmdUsageCredits(*pNym, theMessage, msgOut);
1670 OTLog::vError(
"Unknown command type in the XML, or missing payload, in "
1671 "ProcessMessage.\n");
1706 int32_t nMarketCount = 0;
1711 if ((
true == msgOut.
m_bSuccess) && (nMarketCount > 0)) {
1715 strCount.
Format(
"%d", nMarketCount);
1721 OTString tempInMessage(MsgIn);
1739 void UserCommandProcessor::UserCmdGetMarketOffers(OTPseudonym&,
1744 msgOut.m_strCommand =
"@getMarketOffers";
1745 msgOut.m_strNymID = MsgIn.m_strNymID;
1746 msgOut.m_strNymID2 = MsgIn.m_strNymID2;
1750 int64_t lDepth = MsgIn.m_lDepth;
1751 if (lDepth < 0) lDepth = 0;
1753 const OTIdentifier MARKET_ID(MsgIn.m_strNymID2);
1755 OTMarket* pMarket = server_->m_Cron.
GetMarket(MARKET_ID);
1758 if ((msgOut.m_bSuccess =
1759 ((pMarket !=
nullptr) ?
true :
false)))
1761 OTASCIIArmor ascOutput;
1762 int32_t nOfferCount = 0;
1765 pMarket->GetOfferList(ascOutput, lDepth, nOfferCount);
1767 if ((
true == msgOut.m_bSuccess) && (nOfferCount > 0)) {
1768 msgOut.m_ascPayload = ascOutput;
1769 msgOut.m_lDepth = nOfferCount;
1775 if (!msgOut.m_bSuccess) {
1776 OTString tempInMessage(MsgIn);
1777 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
1781 msgOut.SignContract(server_->m_nymServer);
1790 msgOut.SaveContract();
1794 void UserCommandProcessor::UserCmdGetMarketRecentTrades(OTPseudonym&,
1799 msgOut.m_strCommand =
1800 "@getMarketRecentTrades";
1801 msgOut.m_strNymID = MsgIn.m_strNymID;
1802 msgOut.m_strNymID2 = MsgIn.m_strNymID2;
1806 const OTIdentifier MARKET_ID(MsgIn.m_strNymID2);
1808 OTMarket* pMarket = server_->m_Cron.
GetMarket(MARKET_ID);
1811 if ((msgOut.m_bSuccess =
1812 ((pMarket !=
nullptr) ?
true :
false)))
1814 OTASCIIArmor ascOutput;
1815 int32_t nTradeCount = 0;
1819 if (
true == msgOut.m_bSuccess) {
1820 msgOut.m_lDepth = nTradeCount;
1822 if (nTradeCount > 0) msgOut.m_ascPayload = ascOutput;
1828 if (!msgOut.m_bSuccess) {
1829 OTString tempInMessage(MsgIn);
1830 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
1834 msgOut.SignContract(server_->m_nymServer);
1843 msgOut.SaveContract();
1848 void UserCommandProcessor::UserCmdGetNym_MarketOffers(OTPseudonym& theNym,
1853 msgOut.m_strCommand =
"@getNym_MarketOffers";
1854 msgOut.m_strNymID = MsgIn.m_strNymID;
1858 OTIdentifier NYM_ID;
1859 theNym.GetIdentifier(NYM_ID);
1861 OTASCIIArmor ascOutput;
1862 int32_t nOfferCount = 0;
1867 if ((
true == msgOut.m_bSuccess) && (nOfferCount > 0)) {
1868 msgOut.m_ascPayload = ascOutput;
1869 msgOut.m_lDepth = nOfferCount;
1873 if (!msgOut.m_bSuccess) {
1874 OTString tempInMessage(MsgIn);
1875 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
1879 msgOut.SignContract(server_->m_nymServer);
1888 msgOut.SaveContract();
1891 void UserCommandProcessor::UserCmdCheckServerID(OTPseudonym&, OTMessage& MsgIn,
1895 msgOut.m_strCommand =
"@checkServerID";
1896 msgOut.m_strNymID = MsgIn.m_strNymID;
1903 if (MsgIn.m_strServerID ==
1904 server_->m_strServerID)
1905 msgOut.m_bSuccess =
true;
1907 msgOut.m_bSuccess =
false;
1910 msgOut.SignContract(server_->m_nymServer);
1919 msgOut.SaveContract();
1922 void UserCommandProcessor::UserCmdGetTransactionNum(OTPseudonym& theNym,
1927 msgOut.m_strCommand =
"@getTransactionNum";
1928 msgOut.m_strNymID = MsgIn.m_strNymID;
1935 const OTIdentifier SERVER_ID(server_->m_strServerID);
1943 int32_t nCount = theNym.GetTransactionNumCount(SERVER_ID);
1944 const OTIdentifier theMsgNymboxHash(
1945 MsgIn.m_strNymboxHash);
1947 OTIdentifier EXISTING_NYMBOX_HASH;
1949 const bool bGotNymboxHashServerSide =
1950 theNym.GetNymboxHashServerSide(SERVER_ID, EXISTING_NYMBOX_HASH);
1951 const bool bGotNymboxHashClientSide = MsgIn.m_strNymboxHash.Exists();
1953 if (bGotNymboxHashServerSide)
1955 EXISTING_NYMBOX_HASH.GetString(msgOut.m_strNymboxHash);
1956 if ((bGotNymboxHashServerSide && bGotNymboxHashClientSide &&
1957 (theMsgNymboxHash != EXISTING_NYMBOX_HASH)) ||
1958 (bGotNymboxHashServerSide && !bGotNymboxHashClientSide)) {
1960 0,
"UserCommandProcessor::UserCmdGetTransactionNum: Rejecting "
1961 "message since nymbox hash "
1962 "doesn't match. (Send a getNymbox message to grab the "
1966 else if (nCount > 50)
1971 "UserCommandProcessor::UserCmdGetTransactionNum: Failure: Nym %s "
1973 "more than 50 unused transaction numbers signed out. (He needs to "
1975 "Tell him to download his latest Nymbox.)\n",
1976 MsgIn.m_strNymID.Get());
1979 OTIdentifier USER_ID, NYMBOX_HASH;
1980 theNym.GetIdentifier(USER_ID);
1982 bool bSuccess =
true;
1983 bool bSavedNymbox =
false;
1984 OTLedger theLedger(USER_ID, USER_ID, SERVER_ID);
1990 OTNumList theNumlist;
1992 int64_t lFirstTransNum =
2000 for (int32_t i = 0; i < 100; i++)
2004 int64_t lTransNum = 0;
2012 theNym, lTransNum,
false))
2015 OTLog::Error(
"UserCommandProcessor::UserCmdGetTransactionNu: "
2017 "next transaction number!\n");
2022 theNumlist.Add(lTransNum);
2024 lFirstTransNum = lTransNum;
2031 else if (!theLedger.LoadNymbox()) {
2033 "UserCommandProcessor::UserCmdGetTransactionNum\n");
2036 else if ((msgOut.m_bSuccess = (
2039 theLedger.VerifyContractID() &&
2041 theLedger.VerifySignature(
2042 server_->m_nymServer)
2070 pTransaction->AddNumbersToTransaction(theNumlist);
2072 pTransaction->SignContract(server_->m_nymServer);
2073 pTransaction->SaveContract();
2075 theLedger.AddTransaction(*pTransaction);
2077 theLedger.ReleaseSignatures();
2078 theLedger.SignContract(server_->m_nymServer);
2079 theLedger.SaveContract();
2081 bSavedNymbox =
true;
2082 theLedger.SaveNymbox(&NYMBOX_HASH);
2093 pTransaction->SaveBoxReceipt(theLedger);
2096 theLedger.CalculateNymboxHash(NYMBOX_HASH);
2100 "UserCommandProcessor::UserCmdGetTransactionNum\n");
2102 std::set<int64_t> theList;
2103 theNumlist.Output(theList);
2105 for (
auto& it : theList) {
2106 const int64_t lTransNum = it;
2110 theNym, lTransNum,
false);
2119 theNym.SetNymboxHashServerSide(NYMBOX_HASH);
2120 theNym.SaveSignedNymfile(server_->m_nymServer);
2122 NYMBOX_HASH.GetString(msgOut.m_strNymboxHash);
2124 else if (
true == msgOut.m_bSuccess) {
2125 theLedger.CalculateNymboxHash(NYMBOX_HASH);
2127 theNym.SetNymboxHashServerSide(
2129 theNym.SaveSignedNymfile(server_->m_nymServer);
2131 NYMBOX_HASH.GetString(
2132 msgOut.m_strNymboxHash);
2138 msgOut.SignContract(server_->m_nymServer);
2147 msgOut.SaveContract();
2150 void UserCommandProcessor::UserCmdGetRequest(OTPseudonym& theNym,
2155 msgOut.m_strCommand =
"@getRequest";
2156 msgOut.m_strNymID = MsgIn.m_strNymID;
2160 msgOut.m_strRequestNum.Set(MsgIn.m_strRequestNum);
2164 int64_t lReqNum = 1;
2168 theNym.GetCurrentRequestNum(server_->m_strServerID, lReqNum);
2173 if (!msgOut.m_bSuccess) {
2175 "UserCommandProcessor::UserCmdGetRequest\n");
2178 msgOut.m_lNewRequestNum = lReqNum;
2182 const OTIdentifier SERVER_ID(server_->m_strServerID);
2183 OTIdentifier EXISTING_NYMBOX_HASH;
2184 if (theNym.GetNymboxHashServerSide(SERVER_ID, EXISTING_NYMBOX_HASH))
2185 EXISTING_NYMBOX_HASH.GetString(msgOut.m_strNymboxHash);
2187 const OTIdentifier theNymID(theNym);
2188 OTLedger theLedger(theNymID, theNymID, SERVER_ID);
2190 if (theLedger.LoadNymbox() && theLedger.VerifyContractID() &&
2191 theLedger.VerifySignature(server_->m_nymServer)) {
2192 theLedger.CalculateNymboxHash(EXISTING_NYMBOX_HASH);
2194 theNym.SetNymboxHashServerSide(EXISTING_NYMBOX_HASH);
2195 theNym.SaveSignedNymfile(server_->m_nymServer);
2197 EXISTING_NYMBOX_HASH.GetString(msgOut.m_strNymboxHash);
2202 msgOut.SignContract(server_->m_nymServer);
2211 msgOut.SaveContract();
2214 void UserCommandProcessor::UserCmdSendUserMessage(OTPseudonym& theNym,
2219 msgOut.m_strCommand =
"@sendUserMessage";
2220 msgOut.m_strNymID = MsgIn.m_strNymID;
2221 msgOut.m_strNymID2 = MsgIn.m_strNymID2;
2225 const OTString strInMessage(MsgIn);
2226 const OTIdentifier SENDER_USER_ID(theNym),
2227 RECIPIENT_USER_ID(MsgIn.m_strNymID2), SERVER_ID(server_->m_strServerID);
2228 msgOut.m_ascInReferenceTo.SetString(strInMessage);
2230 SendMessageToNym(SERVER_ID, SENDER_USER_ID, RECIPIENT_USER_ID,
2234 OTLog::vError(
"UserCommandProcessor::UserCmdSendUserMessage: Failed "
2236 "SendMessageToNym.\n");
2237 msgOut.m_bSuccess =
false;
2240 msgOut.m_bSuccess =
true;
2243 msgOut.SignContract(server_->m_nymServer);
2252 msgOut.SaveContract();
2255 void UserCommandProcessor::UserCmdSendUserInstrument(OTPseudonym& theNym,
2260 msgOut.m_strCommand =
"@sendUserInstrument";
2261 msgOut.m_strNymID = MsgIn.m_strNymID;
2262 msgOut.m_strNymID2 = MsgIn.m_strNymID2;
2266 const OTString strInMessage(MsgIn);
2267 const OTIdentifier SENDER_USER_ID(theNym),
2268 RECIPIENT_USER_ID(MsgIn.m_strNymID2), SERVER_ID(server_->m_strServerID);
2269 msgOut.m_ascInReferenceTo.SetString(strInMessage);
2270 const bool bSent = server_->SendInstrumentToNym(
2271 SERVER_ID, SENDER_USER_ID, RECIPIENT_USER_ID,
2276 "UserCommandProcessor::UserCmdSendUserInstrument: Failed while "
2277 "calling SendInstrumentToNym.\n");
2278 msgOut.m_bSuccess =
false;
2281 msgOut.m_bSuccess =
true;
2284 msgOut.SignContract(server_->m_nymServer);
2293 msgOut.SaveContract();
2296 void UserCommandProcessor::UserCmdCheckUser(OTPseudonym&, OTMessage& MsgIn,
2300 msgOut.m_strCommand =
"@checkUser";
2301 msgOut.m_strNymID = MsgIn.m_strNymID;
2302 msgOut.m_strNymID2 =
2308 nym2.SetIdentifier(MsgIn.m_strNymID2);
2310 bool bLoaded = nym2.LoadPublicKey();
2311 msgOut.m_bSuccess = (bLoaded && nym2.VerifyPseudonym());
2314 if (msgOut.m_bSuccess) {
2315 nym2.GetPublicEncrKey().GetPublicKey(msgOut.m_strNymPublicKey,
true);
2320 if (nym2.GetMasterCredentialCount() > 0) {
2324 std::unique_ptr<OTDB::Storable> pStorable(
2326 OTDB::StringMap* pMap =
2327 dynamic_cast<OTDB::StringMap*
>(pStorable.get());
2329 if (
nullptr == pMap) {
2331 "STORED_OBJ_STRING_MAP.\n",
2333 msgOut.m_bSuccess =
false;
2336 OTString strCredList;
2337 auto& theMap = pMap->the_map;
2339 nym2.GetPublicCredentials(strCredList, &theMap);
2342 if (!theMap.empty())
2345 const bool bSuccessEncoding = (str_Encoded.size() > 0);
2346 if (bSuccessEncoding) {
2347 msgOut.m_ascPayload.SetString(
2349 msgOut.m_ascPayload2.Set(
2350 str_Encoded.c_str());
2362 OTString tempInMessage(MsgIn);
2363 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
2367 msgOut.SignContract(server_->m_nymServer);
2376 msgOut.SaveContract();
2394 void UserCommandProcessor::UserCmdUsageCredits(OTPseudonym& theNym,
2399 msgOut.m_strCommand =
"@usageCredits";
2400 msgOut.m_strNymID = MsgIn.m_strNymID;
2401 msgOut.m_strNymID2 = MsgIn.m_strNymID2;
2406 const bool bIsPrivilegedNym =
2411 (MsgIn.m_strNymID.Get()))));
2414 const int64_t lAdjustment =
2419 msgOut.m_lDepth = 0;
2421 OTIdentifier nym2ID, SERVER_ID(server_->m_strServerID);
2422 nym2.SetIdentifier(MsgIn.m_strNymID2);
2423 nym2.GetIdentifier(nym2ID);
2425 const bool bIsSameNym = nym2.CompareID(theNym);
2426 OTPseudonym* pNym =
nullptr;
2428 bool bErrorCondition =
false;
2439 bool bLoadedPublicKey =
2440 nym2.LoadPublicKey() &&
2441 nym2.VerifyPseudonym();
2445 bool bLoadSignedNymfile = nym2.LoadSignedNymfile(server_->m_nymServer);
2446 if (!bLoadSignedNymfile &&
2451 else if (bLoadedPublicKey && !bLoadSignedNymfile)
2457 "%s: Nym public key (%s) exists, but nymfile doesn't! "
2458 "Could be error reading from storage. (Failure.)\n",
2459 __FUNCTION__, MsgIn.m_strNymID2.Get());
2460 bErrorCondition =
true;
2466 if (!MsgIn.m_strNymID.Compare(MsgIn.m_strNymID2))
2486 (MsgIn.m_strNymID.Get())))))
2490 OTLog::vError(
"%s: Failed attempt by a normal Nym to view or "
2491 "adjust usage credits on a different Nym (you're "
2492 "only allowed to do this to yourself, unless your "
2493 "nym is the specially-empowered 'override nym'.)\n",
2495 bErrorCondition =
true;
2498 OTLedger theNymbox(nym2ID, nym2ID, SERVER_ID);
2499 bool bSuccessLoadingNymbox = theNymbox.LoadNymbox();
2501 if (bSuccessLoadingNymbox)
2502 bSuccessLoadingNymbox = (theNymbox.VerifyContractID() &&
2503 theNymbox.VerifyAccount(server_->m_nymServer));
2505 bSuccessLoadingNymbox = theNymbox.GenerateLedger(
2508 if (bSuccessLoadingNymbox) {
2509 bSuccessLoadingNymbox =
2510 theNymbox.SignContract(server_->m_nymServer);
2512 if (bSuccessLoadingNymbox) {
2513 bSuccessLoadingNymbox = theNymbox.SaveContract();
2515 if (bSuccessLoadingNymbox)
2516 bSuccessLoadingNymbox = theNymbox.SaveNymbox();
2520 if (!bSuccessLoadingNymbox) bErrorCondition =
true;
2523 if (!bErrorCondition) {
2526 const int64_t& lOldCredits = pNym->GetUsageCredits();
2527 const int64_t lTentativeNew = lOldCredits + lAdjustment;
2528 const int64_t lNewCredits =
2547 if (0 != lAdjustment) {
2559 pNym->SetUsageCredits(lNewCredits);
2560 msgOut.m_bSuccess = pNym->SaveSignedNymfile(
2561 server_->m_nymServer);
2564 msgOut.m_bSuccess =
true;
2579 msgOut.m_lDepth = lNewCredits;
2583 msgOut.m_lDepth = -1;
2588 msgOut.SignContract(server_->m_nymServer);
2597 msgOut.SaveContract();
2601 void UserCommandProcessor::UserCmdIssueAssetType(OTPseudonym& theNym,
2605 const char* szFunc =
"UserCommandProcessor::UserCmdIssueAssetType";
2608 msgOut.m_strCommand =
"@issueAssetType";
2609 msgOut.m_strNymID = MsgIn.m_strNymID;
2610 msgOut.m_strAssetID =
2618 const OTIdentifier USER_ID(theNym), SERVER_ID(server_->m_strServerID),
2619 ASSET_TYPE_ID(MsgIn.m_strAssetID);
2621 OTAssetContract* pAssetContract =
2626 if (
nullptr != pAssetContract)
2629 "%s: Error: Attempt to issue asset type that already exists.\n",
2635 strFilename(MsgIn.m_strAssetID.Get());
2637 OTString strContract(MsgIn.m_ascPayload);
2638 pAssetContract =
new OTAssetContract(MsgIn.m_strAssetID, strFoldername,
2639 strFilename, MsgIn.m_strAssetID);
2641 OTIdentifier ASSET_USER_ID;
2642 bool bSuccessCalculateDigest =
false;
2644 if (
nullptr == pAssetContract) {
2646 "contract. Asset ID: %s\n",
2647 szFunc, MsgIn.m_strAssetID.Get());
2651 bool bSuccessLoadingContract =
2652 pAssetContract->LoadContractFromString(strContract);
2654 if (!bSuccessLoadingContract) {
2656 "from string. Asset ID: %s\n",
2657 szFunc, MsgIn.m_strAssetID.Get());
2659 "from string. Contract:\n\n%s\n\n",
2660 szFunc, strContract.Get());
2662 else if (pAssetContract->GetBasketInfo().Exists()) {
2664 "basket currency contract. (He needs to use "
2665 "the issueBasket message for that.)\n");
2669 OTPseudonym* pNym =
const_cast<OTPseudonym*
>(
2670 pAssetContract->GetContractPublicNym());
2672 if (
nullptr == pNym) {
2674 "public key from asset "
2675 "contract. Asset ID: %s\n",
2676 szFunc, MsgIn.m_strAssetID.Get());
2681 pNym->GetIdentifier(ASSET_USER_ID);
2683 bSuccessCalculateDigest =
true;
2727 if (bSuccessCalculateDigest) {
2728 if ((ASSET_USER_ID == USER_ID))
2734 if (pAssetContract->VerifyContract()) {
2738 std::unique_ptr<OTAccount> pNewAccount(
2740 USER_ID, SERVER_ID, server_->m_nymServer, MsgIn,
2749 OTString tempPayload(*pNewAccount);
2750 msgOut.m_ascPayload.SetString(tempPayload);
2754 pNewAccount->GetIdentifier(msgOut.m_strAcctID);
2771 pAssetContract->SaveContract(
2773 OTIdentifier theNewAccountID;
2774 pNewAccount->GetIdentifier(theNewAccountID);
2777 "Generating inbox/outbox for new issuer acct. \n");
2779 OTLedger theOutbox(USER_ID, theNewAccountID, SERVER_ID),
2780 theInbox(USER_ID, theNewAccountID, SERVER_ID);
2782 bool bSuccessLoadingInbox = theInbox.LoadInbox();
2783 bool bSuccessLoadingOutbox = theOutbox.LoadOutbox();
2787 bSuccessLoadingInbox)
2788 bSuccessLoadingInbox = theInbox.VerifyAccount(
2789 server_->m_nymServer);
2795 bSuccessLoadingInbox = theInbox.GenerateLedger(
2799 if (bSuccessLoadingInbox) {
2800 bSuccessLoadingInbox =
2801 theInbox.SignContract(server_->m_nymServer);
2803 if (bSuccessLoadingInbox) {
2804 bSuccessLoadingInbox =
2805 theInbox.SaveContract();
2807 if (bSuccessLoadingInbox)
2808 bSuccessLoadingInbox =
2809 pNewAccount->SaveInbox(theInbox);
2814 bSuccessLoadingOutbox)
2815 bSuccessLoadingOutbox = theOutbox.VerifyAccount(
2816 server_->m_nymServer);
2822 bSuccessLoadingOutbox = theOutbox.GenerateLedger(
2826 if (bSuccessLoadingOutbox) {
2827 bSuccessLoadingOutbox = theOutbox.SignContract(
2828 server_->m_nymServer);
2830 if (bSuccessLoadingOutbox) {
2831 bSuccessLoadingOutbox =
2832 theOutbox.SaveContract();
2834 if (bSuccessLoadingOutbox)
2835 bSuccessLoadingOutbox =
2836 pNewAccount->SaveOutbox(theOutbox);
2840 if (!bSuccessLoadingInbox) {
2841 OTString strNewAcctID(theNewAccountID);
2844 "UserCommandProcessor::"
2845 "UserCmdIssueAssetType:\n%"
2847 strNewAcctID.Get());
2849 else if (!bSuccessLoadingOutbox) {
2850 OTString strNewAcctID(theNewAccountID);
2853 "UserCommandProcessor::"
2854 "UserCmdIssueAssetType:\n%"
2856 strNewAcctID.Get());
2859 msgOut.m_bSuccess =
true;
2864 std::set<std::string>& theAccountSet =
2865 theNym.GetSetAssetAccounts();
2866 theAccountSet.insert(msgOut.m_strAcctID.Get());
2868 theNym.SaveSignedNymfile(server_->m_nymServer);
2884 "Failure generating new issuer account in "
2885 "UserCommandProcessor::UserCmdIssueAssetType.\n");
2889 "Failure verifying asset contract in "
2890 "UserCommandProcessor::UserCmdIssueAssetType.\n");
2893 OTString strAssetUserID(ASSET_USER_ID), strUserID;
2894 theNym.GetIdentifier(strUserID);
2896 "User ID on this user account (%s) does NOT match User ID "
2897 "for public key used in asset contract: %s\n",
2898 strUserID.Get(), strAssetUserID.Get());
2902 OTLog::vError(
"%s: Failure loading asset contract from client.\n",
2904 if (pAssetContract && !msgOut.m_bSuccess)
2908 delete pAssetContract;
2909 pAssetContract =
nullptr;
2915 OTString tempInMessage(MsgIn);
2916 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
2920 msgOut.SignContract(server_->m_nymServer);
2929 msgOut.SaveContract();
2944 if (msgOut.m_bSuccess) {
2945 const OTString strReplyMessage(msgOut);
2946 const int64_t lReqNum = atol(MsgIn.m_strRequestNum.Get());
2948 DropReplyNoticeToNymbox(SERVER_ID, USER_ID, strReplyMessage, lReqNum,
2956 void UserCommandProcessor::UserCmdIssueBasket(OTPseudonym& theNym,
2961 msgOut.m_strCommand =
"@issueBasket";
2962 msgOut.m_strNymID = MsgIn.m_strNymID;
2968 OTString tempInMessage(MsgIn);
2969 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
2972 const OTIdentifier USER_ID(theNym), SERVER_ID(server_->m_strServerID),
2973 SERVER_USER_ID(server_->m_nymServer);
2975 OTString strBasket(MsgIn.m_ascPayload);
2978 if (!theBasket.LoadContractFromString(strBasket)) {
2979 OTLog::vError(
"%s: Failed trying to load basket from string.\n",
2982 else if (!theBasket.VerifySignature(theNym)) {
2983 OTLog::vError(
"%s: Failed verifying signature on basket.\n",
2994 OTIdentifier BASKET_ID, BASKET_ACCOUNT_ID, BASKET_CONTRACT_ID;
2995 theBasket.CalculateContractID(BASKET_ID);
3000 BASKET_ID, BASKET_ACCOUNT_ID);
3003 OTLog::vError(
"%s: Rejected: user tried to create basket currency "
3004 "that already exists.\n",
3024 bool bSubCurrenciesAllExist =
true;
3026 for (int32_t i = 0; i < theBasket.Count(); i++) {
3027 BasketItem* pItem = theBasket.At(i);
3032 pItem->SUB_CONTRACT_ID))
3035 const OTString strSubID(pItem->SUB_CONTRACT_ID);
3037 "issued on this server: %s\n",
3038 __FUNCTION__, strSubID.Get());
3039 bSubCurrenciesAllExist =
false;
3047 if (bSubCurrenciesAllExist) {
3055 SERVER_USER_ID.GetString(MsgIn.m_strNymID);
3062 for (int32_t i = 0; i < theBasket.Count(); i++) {
3063 BasketItem* pItem = theBasket.At(i);
3088 OTAccount* pNewAccount =
nullptr;
3093 pItem->SUB_CONTRACT_ID.GetString(MsgIn.m_strAssetID);
3096 SERVER_USER_ID, SERVER_ID, server_->m_nymServer, MsgIn,
3102 if (
nullptr != pNewAccount) {
3103 msgOut.m_bSuccess =
true;
3107 pNewAccount->GetIdentifier(pItem->SUB_ACCOUNT_ID);
3110 pNewAccount =
nullptr;
3114 "OTAccount::GenerateNewAccount(SERVER_"
3115 "USER_ID, SERVER_ID, m_nymServer, "
3116 "MsgIn, OTAccount::basketsub)\n",
3118 msgOut.m_bSuccess =
false;
3123 if (
true == msgOut.m_bSuccess) {
3151 theBasket.ReleaseSignatures();
3152 theBasket.SignContract(server_->m_nymServer);
3153 theBasket.SaveContract();
3169 OTAssetContract* pBasketContract =
3170 new BasketContract(theBasket, server_->m_nymServer);
3173 pBasketContract->GetIdentifier(BASKET_CONTRACT_ID);
3174 OTString STR_BASKET_CONTRACT_ID(BASKET_CONTRACT_ID);
3178 msgOut.m_strAssetID = STR_BASKET_CONTRACT_ID;
3182 strFilename(STR_BASKET_CONTRACT_ID.Get());
3187 pBasketContract->SaveContract(strFoldername.Get(),
3213 OTAccount* pBasketAccount =
nullptr;
3217 MsgIn.m_strAssetID = STR_BASKET_CONTRACT_ID;
3220 SERVER_USER_ID, SERVER_ID, server_->m_nymServer, MsgIn,
3223 if (
nullptr != pBasketAccount) {
3224 msgOut.m_bSuccess =
true;
3226 pBasketAccount->GetIdentifier(
3227 msgOut.m_strAcctID);
3228 pBasketAccount->GetAssetTypeID().GetString(
3229 msgOut.m_strAssetID);
3231 pBasketAccount->GetIdentifier(BASKET_ACCOUNT_ID);
3241 BASKET_ID, BASKET_ACCOUNT_ID, BASKET_CONTRACT_ID);
3248 delete pBasketAccount;
3249 pBasketAccount =
nullptr;
3252 msgOut.m_bSuccess =
false;
3261 msgOut.SignContract(server_->m_nymServer);
3270 msgOut.SaveContract();
3274 void UserCommandProcessor::UserCmdCreateAccount(OTPseudonym& theNym,
3279 msgOut.m_strCommand =
"@createAccount";
3280 msgOut.m_strNymID = MsgIn.m_strNymID;
3285 OTString tempInMessage(MsgIn);
3286 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
3288 const OTIdentifier USER_ID(theNym), SERVER_ID(server_->m_strServerID);
3291 USER_ID, SERVER_ID, server_->m_nymServer, MsgIn));
3295 if (
nullptr != pNewAccount) {
3296 const char* szFunc =
"UserCommandProcessor::UserCmdCreateAccount";
3298 pNewAccount->GetAssetTypeID());
3300 if (
nullptr == pContract) {
3301 const OTString strAssetID(pNewAccount->GetAssetTypeID());
3303 "%s: Error: Unable to get AssetContract for asset type: %s\n",
3304 szFunc, strAssetID.Get());
3306 else if (pContract->IsShares()) {
3310 const bool bAdded = pContract->AddAccountRecord(*pNewAccount);
3312 const OTString strAssetID(pNewAccount->GetAssetTypeID());
3314 "%s: ERROR Adding Account Record: %s ... Aborting.\n",
3315 __FUNCTION__, strAssetID.Get());
3319 OTIdentifier theNewAccountID;
3320 pNewAccount->GetIdentifier(theNewAccountID);
3325 OTLedger theOutbox(USER_ID, theNewAccountID, SERVER_ID),
3326 theInbox(USER_ID, theNewAccountID, SERVER_ID);
3328 bool bSuccessLoadingInbox = theInbox.LoadInbox();
3329 bool bSuccessLoadingOutbox = theOutbox.LoadOutbox();
3333 if (
true == bSuccessLoadingInbox)
3334 bSuccessLoadingInbox = theInbox.VerifyAccount(
3335 server_->m_nymServer);
3340 bSuccessLoadingInbox = theInbox.GenerateLedger(
3344 if (bSuccessLoadingInbox) {
3345 bSuccessLoadingInbox =
3346 theInbox.SignContract(server_->m_nymServer);
3348 if (bSuccessLoadingInbox) {
3349 bSuccessLoadingInbox = theInbox.SaveContract();
3351 if (bSuccessLoadingInbox)
3352 bSuccessLoadingInbox = pNewAccount->SaveInbox(theInbox);
3357 if (
true == bSuccessLoadingOutbox)
3358 bSuccessLoadingOutbox = theOutbox.VerifyAccount(
3359 server_->m_nymServer);
3364 bSuccessLoadingOutbox = theOutbox.GenerateLedger(
3368 if (bSuccessLoadingOutbox) {
3369 bSuccessLoadingOutbox =
3370 theOutbox.SignContract(server_->m_nymServer);
3372 if (bSuccessLoadingOutbox) {
3373 bSuccessLoadingOutbox = theOutbox.SaveContract();
3375 if (bSuccessLoadingOutbox)
3376 bSuccessLoadingOutbox =
3377 pNewAccount->SaveOutbox(theOutbox);
3382 if (!bSuccessLoadingInbox) {
3383 const OTString strNewAcctID(theNewAccountID);
3385 OTLog::vError(
"%s: ERROR generating inbox ledger: %s\n", szFunc,
3386 strNewAcctID.Get());
3388 else if (!bSuccessLoadingOutbox) {
3389 const OTString strNewAcctID(theNewAccountID);
3391 OTLog::vError(
"%s: ERROR generating outbox ledger: %s\n", szFunc,
3392 strNewAcctID.Get());
3395 msgOut.m_bSuccess =
true;
3397 pNewAccount->GetIdentifier(msgOut.m_strAcctID);
3402 std::set<std::string>& theAccountSet = theNym.GetSetAssetAccounts();
3403 theAccountSet.insert(msgOut.m_strAcctID.Get());
3405 theNym.SaveSignedNymfile(server_->m_nymServer);
3407 OTString tempPayload(*pNewAccount);
3408 msgOut.m_ascPayload.SetString(tempPayload);
3413 msgOut.SignContract(server_->m_nymServer);
3422 msgOut.SaveContract();
3437 if (msgOut.m_bSuccess) {
3438 const OTString strReplyMessage(msgOut);
3439 const int64_t lReqNum = atol(MsgIn.m_strRequestNum.Get());
3442 DropReplyNoticeToNymbox(
3443 SERVER_ID, USER_ID, strReplyMessage,
3452 void UserCommandProcessor::UserCmdGetAccount(OTPseudonym&, OTMessage& MsgIn,
3456 msgOut.m_strCommand =
"@getAccount";
3457 msgOut.m_strNymID = MsgIn.m_strNymID;
3460 msgOut.m_strAcctID = MsgIn.m_strAcctID;
3462 const OTIdentifier USER_ID(MsgIn.m_strNymID), ACCOUNT_ID(MsgIn.m_strAcctID),
3463 SERVER_ID(MsgIn.m_strServerID);
3466 bool bSuccessLoadingAccount = ((pAccount !=
nullptr) ?
true :
false);
3469 if (bSuccessLoadingAccount && (pAccount->GetUserID() == USER_ID)) {
3470 msgOut.m_bSuccess =
true;
3472 OTString strPayload(
3474 msgOut.m_ascPayload.SetString(strPayload);
3480 msgOut.m_bSuccess =
false;
3481 OTString tempInMessage(
3483 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
3490 msgOut.SignContract((
const OTPseudonym&)server_->m_nymServer);
3499 msgOut.SaveContract();
3502 void UserCommandProcessor::UserCmdGetAccountFiles(OTPseudonym&,
3507 msgOut.m_strCommand =
"@getAccountFiles";
3508 msgOut.m_strNymID = MsgIn.m_strNymID;
3511 msgOut.m_strAcctID = MsgIn.m_strAcctID;
3513 const OTIdentifier USER_ID(MsgIn.m_strNymID), ACCOUNT_ID(MsgIn.m_strAcctID),
3514 SERVER_ID(MsgIn.m_strServerID);
3516 OTString strAccount, strInbox, strOutbox, strInboxHash, strOutboxHash;
3518 bool bSuccessLoadingAccount = ((pAccount !=
nullptr) ?
true :
false);
3519 bool bSuccessLoadingInbox =
false;
3520 bool bSuccessLoadingOutbox =
false;
3521 if (bSuccessLoadingAccount)
3522 bSuccessLoadingAccount = (pAccount->GetUserID() == USER_ID);
3524 if (bSuccessLoadingAccount) {
3526 pAccount->SaveContractRaw(
3532 OTLedger theInbox(USER_ID, ACCOUNT_ID, SERVER_ID);
3534 bSuccessLoadingInbox = theInbox.LoadInbox();
3536 if (!bSuccessLoadingInbox)
3537 OTLog::vError(
"%s: Failed trying to load Inbox from storage.\n",
3546 bSuccessLoadingInbox =
3547 (theInbox.VerifyContractID() &&
3548 theInbox.VerifySignature(server_->m_nymServer));
3553 if (bSuccessLoadingInbox &&
3554 theInbox.LoadedLegacyData())
3563 theInbox.ReleaseSignatures();
3566 theInbox.SignContract(
3567 server_->m_nymServer);
3571 theInbox.SaveContract();
3574 theInbox.SaveInbox();
3578 if (!bSuccessLoadingInbox)
3580 "%s: Verification failed on Inbox after loading.\n",
3583 if (bSuccessLoadingInbox) {
3584 theInbox.SaveContractRaw(strInbox);
3586 OTIdentifier theHash;
3587 if (theInbox.CalculateInboxHash(theHash))
3588 theHash.GetString(strInboxHash);
3593 if (bSuccessLoadingInbox)
3596 OTLedger theOutbox(USER_ID, ACCOUNT_ID, SERVER_ID);
3598 bSuccessLoadingOutbox = theOutbox.LoadOutbox();
3600 if (!bSuccessLoadingOutbox)
3602 "%s: Failed trying to load Outbox from storage.\n",
3611 bSuccessLoadingOutbox =
3612 (theOutbox.VerifyContractID() &&
3613 theOutbox.VerifySignature(server_->m_nymServer));
3618 if (bSuccessLoadingOutbox &&
3619 theOutbox.LoadedLegacyData())
3628 theOutbox.ReleaseSignatures();
3631 theOutbox.SignContract(
3632 server_->m_nymServer);
3636 theOutbox.SaveContract();
3639 theOutbox.SaveOutbox();
3643 if (!bSuccessLoadingOutbox)
3645 "%s: Verification Failed on Outbox after loading.\n",
3648 if (bSuccessLoadingOutbox) {
3649 theOutbox.SaveContractRaw(strOutbox);
3651 OTIdentifier theHash;
3652 if (theOutbox.CalculateOutboxHash(theHash))
3653 theHash.GetString(strOutboxHash);
3660 if (!bSuccessLoadingOutbox || !bSuccessLoadingInbox ||
3661 !bSuccessLoadingAccount) {
3664 msgOut.m_bSuccess =
false;
3665 OTString tempInMessage(
3667 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
3678 std::unique_ptr<OTDB::Storable> pStorable(
3680 OTDB::StringMap* pMap =
dynamic_cast<OTDB::StringMap*
>(pStorable.get());
3683 if (
nullptr == pMap)
3685 "%s: Error: failed trying to create a STORED_OBJ_STRING_MAP.\n",
3688 auto& theMap = pMap->the_map;
3689 theMap.insert(std::pair<std::string, std::string>(
3690 "account", strAccount.Get()));
3692 std::pair<std::string, std::string>(
"inbox", strInbox.Get()));
3694 std::pair<std::string, std::string>(
"outbox", strOutbox.Get()));
3698 const bool bSuccessEncoding = (str_Encoded.size() > 0);
3700 if (!bSuccessEncoding)
3702 "STORED_OBJ_STRING_MAP.\n",
3705 msgOut.m_ascPayload.Set(str_Encoded.c_str());
3706 msgOut.m_strInboxHash = strInboxHash;
3707 msgOut.m_strOutboxHash = strOutboxHash;
3708 msgOut.m_bSuccess =
true;
3713 msgOut.SignContract((
const OTPseudonym&)server_->m_nymServer);
3722 msgOut.SaveContract();
3726 void UserCommandProcessor::UserCmdGetInbox(OTPseudonym&, OTMessage& MsgIn,
3730 msgOut.m_strCommand =
"@getInbox";
3731 msgOut.m_strNymID = MsgIn.m_strNymID;
3734 msgOut.m_strAcctID = MsgIn.m_strAcctID;
3736 const OTIdentifier USER_ID(MsgIn.m_strNymID), ACCOUNT_ID(MsgIn.m_strAcctID),
3737 SERVER_ID(MsgIn.m_strServerID);
3739 OTLedger theLedger(USER_ID, ACCOUNT_ID, SERVER_ID);
3741 msgOut.m_bSuccess = theLedger.LoadInbox();
3743 if (!msgOut.m_bSuccess)
3744 OTLog::vError(
"%s: Failed trying to load Inbox from storage.\n",
3753 msgOut.m_bSuccess = (theLedger.VerifyContractID() &&
3754 theLedger.VerifySignature(server_->m_nymServer));
3759 if (msgOut.m_bSuccess &&
3760 theLedger.LoadedLegacyData())
3769 theLedger.ReleaseSignatures();
3772 theLedger.SignContract(
3773 server_->m_nymServer);
3776 theLedger.SaveContract();
3778 theLedger.SaveInbox();
3782 if (!msgOut.m_bSuccess)
3783 OTLog::vError(
"%s: Verification failed on Inbox after loading.\n",
3787 if (msgOut.m_bSuccess) {
3789 OTString strPayload(
3791 msgOut.m_ascPayload.SetString(strPayload);
3796 OTIdentifier theHash;
3797 if (theLedger.CalculateInboxHash(theHash))
3798 theHash.GetString(msgOut.m_strInboxHash);
3802 OTString tempInMessage(
3804 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
3811 msgOut.SignContract(
3812 (
const OTPseudonym&)server_->m_nymServer);
3821 msgOut.SaveContract();
3825 void UserCommandProcessor::UserCmdGetOutbox(OTPseudonym&, OTMessage& MsgIn,
3829 msgOut.m_strCommand =
"@getOutbox";
3830 msgOut.m_strNymID = MsgIn.m_strNymID;
3833 msgOut.m_strAcctID = MsgIn.m_strAcctID;
3835 const OTIdentifier USER_ID(MsgIn.m_strNymID), ACCOUNT_ID(MsgIn.m_strAcctID),
3836 SERVER_ID(MsgIn.m_strServerID);
3838 OTLedger theLedger(USER_ID, ACCOUNT_ID, SERVER_ID);
3840 msgOut.m_bSuccess = theLedger.LoadOutbox();
3842 if (!msgOut.m_bSuccess)
3843 OTLog::vError(
"%s: Failed trying to load Outbox from storage.\n",
3852 msgOut.m_bSuccess = (theLedger.VerifyContractID() &&
3853 theLedger.VerifySignature(server_->m_nymServer));
3858 if (msgOut.m_bSuccess &&
3859 theLedger.LoadedLegacyData())
3868 theLedger.ReleaseSignatures();
3871 theLedger.SignContract(
3872 server_->m_nymServer);
3875 theLedger.SaveContract();
3877 theLedger.SaveOutbox();
3881 if (!msgOut.m_bSuccess)
3882 OTLog::vError(
"%s: Verification Failed on Outbox after loading.\n",
3886 if (msgOut.m_bSuccess) {
3888 OTString strPayload(
3890 msgOut.m_ascPayload.SetString(strPayload);
3895 OTIdentifier theHash;
3896 if (theLedger.CalculateOutboxHash(theHash))
3897 theHash.GetString(msgOut.m_strOutboxHash);
3901 OTString tempInMessage(
3903 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
3910 msgOut.SignContract((
const OTPseudonym&)server_->m_nymServer);
3919 msgOut.SaveContract();
3922 void UserCommandProcessor::UserCmdQueryAssetTypes(OTPseudonym&,
3927 msgOut.m_strCommand =
"@queryAssetTypes";
3928 msgOut.m_strNymID = MsgIn.m_strNymID;
3931 msgOut.m_bSuccess =
false;
3934 OTString tempInMessage(
3936 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
3941 if (MsgIn.m_ascPayload.Exists())
3945 OTDB::StringMap* pMap =
dynamic_cast<OTDB::StringMap*
>(pStorable.get());
3947 if (
nullptr != pMap)
3949 msgOut.m_bSuccess =
true;
3951 std::map<std::string, std::string>& theMap = pMap->the_map;
3952 std::map<std::string, std::string> theNewMap;
3954 for (
auto& it : theMap) {
3955 const std::string& str1 =
3957 const std::string& str2 =
3969 if ((str1.size() > 0) &&
3970 (str2.compare(
"exists") == 0))
3972 const OTIdentifier theAssetID(str1.c_str());
3973 OTAssetContract* pAssetContract =
3975 if (
nullptr != pAssetContract)
3976 theNewMap[str1] =
"true";
3978 theNewMap[str1] =
"false";
3990 if (str_Encoded.size() > 0)
3991 msgOut.m_ascPayload =
3992 str_Encoded.c_str();
3996 msgOut.m_bSuccess =
false;
4000 msgOut.m_bSuccess =
false;
4004 msgOut.SignContract((
const OTPseudonym&)server_->m_nymServer);
4013 msgOut.SaveContract();
4016 void UserCommandProcessor::UserCmdGetContract(OTPseudonym&, OTMessage& MsgIn,
4020 msgOut.m_strCommand =
"@getContract";
4021 msgOut.m_strNymID = MsgIn.m_strNymID;
4024 msgOut.m_strAssetID = MsgIn.m_strAssetID;
4026 const OTIdentifier ASSET_TYPE_ID(MsgIn.m_strAssetID);
4028 OTAssetContract* pContract =
4031 bool bSuccessLoadingContract = ((pContract !=
nullptr) ?
true :
false);
4034 if (bSuccessLoadingContract) {
4035 msgOut.m_bSuccess =
true;
4037 OTString strPayload(
4039 msgOut.m_ascPayload.SetString(strPayload);
4045 msgOut.m_bSuccess =
false;
4046 OTString tempInMessage(
4048 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
4055 msgOut.SignContract(
4056 (
const OTPseudonym&)server_->m_nymServer);
4065 msgOut.SaveContract();
4070 void UserCommandProcessor::UserCmdTriggerClause(OTPseudonym& theNym,
4074 OTString strInReferenceTo(
4076 msgOut.m_ascInReferenceTo.SetString(strInReferenceTo);
4078 msgOut.m_strCommand =
"@triggerClause";
4079 msgOut.m_strNymID = MsgIn.m_strNymID;
4082 msgOut.m_bSuccess =
false;
4083 const OTIdentifier SERVER_ID(server_->m_strServerID),
4084 theMsgNymboxHash(MsgIn.m_strNymboxHash);
4086 OTIdentifier theSrvrNymboxHash;
4088 bool bGotNymboxHashServerSide =
4089 theNym.GetNymboxHashServerSide(SERVER_ID, theSrvrNymboxHash);
4090 const bool bGotNymboxHashClientSide = MsgIn.m_strNymboxHash.Exists();
4092 if (bGotNymboxHashServerSide)
4094 theSrvrNymboxHash.GetString(msgOut.m_strNymboxHash);
4095 if ((bGotNymboxHashServerSide && bGotNymboxHashClientSide &&
4096 (theMsgNymboxHash != theSrvrNymboxHash)) ||
4097 (bGotNymboxHashServerSide && !bGotNymboxHashClientSide)) {
4099 "%s: Rejecting message since nymbox hash doesn't match. "
4100 "(Send a getNymbox message to grab the newest one.)\n",
4104 OTSmartContract* pSmartContract =
nullptr;
4105 OTCronItem* pCronItem =
4108 if (
nullptr == pCronItem) {
4110 "transaction #: %ld \n",
4111 __FUNCTION__, MsgIn.m_lTransactionNum);
4115 (pSmartContract = dynamic_cast<OTSmartContract*>(pCronItem))) {
4117 0,
"%s: Found cron item %ld based on %ld, but it wasn't a "
4118 "smart contract. \n",
4119 __FUNCTION__, pCronItem->GetTransactionNum(),
4120 MsgIn.m_lTransactionNum);
4124 OTAgent* pAgent =
nullptr;
4126 pSmartContract->FindPartyBasedOnNymAsAgent(theNym, &pAgent);
4128 if (
nullptr == pParty) {
4130 "(%ld based on %ld) "
4131 "based on Nym as agent: %s",
4132 __FUNCTION__, pCronItem->GetTransactionNum(),
4133 MsgIn.m_lTransactionNum, MsgIn.m_strNymID.Get());
4136 bool bSuccess =
false;
4137 const std::string str_clause_name = MsgIn.m_strNymID2.Get();
4139 if (pSmartContract->CanExecuteClause(
4140 pParty->GetPartyName(),
4151 pSmartContract->GetClause(str_clause_name);
4153 if (
nullptr != pClause) {
4155 "smart contract clause: %s \n",
4156 __FUNCTION__, str_clause_name.c_str());
4158 theMatchingClauses.insert(
4159 std::pair<std::string, OTClause*>(str_clause_name,
4162 pSmartContract->ExecuteClauses(
4163 theMatchingClauses);
4165 if (pSmartContract->IsFlaggedForRemoval()) {
4167 "from cron processing: %ld\n",
4169 pSmartContract->GetTransactionNum());
4175 "clause (%s) on smart contract: %ld "
4177 __FUNCTION__, str_clause_name.c_str(),
4178 pSmartContract->GetTransactionNum());
4195 "%s: Party (%s) successfully triggered clause: %s.\n",
4196 __FUNCTION__, pParty->GetPartyName().c_str(),
4197 str_clause_name.c_str());
4199 msgOut.m_bSuccess =
true;
4203 "request of party %s. "
4204 "(Either the permission wasn't there, or "
4205 "the clause wasn't found.)\n",
4206 __FUNCTION__, str_clause_name.c_str(),
4207 pParty->GetPartyName().c_str());
4211 bGotNymboxHashServerSide =
4212 theNym.GetNymboxHashServerSide(SERVER_ID, theSrvrNymboxHash);
4214 if (bGotNymboxHashServerSide)
4216 theSrvrNymboxHash.GetString(msgOut.m_strNymboxHash);
4218 msgOut.SignContract(
4219 (
const OTPseudonym&)server_->m_nymServer);
4228 msgOut.SaveContract();
4231 void UserCommandProcessor::UserCmdGetMint(OTPseudonym&, OTMessage& MsgIn,
4235 msgOut.m_strCommand =
"@getMint";
4236 msgOut.m_strNymID = MsgIn.m_strNymID;
4239 msgOut.m_strAssetID = MsgIn.m_strAssetID;
4241 const OTIdentifier ASSET_TYPE_ID(MsgIn.m_strAssetID);
4242 const OTString ASSET_ID_STR(ASSET_TYPE_ID);
4243 bool bSuccessLoadingMint =
false;
4245 std::unique_ptr<Mint> pMint(
4248 if (
true == (bSuccessLoadingMint = pMint->LoadMint(
".PUBLIC"))) {
4255 bSuccessLoadingMint = pMint->VerifyMint(server_->m_nymServer);
4258 if (bSuccessLoadingMint) {
4259 msgOut.m_bSuccess =
true;
4262 OTString strPayload(
4264 msgOut.m_ascPayload.SetString(strPayload);
4272 if (!bSuccessLoadingMint) {
4273 msgOut.m_bSuccess =
false;
4274 OTString tempInMessage(
4276 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
4283 msgOut.SignContract((
const OTPseudonym&)server_->m_nymServer);
4292 msgOut.SaveContract();
4301 void UserCommandProcessor::UserCmdDeleteUser(OTPseudonym& theNym,
4306 msgOut.m_strCommand =
"@deleteUserAccount";
4307 msgOut.m_strNymID = MsgIn.m_strNymID;
4311 const OTIdentifier USER_ID(MsgIn.m_strNymID),
4312 SERVER_ID(MsgIn.m_strServerID);
4314 OTLedger theLedger(USER_ID, USER_ID, SERVER_ID);
4316 std::set<int64_t>& theSetofCronItemIDs = theNym.GetSetOpenCronItems();
4322 const bool bSuccessLoadNymbox =
4323 (theLedger.LoadNymbox() &&
4324 theLedger.VerifyAccount(server_->m_nymServer));
4325 if (!bSuccessLoadNymbox) {
4326 OTLog::Output(3,
"Tried to delete Nym, but failed loading or verifying "
4328 msgOut.m_bSuccess =
false;
4330 else if (theLedger.GetTransactionCount() > 0) {
4331 OTLog::Output(3,
"Tried to delete Nym, but there are still receipts in "
4332 "the Nymbox. (Process them first.)\n");
4333 msgOut.m_bSuccess =
false;
4337 else if (!theSetofCronItemIDs.empty()) {
4338 OTLog::Output(3,
"Tried to delete Nym, but there are still open Cron "
4339 "Items. (Close them first.)\n");
4340 msgOut.m_bSuccess =
false;
4342 else if (theNym.GetSetAssetAccounts().size() > 0) {
4343 OTLog::Output(3,
"Tried to delete Nym, but there are still Asset "
4344 "Accounts open for that Nym. (Close them first.)\n");
4345 msgOut.m_bSuccess =
false;
4350 else if (theNym.GetTransactionNumCount(SERVER_ID) !=
4351 theNym.GetIssuedNumCount(SERVER_ID)) {
4352 OTLog::Output(3,
"Tried to delete Nym, but there are still "
4353 "transactions open for that Nym. (Close them "
4355 msgOut.m_bSuccess =
false;
4359 msgOut.m_bSuccess =
true;
4376 while (theNym.GetTransactionNumCount(SERVER_ID) > 0) {
4377 int64_t lTemp = theNym.GetTransactionNum(SERVER_ID, 0);
4379 theNym, lTemp,
false);
4382 while (theNym.GetIssuedNumCount(SERVER_ID) > 0) {
4383 int64_t lTemp = theNym.GetIssuedNum(SERVER_ID, 0);
4388 theNym.MarkForDeletion();
4395 theNym.SaveSignedNymfile(server_->m_nymServer);
4401 OTString tempInMessage(
4403 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
4410 msgOut.SignContract((
const OTPseudonym&)server_->m_nymServer);
4419 msgOut.SaveContract();
4436 if (msgOut.m_bSuccess) {
4437 const OTString strReplyMessage(msgOut);
4438 const int64_t lReqNum = atol(MsgIn.m_strRequestNum.Get());
4441 DropReplyNoticeToNymbox(SERVER_ID, USER_ID, strReplyMessage, lReqNum,
4452 void UserCommandProcessor::UserCmdGetBoxReceipt(OTPseudonym&, OTMessage& MsgIn,
4456 msgOut.m_strCommand =
"@getBoxReceipt";
4457 msgOut.m_strNymID = MsgIn.m_strNymID;
4460 msgOut.m_strAcctID = MsgIn.m_strAcctID;
4463 msgOut.m_lTransactionNum =
4464 MsgIn.m_lTransactionNum;
4466 msgOut.m_lDepth = MsgIn.m_lDepth;
4467 msgOut.m_bSuccess =
false;
4469 const OTIdentifier USER_ID(MsgIn.m_strNymID),
4470 SERVER_ID(MsgIn.m_strServerID), ACCOUNT_ID(MsgIn.m_strAcctID);
4472 OTLedger* pLedger =
nullptr;
4473 std::unique_ptr<OTLedger> theLedgerAngel;
4475 bool bErrorCondition =
false;
4476 bool bSuccessLoading =
false;
4478 switch (MsgIn.m_lDepth) {
4480 if (USER_ID == ACCOUNT_ID) {
4481 pLedger =
new OTLedger(USER_ID, USER_ID, SERVER_ID);
4483 theLedgerAngel.reset(pLedger);
4484 bSuccessLoading = pLedger->LoadNymbox();
4491 "UserCommandProcessor::UserCmdGetBoxReceipt: User requested "
4493 "failed to provide the "
4494 "UserID (%s) in the AccountID (%s) field as expected.\n",
4495 MsgIn.m_strNymID.Get(), MsgIn.m_strAcctID.Get());
4496 bErrorCondition =
true;
4500 if (USER_ID == ACCOUNT_ID) {
4502 "UserCommandProcessor::UserCmdGetBoxReceipt: User requested "
4503 "Inbox, but erroneously provided the "
4504 "UserID (%s) in the AccountID (%s) field.\n",
4505 MsgIn.m_strNymID.Get(), MsgIn.m_strAcctID.Get());
4506 bErrorCondition =
true;
4509 pLedger =
new OTLedger(USER_ID, ACCOUNT_ID, SERVER_ID);
4511 theLedgerAngel.reset(pLedger);
4512 bSuccessLoading = pLedger->LoadInbox();
4518 if (USER_ID == ACCOUNT_ID) {
4520 "UserCommandProcessor::UserCmdGetBoxReceipt: User requested "
4521 "Outbox, but erroneously provided the "
4522 "UserID (%s) in the AccountID (%s) field.\n",
4523 MsgIn.m_strNymID.Get(), MsgIn.m_strAcctID.Get());
4524 bErrorCondition =
true;
4527 pLedger =
new OTLedger(USER_ID, ACCOUNT_ID, SERVER_ID);
4529 theLedgerAngel.reset(pLedger);
4530 bSuccessLoading = pLedger->LoadOutbox();
4536 OTLog::vError(
"UserCommandProcessor::UserCmdGetBoxReceipt: Unknown box "
4539 bErrorCondition =
true;
4545 if (bSuccessLoading && !bErrorCondition &&
4550 pLedger->VerifyContractID() &&
4553 pLedger->VerifySignature(
4554 server_->m_nymServer)
4556 OTTransaction* pTransaction =
4557 pLedger->GetTransaction(MsgIn.m_lTransactionNum);
4558 if (
nullptr == pTransaction) {
4560 "UserCommandProcessor::UserCmdGetBoxReceipt: User requested a "
4561 "transaction number "
4562 "(%ld) that's not in the %s. UserID (%s) and "
4563 "AccountID (%s) FYI.\n",
4564 MsgIn.m_lTransactionNum,
4565 (MsgIn.m_lDepth == 0)
4567 : ((MsgIn.m_lDepth == 1) ?
"inbox"
4569 MsgIn.m_strNymID.Get(),
4570 MsgIn.m_strAcctID.Get());
4573 pLedger->LoadBoxReceipt(MsgIn.m_lTransactionNum);
4587 pTransaction = pLedger->GetTransaction(MsgIn.m_lTransactionNum);
4589 if ((
nullptr != pTransaction) && !pTransaction->IsAbbreviated() &&
4590 pTransaction->VerifyContractID() &&
4591 pTransaction->VerifySignature(server_->m_nymServer)) {
4597 const OTString strBoxReceipt(*pTransaction);
4600 msgOut.m_ascPayload.SetString(
4602 msgOut.m_bSuccess =
true;
4605 3,
"UserCommandProcessor::UserCmdGetBoxReceipt: Success: "
4607 "retrieving the box receipt for transaction number "
4608 "%ld in the %s for UserID (%s) AccountID (%s).\n",
4609 MsgIn.m_lTransactionNum,
4610 (MsgIn.m_lDepth == 0)
4612 : ((MsgIn.m_lDepth == 1) ?
"inbox"
4614 MsgIn.m_strNymID.Get(),
4615 MsgIn.m_strAcctID.Get());
4619 "UserCommandProcessor::UserCmdGetBoxReceipt: User "
4621 "transaction number (%ld) that's "
4622 "failing to retrieve from the %s, AFTER calling "
4623 "LoadBoxReceipt(). (Though it worked BEFORE calling it.) "
4624 "UserID (%s) and AccountID (%s) FYI. IsAbbreviated == %s\n",
4625 MsgIn.m_lTransactionNum,
4626 (MsgIn.m_lDepth == 0)
4628 : ((MsgIn.m_lDepth == 1) ?
"inbox"
4630 MsgIn.m_strNymID.Get(),
4631 MsgIn.m_strAcctID.Get(),
4632 (
nullptr == pTransaction)
4634 : (pTransaction->IsAbbreviated()) ?
"true" :
"false");
4640 "UserCommandProcessor::UserCmdGetBoxReceipt: Failed loading or "
4642 "Transaction (%ld), UserID (%s) and AccountID (%s) FYI.\n",
4643 (MsgIn.m_lDepth == 0)
4645 : ((MsgIn.m_lDepth == 1) ?
"inbox" :
"outbox"),
4646 MsgIn.m_lTransactionNum,
4647 MsgIn.m_strNymID.Get(), MsgIn.m_strAcctID.Get());
4653 const OTString tempInMessage(
4655 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
4662 msgOut.SignContract((
const OTPseudonym&)server_->m_nymServer);
4671 msgOut.SaveContract();
4678 void UserCommandProcessor::UserCmdDeleteAssetAcct(OTPseudonym& theNym,
4682 const char* szFunc =
"UserCommandProcessor::UserCmdDeleteAssetAcct";
4685 msgOut.m_strCommand =
"@deleteAssetAccount";
4686 msgOut.m_strNymID = MsgIn.m_strNymID;
4689 msgOut.m_strAcctID = MsgIn.m_strAcctID;
4691 const OTIdentifier USER_ID(MsgIn.m_strNymID),
4692 SERVER_ID(MsgIn.m_strServerID), ACCOUNT_ID(MsgIn.m_strAcctID);
4694 std::unique_ptr<OTAccount> pAccount(
4697 if (
nullptr == pAccount || !pAccount->VerifyAccount(server_->m_nymServer)) {
4698 OTLog::vError(
"%s: Error loading or verifying account: %s\n", szFunc,
4699 MsgIn.m_strAcctID.Get());
4701 else if (pAccount->GetBalance() != 0) {
4702 OTLog::vOutput(1,
"%s: Failed while trying to delete asset account %s: "
4703 "Balance must be zero to do this!\n",
4704 szFunc, MsgIn.m_strAcctID.Get());
4707 std::unique_ptr<OTLedger> pInbox(
4708 pAccount->LoadInbox(server_->m_nymServer));
4709 std::unique_ptr<OTLedger> pOutbox(
4710 pAccount->LoadOutbox(server_->m_nymServer));
4716 OTLog::vError(
"%s: Error loading or verifying inbox: %s\n", szFunc,
4717 MsgIn.m_strAcctID.Get());
4724 OTLog::vError(
"%s: Error loading or verifying outbox: %s\n", szFunc,
4725 MsgIn.m_strAcctID.Get());
4727 else if (pInbox->GetTransactionCount() > 0) {
4729 3,
"%s: Tried to delete asset account, but there are still "
4730 "receipts in the Inbox. (Process them first.)\n",
4732 msgOut.m_bSuccess =
false;
4734 else if (pOutbox->GetTransactionCount() > 0) {
4736 3,
"%s: Tried to delete asset account, but there are still "
4737 "receipts in the Outbox. (Process them first.)\n",
4739 msgOut.m_bSuccess =
false;
4743 msgOut.m_bSuccess =
true;
4745 std::set<std::string>& theAccountSet = theNym.GetSetAssetAccounts();
4746 theAccountSet.erase(MsgIn.m_strAcctID.Get());
4748 theNym.SaveSignedNymfile(server_->m_nymServer);
4750 pAccount->GetAssetTypeID());
4752 if (
nullptr == pContract) {
4753 const OTString strAssetID(pAccount->GetAssetTypeID());
4756 szFunc, strAssetID.Get());
4758 else if (pContract->IsShares()) {
4762 const bool bErased =
4763 pContract->EraseAccountRecord(pAccount->GetAssetTypeID());
4765 const OTString strAssetID(pAccount->GetAssetTypeID());
4767 "%s: ERROR Erasing Account Record: %s ... Aborting.\n",
4768 __FUNCTION__, strAssetID.Get());
4773 pAccount->MarkForDeletion();
4779 pAccount->ReleaseSignatures();
4780 pAccount->SignContract(server_->m_nymServer);
4781 pAccount->SaveContract();
4782 pAccount->SaveAccount();
4789 OTString tempInMessage(
4791 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
4798 msgOut.SignContract((
const OTPseudonym&)server_->m_nymServer);
4807 msgOut.SaveContract();
4821 if (msgOut.m_bSuccess) {
4822 const OTString strReplyMessage(msgOut);
4823 const int64_t lReqNum = atol(MsgIn.m_strRequestNum.Get());
4826 DropReplyNoticeToNymbox(SERVER_ID, USER_ID, strReplyMessage, lReqNum,
4832 void UserCommandProcessor::UserCmdGetNymbox(OTPseudonym& theNym,
4833 OTMessage& MsgIn, OTMessage& msgOut)
4836 msgOut.m_strCommand =
"@getNymbox";
4837 msgOut.m_strNymID = MsgIn.m_strNymID;
4841 const OTIdentifier USER_ID(MsgIn.m_strNymID),
4842 SERVER_ID(MsgIn.m_strServerID);
4843 OTIdentifier NYMBOX_HASH;
4844 bool bSavedNymbox =
false;
4846 OTLedger theLedger(USER_ID, USER_ID, SERVER_ID);
4848 msgOut.m_bSuccess = theLedger.LoadNymbox();
4850 if (!msgOut.m_bSuccess)
4851 OTLog::Error(
"UserCommandProcessor::UserCmdGetNymbox: Failed trying to "
4861 msgOut.m_bSuccess = (theLedger.VerifyContractID() &&
4862 theLedger.VerifySignature(server_->m_nymServer));
4867 if (msgOut.m_bSuccess &&
4868 theLedger.LoadedLegacyData())
4877 theLedger.ReleaseSignatures();
4880 theLedger.SignContract(
4881 server_->m_nymServer);
4884 theLedger.SaveContract();
4886 theLedger.SaveNymbox(&NYMBOX_HASH);
4889 bSavedNymbox =
true;
4891 if (!msgOut.m_bSuccess)
4892 OTLog::Error(
"UserCommandProcessor::UserCmdGetNymbox: Verification "
4894 "Nymbox after loading.\n");
4897 if (
true == msgOut.m_bSuccess) {
4899 OTString strPayload(
4901 msgOut.m_ascPayload.SetString(strPayload);
4908 OTString tempInMessage(
4910 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
4920 theNym.SetNymboxHashServerSide(
4922 theNym.SaveSignedNymfile(server_->m_nymServer);
4924 NYMBOX_HASH.GetString(
4925 msgOut.m_strNymboxHash);
4927 else if (
true == msgOut.m_bSuccess) {
4928 theLedger.CalculateNymboxHash(NYMBOX_HASH);
4930 theNym.SetNymboxHashServerSide(
4932 theNym.SaveSignedNymfile(server_->m_nymServer);
4934 NYMBOX_HASH.GetString(
4935 msgOut.m_strNymboxHash);
4938 OTIdentifier EXISTING_NYMBOX_HASH;
4939 if (theNym.GetNymboxHashServerSide(
4941 EXISTING_NYMBOX_HASH))
4942 EXISTING_NYMBOX_HASH.GetString(
4943 msgOut.m_strNymboxHash);
4947 msgOut.SignContract(
4948 (
const OTPseudonym&)server_->m_nymServer);
4957 msgOut.SaveContract();
4960 void UserCommandProcessor::UserCmdProcessNymbox(OTPseudonym& theNym,
4965 msgOut.m_strCommand =
"@processNymbox";
4966 msgOut.m_strNymID = MsgIn.m_strNymID;
4970 const OTIdentifier USER_ID(msgOut.m_strNymID),
4971 SERVER_ID(server_->m_strServerID), SERVER_USER_ID(server_->m_nymServer);
4973 OTLedger theLedger(USER_ID, USER_ID, SERVER_ID);
4982 OTString strLedger(MsgIn.m_ascPayload);
4984 bool bTransSuccess =
false;
4986 const OTIdentifier theMsgNymboxHash(
4987 MsgIn.m_strNymboxHash);
4989 OTIdentifier theSrvrNymboxHash;
4991 bool bGotNymboxHashServerSide =
4992 theNym.GetNymboxHashServerSide(SERVER_ID, theSrvrNymboxHash);
4994 if (bGotNymboxHashServerSide)
4996 theSrvrNymboxHash.GetString(msgOut.m_strNymboxHash);
4999 1,
"%s: We cannot obtain server side nymbox hash, will continue.\n",
5003 const bool bGotNymboxHashClientSide = MsgIn.m_strNymboxHash.Exists();
5005 if (!bGotNymboxHashClientSide) {
5007 1,
"%s: We don't have a client side nymbox hash, will continue\n",
5011 if (bGotNymboxHashServerSide && bGotNymboxHashClientSide)
5012 if (theMsgNymboxHash != theSrvrNymboxHash) {
5014 "missmatch! rejecting message.\n",
5024 msgOut.m_bSuccess = theLedger.LoadContractFromString(strLedger);
5025 if (msgOut.m_bSuccess)
5034 if (theLedger.GetTransactionCount() == 0) {
5037 pTranResponse->SignContract(server_->m_nymServer);
5038 pTranResponse->SaveContract();
5043 pResponseLedger->AddTransaction(*pTranResponse);
5045 for (
auto& it : theLedger.GetTransactionMap()) {
5046 OTTransaction* pTransaction = it.second;
5048 "nullptr transaction pointer in "
5049 "UserCommandProcessor::UserCmdProcessNymbox\n");
5056 pTransaction->GetTransactionNum());
5061 pResponseLedger->AddTransaction(*pTranResponse);
5095 theNym, *pTransaction, *pTranResponse, bTransSuccess);
5097 pTranResponse =
nullptr;
5113 "UserCommandProcessor::UserCmdProcessNymbox\n");
5119 pResponseLedger->SignContract(server_->m_nymServer);
5120 pResponseLedger->SaveContract();
5122 OTString strPayload(*pResponseLedger);
5124 msgOut.m_ascPayload.SetString(strPayload);
5134 OTString tempInMessage(MsgIn);
5135 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
5148 bGotNymboxHashServerSide =
5149 theNym.GetNymboxHashServerSide(SERVER_ID, theSrvrNymboxHash);
5150 if (bGotNymboxHashServerSide)
5152 theSrvrNymboxHash.GetString(msgOut.m_strNymboxHash);
5155 msgOut.SignContract(server_->m_nymServer);
5164 msgOut.SaveContract();
5178 if (msgOut.m_bSuccess) {
5179 const OTString strReplyMessage(msgOut);
5180 const int64_t lReqNum = atol(MsgIn.m_strRequestNum.Get());
5183 DropReplyNoticeToNymbox(
5184 SERVER_ID, USER_ID, strReplyMessage,
5196 void UserCommandProcessor::UserCmdProcessInbox(OTPseudonym& theNym,
5201 msgOut.m_strCommand =
"@processInbox";
5202 msgOut.m_strNymID = MsgIn.m_strNymID;
5205 msgOut.m_strAcctID = MsgIn.m_strAcctID;
5207 const OTIdentifier USER_ID(msgOut.m_strNymID),
5208 ACCOUNT_ID(MsgIn.m_strAcctID), SERVER_ID(server_->m_strServerID),
5209 SERVER_USER_ID(server_->m_nymServer);
5211 OTLedger theLedger(USER_ID, ACCOUNT_ID, SERVER_ID);
5217 OT_ASSERT_MSG(
nullptr != pResponseLedger,
"UserCommandProcessor::"
5218 "UserCmdProcessInbox: ASSERT: "
5219 "nullptr != pResponseLedger");
5220 OTTransaction* pTranResponse =
nullptr;
5224 OTString strLedger(MsgIn.m_ascPayload);
5226 bool bTransSuccess =
false;
5227 const OTIdentifier theMsgNymboxHash(
5228 MsgIn.m_strNymboxHash);
5230 OTIdentifier theSrvrNymboxHash;
5232 bool bGotNymboxHashServerSide =
5233 theNym.GetNymboxHashServerSide(SERVER_ID, theSrvrNymboxHash);
5235 if (bGotNymboxHashServerSide)
5237 theSrvrNymboxHash.GetString(msgOut.m_strNymboxHash);
5240 1,
"%s: We cannot obtain server side nymbox hash, will continue.\n",
5244 const bool bGotNymboxHashClientSide = MsgIn.m_strNymboxHash.Exists();
5246 if (!bGotNymboxHashClientSide) {
5248 1,
"%s: We don't have a client side nymbox hash, will continue\n",
5252 if (bGotNymboxHashServerSide && bGotNymboxHashClientSide)
5253 if (theMsgNymboxHash != theSrvrNymboxHash) {
5255 "missmatch! rejecting message.\n",
5264 msgOut.m_bSuccess = theLedger.LoadContractFromString(strLedger);
5265 if (msgOut.m_bSuccess) {
5266 OTAccount theAccount(USER_ID, ACCOUNT_ID, SERVER_ID);
5269 if (!theAccount.LoadContract()) {
5270 const OTString strAcctID(ACCOUNT_ID);
5272 "Failed loading account: %s\n",
5276 else if (theAccount.IsMarkedForDeletion()) {
5278 0,
"UserCommandProcessor::UserCmdProcessInbox: Failed attempt "
5279 "to use an Asset account that was marked for "
5284 else if (!theAccount.VerifyContractID()) {
5289 "UserCommandProcessor::UserCmdProcessInbox\n");
5296 else if (!theAccount.VerifyOwner(theNym)) {
5298 "UserCommandProcessor::UserCmdProcessInbox\n");
5301 else if (!theAccount.VerifySignature(server_->m_nymServer)) {
5302 OTLog::Error(
"Error verifying server signature on account in "
5303 "UserCommandProcessor::UserCmdProcessInbox\n");
5317 OTTransaction* pTransaction =
5320 if (
nullptr == pTransaction)
5324 "UserCommandProcessor::UserCmdProcessInbox\n");
5327 const int64_t lTransactionNumber =
5328 pTransaction->GetTransactionNum();
5335 lTransactionNumber);
5337 "UserCommandProcessor::UserCmdProcessInbox: "
5338 "nullptr != pTranResponse");
5343 pResponseLedger->AddTransaction(*pTranResponse);
5346 theNym, lTransactionNumber)) {
5350 0,
"UserCommandProcessor::UserCmdProcessInbox: Error "
5351 "verifying transaction num %ld for Nym "
5353 lTransactionNumber, msgOut.m_strNymID.Get());
5364 else if (!pTransaction->VerifyItems(theNym)) {
5366 0,
"Error verifying transaction items "
5367 "UserCommandProcessor::UserCmdProcessInbox\n");
5383 theNym, lTransactionNumber,
true))
5386 "Error removing transaction number (as "
5387 "available) from user nym in "
5388 "UserCommandProcessor::UserCmdProcessInbox\n");
5392 2,
"UserCmdProcessInbox type: Process Inbox\n");
5395 theNym, theAccount, *pTransaction, *pTranResponse,
5403 theNym, lTransactionNumber,
5427 "UserCommandProcessor::UserCmdProcessInbox\n");
5432 if (
nullptr == pTranResponse) {
5435 OT_ASSERT_MSG(
nullptr != pTranResponse,
"UserCommandProcessor::"
5436 "UserCmdProcessInbox 2: "
5437 "nullptr != pTranResponse");
5442 pResponseLedger->AddTransaction(*pTranResponse);
5446 OT_ASSERT_MSG(
nullptr != pTranResponse,
"UserCommandProcessor::"
5447 "UserCmdProcessInbox 3: nullptr != "
5450 pTranResponse->ReleaseSignatures();
5451 pTranResponse->SignContract(server_->m_nymServer);
5452 pTranResponse->SaveContract();
5456 pResponseLedger->SignContract(server_->m_nymServer);
5457 pResponseLedger->SaveContract();
5459 OTString strPayload(*pResponseLedger);
5461 msgOut.m_ascPayload.SetString(strPayload);
5471 OTString tempInMessage(MsgIn);
5472 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
5485 bGotNymboxHashServerSide =
5486 theNym.GetNymboxHashServerSide(SERVER_ID, theSrvrNymboxHash);
5487 if (bGotNymboxHashServerSide)
5489 theSrvrNymboxHash.GetString(msgOut.m_strNymboxHash);
5492 msgOut.SignContract(server_->m_nymServer);
5501 msgOut.SaveContract();
5515 if (msgOut.m_bSuccess) {
5516 const OTString strReplyMessage(msgOut);
5517 const int64_t lReqNum = atol(MsgIn.m_strRequestNum.Get());
5520 DropReplyNoticeToNymbox(SERVER_ID, USER_ID, strReplyMessage,
5535 void UserCommandProcessor::UserCmdNotarizeTransactions(OTPseudonym& theNym,
5540 msgOut.m_strCommand =
5541 "@notarizeTransactions";
5542 msgOut.m_strNymID = MsgIn.m_strNymID;
5545 msgOut.m_strAcctID = MsgIn.m_strAcctID;
5547 const OTIdentifier USER_ID(MsgIn.m_strNymID), ACCOUNT_ID(MsgIn.m_strAcctID),
5548 SERVER_ID(server_->m_strServerID), SERVER_USER_ID(server_->m_nymServer);
5550 OTLedger theLedger(USER_ID, ACCOUNT_ID, SERVER_ID);
5558 bool bTransSuccess =
false;
5559 bool bCancelled =
false;
5562 int64_t lTransactionNumber = 0, lResponseNumber = 0;
5569 OTString strLedger(MsgIn.m_ascPayload);
5571 const OTIdentifier theMsgNymboxHash(
5572 MsgIn.m_strNymboxHash);
5574 OTIdentifier theSrvrNymboxHash;
5576 bool bGotNymboxHashServerSide =
5577 theNym.GetNymboxHashServerSide(SERVER_ID, theSrvrNymboxHash);
5579 if (bGotNymboxHashServerSide)
5581 theSrvrNymboxHash.GetString(msgOut.m_strNymboxHash);
5584 1,
"%s: We cannot obtain server side nymbox hash, will continue.\n",
5588 const bool bGotNymboxHashClientSide = MsgIn.m_strNymboxHash.Exists();
5590 if (!bGotNymboxHashClientSide) {
5592 1,
"%s: We don't have a client side nymbox hash, will continue\n",
5596 if (bGotNymboxHashServerSide && bGotNymboxHashClientSide)
5597 if (theMsgNymboxHash != theSrvrNymboxHash) {
5599 "missmatch! rejecting message.\n",
5610 msgOut.m_bSuccess = theLedger.LoadLedgerFromString(strLedger);
5612 if (msgOut.m_bSuccess) {
5634 int32_t nCounter = 0;
5635 for (
auto& it : theLedger.GetTransactionMap()) {
5636 OTTransaction* pTransaction = it.second;
5642 "message ledger.\n");
5661 pTransaction->GetTransactionNum());
5665 pResponseLedger->AddTransaction(*pTranResponse);
5698 *pTranResponse, bTransSuccess);
5700 if (pTranResponse->IsCancelled()) bCancelled =
true;
5702 lTransactionNumber = pTransaction->GetTransactionNum();
5703 lResponseNumber = pTranResponse->GetTransactionNum();
5706 "Transaction number and response number should "
5707 "always be the same. (But this time, they weren't.)");
5709 pTranResponse =
nullptr;
5723 pResponseLedger->SignContract(server_->m_nymServer);
5724 pResponseLedger->SaveContract();
5727 OTString strPayload(*pResponseLedger);
5729 msgOut.m_ascPayload.SetString(strPayload);
5735 "UserCommandProcessor::UserCmdNotarizeTransactions\n");
5747 OTString tempInMessage(MsgIn);
5748 msgOut.m_ascInReferenceTo.SetString(tempInMessage);
5761 bGotNymboxHashServerSide =
5762 theNym.GetNymboxHashServerSide(SERVER_ID, theSrvrNymboxHash);
5763 if (bGotNymboxHashServerSide)
5765 theSrvrNymboxHash.GetString(msgOut.m_strNymboxHash);
5768 msgOut.SignContract(server_->m_nymServer);
5777 msgOut.SaveContract();
5791 if (msgOut.m_bSuccess) {
5792 const OTString strReplyMessage(msgOut);
5793 const int64_t lReqNum = atol(MsgIn.m_strRequestNum.Get());
5799 DropReplyNoticeToNymbox(SERVER_ID, USER_ID, strReplyMessage, lReqNum,
5803 OTLog::vOutput(0,
"Success: canceling transaction %ld for nym: %s \n",
5804 lTransactionNumber, msgOut.m_strNymID.Get());
5806 else if (bTransSuccess) {
5807 OTLog::vOutput(0,
"Success: processing transaction %ld for nym: %s \n",
5808 lTransactionNumber, msgOut.m_strNymID.Get());
5811 OTLog::vOutput(0,
"Failure: processing transaction %ld for nym: %s \n",
5812 lTransactionNumber, msgOut.m_strNymID.Get());
5820 bool UserCommandProcessor::SendMessageToNym(
5821 const OTIdentifier& SERVER_ID,
const OTIdentifier& SENDER_USER_ID,
5822 const OTIdentifier& RECIPIENT_USER_ID,
5826 const OTString* pstrMessage)
5831 return server_->DropMessageToNymbox(
5842 void UserCommandProcessor::DropReplyNoticeToNymbox(
5843 const OTIdentifier& SERVER_ID,
const OTIdentifier& USER_ID,
5844 const OTString& strMessage,
const int64_t& lRequestNum,
5845 const bool bReplyTransSuccess, OTPseudonym* pActualNym)
5847 OTLedger theNymbox(USER_ID, USER_ID, SERVER_ID);
5849 bool bSuccessLoadingNymbox = theNymbox.LoadNymbox();
5851 if (
true == bSuccessLoadingNymbox)
5852 bSuccessLoadingNymbox =
5853 (theNymbox.VerifyContractID() &&
5854 theNymbox.VerifySignature(server_->m_nymServer));
5859 if (!bSuccessLoadingNymbox) {
5860 const OTString strNymID(USER_ID);
5861 OTLog::vOutput(0,
"OTServer::DropReplyNoticeToNymbox: Failed loading "
5862 "or verifying Nymbox for user: %s\n",
5866 int64_t lReplyNoticeTransNum = 0;
5868 server_->m_nymServer, lReplyNoticeTransNum,
5871 if (!bGotNextTransNum) {
5872 lReplyNoticeTransNum = 0;
5873 OTLog::Error(
"OTServer::DropReplyNoticeToNymbox: Error getting "
5874 "next transaction number for an "
5875 "OTTransaction::replyNotice.\n");
5885 pReplyNoticeItem->SetStatus(
5891 pReplyNoticeItem->SetAttachment(
5895 pReplyNoticeItem->SignContract(server_->m_nymServer);
5896 pReplyNoticeItem->SaveContract();
5897 pReplyNotice->AddItem(*pReplyNoticeItem);
5916 pReplyNotice->SetRequestNum(lRequestNum);
5917 pReplyNotice->SetReplyTransSuccess(bReplyTransSuccess);
5918 pReplyNotice->SignContract(server_->m_nymServer);
5919 pReplyNotice->SaveContract();
5920 theNymbox.AddTransaction(*pReplyNotice);
5923 theNymbox.ReleaseSignatures();
5924 theNymbox.SignContract(server_->m_nymServer);
5925 theNymbox.SaveContract();
5927 OTIdentifier NYMBOX_HASH;
5928 theNymbox.SaveNymbox(&NYMBOX_HASH);
5930 pReplyNotice->SaveBoxReceipt(theNymbox);
5932 if ((
nullptr != pActualNym) && pActualNym->CompareID(USER_ID)) {
5933 pActualNym->SetNymboxHashServerSide(NYMBOX_HASH);
5934 pActualNym->SaveSignedNymfile(server_->m_nymServer);
5936 else if (
nullptr != pActualNym)
5937 OTLog::Error(
"OTServer::DropReplyNoticeToNymbox: ERROR: "
5938 "pActualNym was not nullptr, but it didn't match "
static EXPORT void vError(const char *szError,...)
EXPORT bool StorePlainString(std::string strContents, std::string strFolder, std::string oneStr="", std::string twoStr="", std::string threeStr="")
OTASCIIArmor m_ascPayload2
static EXPORT OTAsymmetricKey * KeyFactory()
EXPORT Storable * CreateObject(StoredObjectType eType)
EXPORT bool SetPublicKey(const OTString &strKey, bool bEscaped=true)
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)
static bool __cmd_check_user
virtual EXPORT bool SignContract(const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr)
static EXPORT Mint * MintFactory()
static bool __admin_usage_credits
EXPORT bool LoadFromString(const OTString &strNym, OTString::Map *pMapCredentials=nullptr, OTString *pstrReason=nullptr, const OTPassword *pImportPassword=nullptr)
virtual EXPORT bool VerifySignature(const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr) const
EXPORT void GetIdentifier(OTIdentifier &theIdentifier) const
static EXPORT const OTString & Pubcred()
EXPORT void SetAcknowledgments(OTPseudonym &theNym)
static bool __cmd_create_asset_acct
virtual EXPORT bool VerifyAccount(const OTPseudonym &theNym)
static const std::string & GetOverrideNymID()
bool issueNextTransactionNumber(OTPseudonym &nym, int64_t &txNumber, bool storeNumber=true)
EXPORT bool DeleteBoxReceipt(OTLedger &theLedger)
EXPORT bool SaveContract()
static EXPORT OTAccount * GenerateNewAccount(const OTIdentifier &userId, const OTIdentifier &serverId, const OTPseudonym &serverNym, const OTMessage &message, AccountType acctType=simple, int64_t stashTransNum=0)
static bool __cmd_get_market_list
static bool __cmd_get_outbox
bool verifyTransactionNumber(OTPseudonym &nym, const int64_t &transactionNumber)
EXPORT const OTAsymmetricKey & GetPublicEncrKey() const
static bool __cmd_issue_basket
EXPORT bool SaveContractRaw(OTString &strOutput) const
std::map< std::string, OTClause * > mapOfClauses
void SetPublicKey(const OTString &publicKey)
EXPORT bool LoadSignedNymfile(OTPseudonym &SIGNER_NYM)
EXPORT OTCronItem * GetItemByValidOpeningNum(int64_t lOpeningNum)
EXPORT bool VerifyWithKey(const OTAsymmetricKey &theKey, const OTPasswordData *pPWData=nullptr) const
bool IsMarkedForDeletion() const
bool lookupBasketAccountID(const OTIdentifier &basketId, OTIdentifier &basketAccountId)
EXPORT bool WriteArmoredString(OTString &strOutput, const std::string str_type, bool bEscaped=false) const
static EXPORT const OTString & Contract()
EXPORT const int64_t & GetUsageCredits() const
static EXPORT const OTString & UserAcct()
bool removeTransactionNumber(OTPseudonym &nym, const int64_t &transactionNumber, bool save=false)
EXPORT bool VerifyPseudonym() const
static EXPORT OTItem * CreateItemFromTransaction(const OTTransaction &theOwner, OTItem::itemType theType, const OTIdentifier *pDestinationAcctID=nullptr)
EXPORT bool Exists() const
EXPORT bool SetString(const OTString &theData, bool bLineBreaks=true)
EXPORT std::string EncodeObject(Storable &theContents)
void NotarizeProcessNymbox(OTPseudonym &nym, OTTransaction &tranIn, OTTransaction &tranOut, bool &outSuccess)
static EXPORT void Error(const char *szError)
EXPORT bool SetPublicKey(const OTASCIIArmor &strKey)
static bool __cmd_get_acct
EXPORT void Format(const char *fmt,...)
EXPORT bool LoadPublicKey()
EXPORT bool Compare(const char *compare) const
void NotarizeProcessInbox(OTPseudonym &nym, OTAccount &account, OTTransaction &tranIn, OTTransaction &tranOut, bool &outSuccess)
static bool __cmd_check_server_id
OTNumList m_AcknowledgedReplies
static bool __cmd_get_inbox
EXPORT void Set(const char *data, uint32_t enforcedMaxLength=0)
static bool __cmd_process_nymbox
EXPORT bool GetPublicKey(OTASCIIArmor &strKey) const
bool removeIssuedNumber(OTPseudonym &nym, const int64_t &transactionNumber, bool save=false)
EXPORT bool Output(std::set< int64_t > &theOutput) const
EXPORT bool GetCurrentRequestNum(const OTString &strServerID, int64_t &lReqNum) const
EXPORT void SetUsageCredits(const int64_t &lUsage)
EXPORT bool AddAcknowledgedNum(const OTString &strServerID, const int64_t &lRequestNum)
#define OT_ASSERT_MSG(x, s)
static bool __cmd_del_asset_acct
EXPORT bool RemoveAcknowledgedNum(OTPseudonym &SIGNER_NYM, const OTString &strServerID, const int64_t &lRequestNum, bool bSave)
static EXPORT OTLedger * GenerateLedger(const OTIdentifier &theUserID, const OTIdentifier &theAcctID, const OTIdentifier &theServerID, ledgerType theType, bool bCreateFile=false)
OTASCIIArmor m_ascInReferenceTo
EXPORT bool CompareID(const OTIdentifier &theIdentifier) const
EXPORT int32_t Count() const
static bool __cmd_get_nym_market_offers
bool addAssetContract(OTAssetContract &contract)
EXPORT bool SaveNymbox(OTIdentifier *pNymboxHash=nullptr)
OTAssetContract * getAssetContract(const OTIdentifier &id)
UserCommandProcessor(OTServer *server)
EXPORT const OTAsymmetricKey & GetPublicSignKey() const
static bool __cmd_process_inbox
static bool __cmd_del_user_acct
EXPORT bool SavePseudonym()
EXPORT int32_t GetAcknowledgedNumCount(const OTIdentifier &theServerID) const
static bool __cmd_get_request
EXPORT const char * Get() const
virtual EXPORT bool SignContract(const OTPseudonym &theNym, const OTPasswordData *pPWData=nullptr)
static bool __cmd_get_mint
EXPORT bool GetRecentTradeList(OTASCIIArmor &ascOutput, int32_t &nTradeCount)
EXPORT int64_t GetTransactionNum() const
std::map< std::string, std::string > the_map
OTASCIIArmor m_ascPayload
static bool __cmd_create_user_acct
EXPORT const OTIdentifier & GetConstID() const
static bool __admin_server_locked
EXPORT bool Verify(const int64_t &theValue) const
virtual EXPORT bool VerifyContractID() const
EXPORT int64_t GetAcknowledgedNum(const OTIdentifier &theServerID, int32_t nIndex) const
bool ProcessUserCommand(OTMessage &msgIn, OTMessage &msgOut, ClientConnection *connection, OTPseudonym *nym)
EXPORT Storable * DecodeObject(StoredObjectType theObjectType, std::string strInput)
EXPORT bool GetMarketList(OTASCIIArmor &ascOutput, int32_t &nMarketCount)
static bool __cmd_get_contract
EXPORT bool GetNym_OfferList(OTASCIIArmor &ascOutput, const OTIdentifier &NYM_ID, int32_t &nOfferCount)
void NotarizeTransaction(OTPseudonym &nym, OTTransaction &tranIn, OTTransaction &tranOut, bool &outSuccess)
static bool __cmd_issue_asset
#define OT_ENFORCE_PERMISSION_MSG(BOOL_VAR_NAME)
static bool __cmd_get_nymbox
EXPORT OTMarket * GetMarket(const OTIdentifier &MARKET_ID)
static bool __cmd_get_market_offers
static bool __cmd_notarize_transaction
OTString m_strNymPublicKey
static bool __cmd_get_trans_num
static EXPORT void vOutput(int32_t nVerbosity, const char *szOutput,...)
static EXPORT OTAccount * LoadExistingAccount(const OTIdentifier &accountId, const OTIdentifier &serverId)
static bool __cmd_trigger_clause
virtual EXPORT void Release()
EXPORT bool VerifyAcknowledgedNum(const OTString &strServerID, const int64_t &lRequestNum) const
static bool __cmd_usage_credits
bool addBasketAccountID(const OTIdentifier &basketId, const OTIdentifier &basketAccountId, const OTIdentifier &basketContractId)
static bool __cmd_send_message
EXPORT bool SaveSignedNymfile(OTPseudonym &SIGNER_NYM)
EXPORT void IncrementRequestNum(OTPseudonym &SIGNER_NYM, const OTString &strServerID)
static bool __cmd_get_market_recent_trades