Open-Transactions  0.93.0-ge03d287
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
OTScript.cpp
Go to the documentation of this file.
1 /************************************************************
2  *
3  * OTScript.cpp
4  *
5  */
6 
7 /************************************************************
8  -----BEGIN PGP SIGNED MESSAGE-----
9  Hash: SHA1
10 
11  * OPEN TRANSACTIONS
12  *
13  * Financial Cryptography and Digital Cash
14  * Library, Protocol, API, Server, CLI, GUI
15  *
16  * -- Anonymous Numbered Accounts.
17  * -- Untraceable Digital Cash.
18  * -- Triple-Signed Receipts.
19  * -- Cheques, Vouchers, Transfers, Inboxes.
20  * -- Basket Currencies, Markets, Payment Plans.
21  * -- Signed, XML, Ricardian-style Contracts.
22  * -- Scripted smart contracts.
23  *
24  * Copyright (C) 2010-2013 by "Fellow Traveler" (A pseudonym)
25  *
26  * EMAIL:
28  *
29  * BITCOIN: 1NtTPVVjDsUfDWybS4BwvHpG2pdS9RnYyQ
30  *
31  * KEY FINGERPRINT (PGP Key in license file):
32  * 9DD5 90EB 9292 4B48 0484 7910 0308 00ED F951 BB8E
33  *
34  * OFFICIAL PROJECT WIKI(s):
35  * https://github.com/FellowTraveler/Moneychanger
36  * https://github.com/FellowTraveler/Open-Transactions/wiki
37  *
38  * WEBSITE:
39  * http://www.OpenTransactions.org/
40  *
41  * Components and licensing:
42  * -- Moneychanger..A Java client GUI.....LICENSE:.....GPLv3
43  * -- otlib.........A class library.......LICENSE:...LAGPLv3
44  * -- otapi.........A client API..........LICENSE:...LAGPLv3
45  * -- opentxs/ot....Command-line client...LICENSE:...LAGPLv3
46  * -- otserver......Server Application....LICENSE:....AGPLv3
47  * Github.com/FellowTraveler/Open-Transactions/wiki/Components
48  *
49  * All of the above OT components were designed and written by
50  * Fellow Traveler, with the exception of Moneychanger, which
51  * was contracted out to Vicky C ([email protected]).
52  * The open-source community has since actively contributed.
53  *
54  * -----------------------------------------------------
55  *
56  * LICENSE:
57  * This program is free software: you can redistribute it
58  * and/or modify it under the terms of the GNU Affero
59  * General Public License as published by the Free Software
60  * Foundation, either version 3 of the License, or (at your
61  * option) any later version.
62  *
63  * ADDITIONAL PERMISSION under the GNU Affero GPL version 3
64  * section 7: (This paragraph applies only to the LAGPLv3
65  * components listed above.) If you modify this Program, or
66  * any covered work, by linking or combining it with other
67  * code, such other code is not for that reason alone subject
68  * to any of the requirements of the GNU Affero GPL version 3.
69  * (==> This means if you are only using the OT API, then you
70  * don't have to open-source your code--only your changes to
71  * Open-Transactions itself must be open source. Similar to
72  * LGPLv3, except it applies to software-as-a-service, not
73  * just to distributing binaries.)
74  *
75  * Extra WAIVER for OpenSSL, Lucre, and all other libraries
76  * used by Open Transactions: This program is released under
77  * the AGPL with the additional exemption that compiling,
78  * linking, and/or using OpenSSL is allowed. The same is true
79  * for any other open source libraries included in this
80  * project: complete waiver from the AGPL is hereby granted to
81  * compile, link, and/or use them with Open-Transactions,
82  * according to their own terms, as long as the rest of the
83  * Open-Transactions terms remain respected, with regard to
84  * the Open-Transactions code itself.
85  *
86  * Lucre License:
87  * This code is also "dual-license", meaning that Ben Lau-
88  * rie's license must also be included and respected, since
89  * the code for Lucre is also included with Open Transactions.
90  * See Open-Transactions/src/otlib/lucre/LUCRE_LICENSE.txt
91  * The Laurie requirements are light, but if there is any
92  * problem with his license, simply remove the Lucre code.
93  * Although there are no other blind token algorithms in Open
94  * Transactions (yet. credlib is coming), the other functions
95  * will continue to operate.
96  * See Lucre on Github: https://github.com/benlaurie/lucre
97  * -----------------------------------------------------
98  * You should have received a copy of the GNU Affero General
99  * Public License along with this program. If not, see:
100  * http://www.gnu.org/licenses/
101  *
102  * If you would like to use this software outside of the free
103  * software license, please contact FellowTraveler.
104  * (Unfortunately many will run anonymously and untraceably,
105  * so who could really stop them?)
106  *
107  * DISCLAIMER:
108  * This program is distributed in the hope that it will be
109  * useful, but WITHOUT ANY WARRANTY; without even the implied
110  * warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
111  * PURPOSE. See the GNU Affero General Public License for
112  * more details.
113 
114  -----BEGIN PGP SIGNATURE-----
115  Version: GnuPG v1.4.9 (Darwin)
116 
117  iQIcBAEBAgAGBQJRSsfJAAoJEAMIAO35UbuOQT8P/RJbka8etf7wbxdHQNAY+2cC
118  vDf8J3X8VI+pwMqv6wgTVy17venMZJa4I4ikXD/MRyWV1XbTG0mBXk/7AZk7Rexk
119  KTvL/U1kWiez6+8XXLye+k2JNM6v7eej8xMrqEcO0ZArh/DsLoIn1y8p8qjBI7+m
120  aE7lhstDiD0z8mwRRLKFLN2IH5rAFaZZUvj5ERJaoYUKdn4c+RcQVei2YOl4T0FU
121  LWND3YLoH8naqJXkaOKEN4UfJINCwxhe5Ke9wyfLWLUO7NamRkWD2T7CJ0xocnD1
122  sjAzlVGNgaFDRflfIF4QhBx1Ddl6wwhJfw+d08bjqblSq8aXDkmFA7HeunSFKkdn
123  oIEOEgyj+veuOMRJC5pnBJ9vV+7qRdDKQWaCKotynt4sWJDGQ9kWGWm74SsNaduN
124  TPMyr9kNmGsfR69Q2Zq/FLcLX/j8ESxU+HYUB4vaARw2xEOu2xwDDv6jt0j3Vqsg
125  x7rWv4S/Eh18FDNDkVRChiNoOIilLYLL6c38uMf1pnItBuxP3uhgY6COm59kVaRh
126  nyGTYCDYD2TK+fI9o89F1297uDCwEJ62U0Q7iTDp5QuXCoxkPfv8/kX6lS6T3y9G
127  M9mqIoLbIQ1EDntFv7/t6fUTS2+46uCrdZWbQ5RjYXdrzjij02nDmJAm2BngnZvd
128  kamH0Y/n11lCvo1oQxM+
129  =uSzz
130  -----END PGP SIGNATURE-----
131  **************************************************************/
132 
133 #include "stdafx.hpp"
134 
135 #include "OTScript.hpp"
136 
137 #include "OTLog.hpp"
138 #include "OTParty.hpp"
139 #include "OTVariable.hpp"
140 
141 #ifdef OT_USE_SCRIPT_CHAI
142 #include "OTScriptChai.hpp"
143 #endif
144 
145 namespace opentxs
146 {
147 
148 // A script should be "Dumb", meaning that you just stick it with its
149 // parties and other resources, and it EXPECTS them to be the correct
150 // ones. It uses them low-level style.
151 //
152 // Any verification should be done at a higher level, in OTSmartContract.
153 // There, multiple parties might be loaded, as well as multiple scripts
154 // (clauses) and that is where the proper resources, accounts, etc are
155 // instantiated and validated before any use.
156 //
157 // Thus by the time you get down to OTScript, all that validation is already
158 // done. The programmatic user will interact with OTSmartContract, likely,
159 // and not with OTScript itself.
160 //
161 
162 // Note: any relevant assets or asset accounts are listed by their owner /
163 // contributor
164 // parties. Therefore there's no need to separately input any accounts or assets
165 // to
166 // a script, since the necessary ones are already present inside their
167 // respective parties.
168 //
169 // bool OTScript::ExecuteScript()
170 //{
171 // return true;
172 //}
173 
174 /*
175 
176  To use:
177 
178  const char * default_script_language = "chai";
179 
180  ...
181 
182  OTParty theParty(theNym);
183 
184  // (Set up theParty here, with his asset accounts, etc)
185  // Then...
186  //
187  std::shared_ptr<OTScript> pScript = OTScript::Factory(default_script_language,
188  strScript);
189 
190  if (pScript)
191  {
192  pScript->AddParty("mynym", &theParty);
193  pScript->Execute();
194  }
195 
196 
197  MIGHT WANT TO ADD an AddParty(string, Nym) function, which automatically wraps
198  the Nym in a party.
199  That way you can basically treat a Nym like a party to an agreement.
200 
201  */
202 
203 std::shared_ptr<OTScript> OTScriptFactory(const std::string& script_type)
204 {
205 
206 #ifdef OT_USE_SCRIPT_CHAI
207  // default or explicit chai script interpreter
208  if (script_type == "" || script_type == "chai") // todo no hardcoding.
209  {
210  std::shared_ptr<OTScript> pChaiScript(new OTScriptChai);
211  return pChaiScript;
212  }
213 
214 //#elif OT_USE_SCRIPT_LUA
215 // if (script_type =="lua") // todo no hardcoding.
216 // {
217 // std::shared_ptr<OTScript> pLuaScript(new OTScriptLua);
218 // return pLuaScript;
219 // }
220 
221 #else
222  // default no script interpreter
223  if (script_type == "") {
224  otErr << "\n\n WARNING 1: script_type == noscript. \n\n";
225 
226  std::shared_ptr<OTScript> pNoScript(new OTScript);
227  return pNoScript;
228  }
229 #endif
230 
231  otErr << __FUNCTION__ << ": Script language (" << script_type
232  << ") not found.\n";
233 
234  std::shared_ptr<OTScript> retVal;
235  return retVal;
236 }
237 
238 std::shared_ptr<OTScript> OTScriptFactory(const std::string& script_type,
239  const std::string& script_contents)
240 {
241 
242 #ifdef OT_USE_SCRIPT_CHAI
243  // default or explicit chai script interpreter
244  if (script_type == "" || script_type == "chai") // todo no hardcoding.
245  {
246  std::shared_ptr<OTScript> pChaiScript(
247  new OTScriptChai(script_contents));
248  return pChaiScript;
249  }
250 
251 //#elif OT_USE_SCRIPT_LUA
252 // if (script_type =="lua") // todo no hardcoding.
253 // {
254 // std::shared_ptr<OTScript> pLuaScript(new OTScriptLua(script_contents));
255 // return pLuaScript;
256 // }
257 
258 #else
259  // default no script interpreter
260  if (script_type == "") {
261  otErr << "\n\n WARNING 2: script_type == noscript. \n\n";
262 
263  std::shared_ptr<OTScript> pNoScript(new OTScript);
264  return pNoScript;
265  }
266 #endif
267 
268  otErr << __FUNCTION__ << ": Script language (" << script_type
269  << ") not found.\n";
270 
271  std::shared_ptr<OTScript> retVal;
272  return retVal;
273 }
274 
276 {
277 }
278 
279 OTScript::OTScript(const OTString& strValue)
280  : m_str_script(strValue.Get())
281 {
282 }
283 
284 OTScript::OTScript(const char* new_string)
285  : m_str_script(new_string)
286 {
287 }
288 
289 OTScript::OTScript(const char* new_string, size_t sizeLength)
290  : m_str_script(new_string, sizeLength)
291 {
292 }
293 
294 OTScript::OTScript(const std::string& new_string)
295  : m_str_script(new_string)
296 {
297 }
298 
300 {
301  // mapOfParties; // NO NEED to clean this up, since OTScript doesn't own the
302  // parties.
303  // See OTSmartContract, rather, for that.
304 
305  while (!m_mapVariables.empty()) {
306  OTVariable* pVar = m_mapVariables.begin()->second;
307  OT_ASSERT(nullptr != pVar);
308 
309  // NOTE: We're NOT going to delete pVar, since we don't own it.
310  // But we ARE going to remove pVar's pointer to this script, so
311  // pVar doesn't dereference a bad pointer later on.
312  //
313  pVar->UnregisterScript();
314  m_mapVariables.erase(m_mapVariables.begin());
315  }
316 }
317 
318 void OTScript::SetScript(const OTString& strValue)
319 {
320  if (strValue.Exists()) m_str_script = strValue.Get();
321 }
322 
323 void OTScript::SetScript(const char* new_string)
324 {
325  if (nullptr != new_string) m_str_script = new_string;
326 }
327 
328 void OTScript::SetScript(const char* new_string, size_t sizeLength)
329 {
330  if (nullptr != new_string) m_str_script.assign(new_string, sizeLength);
331 }
332 
333 void OTScript::SetScript(const std::string& new_string)
334 {
335  m_str_script = new_string;
336 }
337 
338 // The same OTSmartContract that loads all the clauses (scripts) will
339 // also load all the parties, so it will call this function whenever before it
340 // needs to actually run a script.
341 //
342 // NOTE: OTScript does NOT take ownership of the party, since there could be
343 // multiple scripts (with all scripts and parties being owned by a
344 // OTSmartContract.)
345 // Therefore it's ASSUMED that the owner OTSmartContract will handle all the
346 // work of
347 // cleaning up the mess! theParty is passed as reference to insure it already
348 // exists.
349 //
350 void OTScript::AddParty(std::string str_party_name, OTParty& theParty)
351 {
352  // typedef std::map<std::string, OTParty *> mapOfParties;
353 
354  m_mapParties.insert(
355  std::pair<std::string, OTParty*>(str_party_name, &theParty));
356  // We're just storing these pointers for reference value. Script doesn't
357  // actually Own the
358  // parties, and isn't responsible to clean them up.
359 
360  theParty.RegisterAccountsForExecution(*this);
361 }
362 
363 void OTScript::AddAccount(std::string str_acct_name, OTPartyAccount& theAcct)
364 {
365  m_mapAccounts.insert(
366  std::pair<std::string, OTPartyAccount*>(str_acct_name, &theAcct));
367 
368  // We're just storing these pointers for reference value. Script doesn't
369  // actually Own the
370  // accounts, and isn't responsible to clean them up.
371 }
372 
373 // If you want to add a variable to a script, you should probably call
374 // OTVariable::RegisterForExecution
375 // so that later if the variable destructs, it will have a pointer to the script
376 // and it can remove itself
377 // from the script's list of variables. (Instead of calling this function, which
378 // is lower-level.)
379 //
380 void OTScript::AddVariable(std::string str_var_name, OTVariable& theVar)
381 {
382  // mapOfVariables m_mapVariables;
383 
384  m_mapVariables.insert(
385  std::pair<std::string, OTVariable*>(str_var_name, &theVar));
386 
387  // We're just storing these pointers for reference value. Script doesn't
388  // actually Own the
389  // variables, and isn't responsible to clean them up.
390 }
391 
392 OTVariable* OTScript::FindVariable(std::string str_var_name)
393 {
394  auto it_var = m_mapVariables.find(str_var_name);
395  return it_var != m_mapVariables.end() ? it_var->second : nullptr;
396 }
397 
398 // If a variable is set onto a script, it sets an internal pointer to that
399 // script.
400 // Later, when the variable destructs, if that pointer is set, it removes itself
401 // from the script by calling this function. (Yes, this would be better with
402 // smart
403 // pointers. C++11 here we come!)
404 //
406 {
407  const std::string str_var_name = theVar.GetName().Get();
408  auto it_var = m_mapVariables.find(str_var_name);
409 
410  if (it_var != m_mapVariables.end()) {
411  m_mapVariables.erase(it_var); // no need to delete the variable pointer
412  // since the script doesn't own it anyway.
413  }
414 }
415 
417 {
418  otErr << "OTScript::ExecuteScript: Scripting has been disabled.\n";
419  return true;
420 }
421 
422 } // namespace opentxs
EXPORT void RemoveVariable(OTVariable &theVar)
Definition: OTScript.cpp:405
void AddParty(std::string str_party_name, OTParty &theParty)
Definition: OTScript.cpp:350
mapOfParties m_mapParties
Definition: OTScript.hpp:180
EXPORT OTVariable * FindVariable(std::string str_var_name)
Definition: OTScript.cpp:392
EXPORT void UnregisterScript()
Definition: OTVariable.cpp:416
void RegisterAccountsForExecution(OTScript &theScript)
Definition: OTParty.cpp:1779
EXPORT bool Exists() const
Definition: OTString.cpp:1035
EXPORT const OTString & GetName() const
Definition: OTVariable.hpp:220
void AddAccount(std::string str_acct_name, OTPartyAccount &theAcct)
Definition: OTScript.cpp:363
virtual ~OTScript()
Definition: OTScript.cpp:299
#define OT_ASSERT(x)
Definition: Assert.hpp:150
std::string m_str_script
Definition: OTScript.hpp:177
EXPORT void SetScript(const OTString &strValue)
Definition: OTScript.cpp:318
EXPORT const char * Get() const
Definition: OTString.cpp:1045
OTLOG_IMPORT OTLogStream otErr
EXPORT void AddVariable(std::string str_var_name, OTVariable &theVar)
Definition: OTScript.cpp:380
mapOfPartyAccounts m_mapAccounts
Definition: OTScript.hpp:182
mapOfVariables m_mapVariables
Definition: OTScript.hpp:185
EXPORT std::shared_ptr< OTScript > OTScriptFactory(const std::string &script_type="")
Definition: OTScript.cpp:203
virtual bool ExecuteScript(OTVariable *pReturnVar=nullptr)
Definition: OTScript.cpp:416