void OT_API_issueAssetType(const char * SERVER_ID, const char * USER_ID, const char * THE_CONTRACT) { OT_ASSERT(NULL != SERVER_ID); OT_ASSERT(NULL != USER_ID); OT_ASSERT(NULL != THE_CONTRACT); OTIdentifier theServerID(SERVER_ID), theUserID(USER_ID); OTString strContract(THE_CONTRACT); g_OT_API.issueAssetType(theServerID, theUserID, strContract); }
// static -- class factory. // OTTransactionType * OTTransactionType::TransactionFactory(const OTString & strInput) { static char buf[45] = ""; OTTransactionType * pItem = NULL; if (!strInput.Exists()) return NULL; // -------------------------------------------------------------------- // // To support legacy data, we check here to see if it's armored or not. // If it's not, we support it. But if it IS, we ALSO support it (we de-armor it here.) // bool bArmoredAndALSOescaped = false; // "- -----BEGIN OT ARMORED" bool bArmoredButNOTescaped = false; // "-----BEGIN OT ARMORED" if (strInput.Contains(OT_BEGIN_ARMORED_escaped)) // check this one first... { bArmoredAndALSOescaped = true; OTLog::Error("OTTransactionType::TransactionFactory: Armored and escaped value passed in, " "but escaped are forbidden here. (Returning NULL.)\n"); return NULL; } else if (strInput.Contains(OT_BEGIN_ARMORED)) { bArmoredButNOTescaped = true; } // ---------------------------------------- const bool bArmored = (bArmoredAndALSOescaped || bArmoredButNOTescaped); // ---------------------------------------- // Whether the string is armored or not, (-----BEGIN OT ARMORED) // either way, we'll end up with the decoded version in this variable: // std::string str_Trim; // ------------------------------------------------ if (bArmored) // it's armored, we have to decode it first. { OTASCIIArmor ascTemp; OTString strInputTemp(strInput); if (false == (ascTemp.LoadFromString(strInputTemp, bArmoredAndALSOescaped, // if it IS escaped or not, this variable will be true or false to show it. // The below szOverride sub-string determines where the content starts, when loading. OT_BEGIN_ARMORED))) // Default is: "-----BEGIN" // We're doing this: "-----BEGIN OT ARMORED" (Should worked for escaped as well, here.) { OTLog::vError("OTTransactionType::TransactionFactory: Error " "loading string contents from ascii-armored encoding. Contents: \n%s\n", strInput.Get()); return NULL; } else // success loading the actual contents out of the ascii-armored version. { OTString strTemp(ascTemp); // <=== ascii-decoded here. std::string str_temp(strTemp.Get(), strTemp.GetLength()); str_Trim = OTString::trim(str_temp); // This is the std::string for the trim process. } } else { std::string str_temp(strInput.Get(), strInput.GetLength()); str_Trim = OTString::trim(str_temp); // This is the std::string for the trim process. (Wasn't armored, so here we use it as passed in.) } // ------------------------------------------------ // At this point, str_Trim contains the actual contents, whether they // were originally ascii-armored OR NOT. (And they are also now trimmed, either way.) // ------------------------------------------ OTString strContract(str_Trim.c_str()); strContract.reset(); // for sgets buf[0] = 0; // probably unnecessary. bool bGotLine = strContract.sgets(buf, 40); if (!bGotLine) return NULL; OTString strFirstLine(buf); strContract.reset(); // set the "file" pointer within this string back to index 0. // Now I feel pretty safe -- the string I'm examining is within // the first 45 characters of the beginning of the contract, and // it will NOT contain the escape "- " sequence. From there, if // it contains the proper sequence, I will instantiate that type. if (!strFirstLine.Exists() || strFirstLine.Contains("- -")) return NULL; if (strFirstLine.Contains("-----BEGIN SIGNED TRANSACTION-----")) // this string is 34 chars long. { pItem = new OTTransaction(); OT_ASSERT(NULL != pItem); } else if (strFirstLine.Contains("-----BEGIN SIGNED TRANSACTION ITEM-----")) // this string is 39 chars long. { pItem = new OTItem(); OT_ASSERT(NULL != pItem); } else if (strFirstLine.Contains("-----BEGIN SIGNED LEDGER-----")) // this string is 29 chars long. { pItem = new OTLedger(); OT_ASSERT(NULL != pItem); } else if (strFirstLine.Contains("-----BEGIN SIGNED ACCOUNT-----")) // this string is 30 chars long. { pItem = new OTAccount(); OT_ASSERT(NULL != pItem); } // The string didn't match any of the options in the factory. if (NULL == pItem) return NULL; // This causes pItem to load ASSUMING that the PurportedAcctID and PurportedServerID are correct. // The object is still expected to be internally consistent with its sub-items, regarding those IDs, // but the big difference is that it will SET the Real Acct and Real Server IDs based on the purported // values. This way you can load a transaction without knowing the account in advance. // pItem->m_bLoadSecurely = false; // OTLog::Error("\n\nTESTING DEBUGGING LOL LOL LOL LOL \n\n\n"); // Does the contract successfully load from the string passed in? if (pItem->LoadContractFromString(strContract)) { // NOTE: this already happens in OTTransaction::ProcessXMLNode and OTLedger::ProcessXMLNode. // Specifically, it happens when m_bLoadSecurely is set to false. // // pItem->SetRealServerID(pItem->GetPurportedServerID()); // pItem->SetRealAccountID(pItem->GetPurportedAccountID()); // return pItem; } else delete pItem; return NULL; }