Open-Transactions  0.93.0-ge03d287
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
OTAgent.hpp
Go to the documentation of this file.
1 /************************************************************
2  *
3  * OTAgent.hpp
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 #ifndef OPENTXS_CORE_SCRIPT_OTAGENT_HPP
134 #define OPENTXS_CORE_SCRIPT_OTAGENT_HPP
135 
136 #include "../OTString.hpp"
137 #include <map>
138 
139 namespace opentxs
140 {
141 
142 class OTAccount;
143 class OTAgent;
144 class OTIdentifier;
145 class OTParty;
146 class OTPartyAccount;
147 class OTPseudonym;
148 class OTSmartContract;
149 
150 typedef std::map<std::string, OTPseudonym*> mapOfNyms;
151 
152 // Agent is always either the Owner Nym acting in his own interests,
153 // or is an employee Nym acting actively in a role on behalf of an Entity formed
154 // by contract
155 // or is a voting group acting passively in a role on behalf of an Entity formed
156 // by contract
157 //
158 // QUESTION: What about having an agent being one Nym representing another?
159 // NO: because then he needs a ROLE in order to act as agent. In which case, the
160 // other
161 // nym should just create an entity he controls, and make the first nym an agent
162 // for that entity.
163 //
164 class OTAgent
165 {
166 private:
167  bool m_bNymRepresentsSelf; // Whether this agent represents himself (a nym)
168  // or whether he represents an entity of some
169  // sort.
170  bool m_bIsAnIndividual; // Whether this agent is a voting group or Nym
171  // (whether Nym acting for himself or for some
172  // entity.)
173 
174  // If agent is active (has a nym), here is the sometimes-available pointer
175  // to said Agent Nym.
176  OTPseudonym* m_pNym; // this pointer is not owned by this object, and is
177  // here for convenience only.
178  // someday may add a "role" pointer here.
179 
180  OTParty* m_pForParty; // The agent probably has a pointer to the party it
181  // acts on behalf of.
182 
183  /*
184  <Agent type=“group”// could be “nym”, or “role”, or “group”.
185  Nym_id=“” // In case of “nym”, this is the Nym’s ID. If “role”, this
186  is NymID of employee in role.
187  Role_id=“” // In case of “role”, this is the Role’s ID.
188  Entity_id=“this” // same as OwnerID if ever used. Should remove.
189  Group_Name=“class_A” // “class A shareholders” are the voting group
190  that controls this agent.
191  */
192 
193  OTString m_strName; // agent name (accessible within script language.)
194 
195  // info about agent.
196  //
197  OTString m_strNymID; // If agent is a Nym, then this is the NymID of that
198  // Nym (whether that Nym is owner or not.)
199  // If agent is a group (IsAGroup()) then this will be blank. This is
200  // different than the
201  // Nym stored in OTParty, which if present ALWAYS refers to the OWNER Nym
202  // (Though this Nym
203  // MAY ALSO be the owner, that fact is purely incidental here AND this NymID
204  // could be blank.)
205  OTString m_strRoleID; // If agent is Nym working in a role on behalf of an
206  // entity, then this is its RoleID in Entity.
207  OTString m_strGroupName; // If agent is a voting group in an Entity, this is
208  // group's Name (inside Entity.)
209 
210 public:
211  OTAgent();
212  OTAgent(std::string str_agent_name, OTPseudonym& theNym,
213  bool bNymRepresentsSelf = true);
214  /*IF false, then: ENTITY and ROLE parameters go here.*/
215  //
216  // Someday another constructor here like the above, for
217  // instantiating with an Entity/Group instead of with a Nym.
218 
219  OTAgent(bool bNymRepresentsSelf, bool bIsAnIndividual,
220  const OTString& strName, const OTString& strNymID,
221  const OTString& strRoleID, const OTString& strGroupName);
222 
223  virtual ~OTAgent();
224 
225  void Serialize(OTString& strAppend) const;
226 
227  // For pointers I don't own, but store for convenience.
228  // This clears them once we're done processing, so I don't
229  // end up stuck with bad pointers on the next go-around.
230  //
232  {
233  m_pNym = nullptr;
234  } /* Someday clear entity/role ptr here? And do NOT
235  clear party ptr here (since it's not temporary.) */
236  // NOTE: Current iteration, these functions ASSUME that m_pNym is loaded.
237  // They will definitely fail if you haven't already loaded the Nym.
238  //
239  bool VerifyIssuedNumber(const int64_t& lNumber,
240  const OTString& strServerID);
241  bool VerifyTransactionNumber(const int64_t& lNumber,
242  const OTString& strServerID);
243 
244  bool RemoveIssuedNumber(const int64_t& lNumber, const OTString& strServerID,
245  bool bSave = false,
246  OTPseudonym* pSignerNym = nullptr);
247  bool RemoveTransactionNumber(const int64_t& lNumber,
248  const OTString& strServerID,
249  OTPseudonym& SIGNER_NYM, bool bSave = true);
250 
252  const int64_t& lNumber, const OTString& strServerID,
253  bool bSave = false, // Each agent's nym is used if pSignerNym is
254  // nullptr,
255  // whereas the server
256  OTPseudonym* pSignerNym = nullptr); // uses this optional arg to
257  // substitute serverNym as signer.
258 
259  bool ReserveOpeningTransNum(const OTString& strServerID);
260  bool ReserveClosingTransNum(const OTString& strServerID,
261  OTPartyAccount& thePartyAcct);
262  EXPORT bool SignContract(OTContract& theInput) const;
263 
264  // Verify that this agent somehow has legitimate agency over this account.
265  // (According to the account.)
266  //
267  bool VerifyAgencyOfAccount(const OTAccount& theAccount) const;
268  bool VerifySignature(const OTContract& theContract) const; // Have the agent
269  // try
270  // to
271  // verify his own signature
272  // against any contract.
273 
274  void SetParty(OTParty& theOwnerParty); // This happens when the agent is
275  // added to the party.
276 
278  {
279  m_pNym = &theNym;
280  }
281 
282  EXPORT bool IsValidSigner(OTPseudonym& theNym);
283  EXPORT bool IsValidSignerID(const OTIdentifier& theNymID);
284 
285  bool IsAuthorizingAgentForParty(); // true/false whether THIS agent is the
286  // authorizing agent for his party.
287  int32_t GetCountAuthorizedAccts(); // The number of accounts, owned by this
288  // agent's party, that this agent is the
289  // authorized agent FOR.
290 
291  // Only one of these can be true:
292  // (I wrestle with making these 2 calls private, since technically it should
293  // be irrelevant to the external.)
294  //
295  bool DoesRepresentHimself() const; // If the agent is a Nym acting for
296  // himself, this will be true. Otherwise,
297  // if agent is a Nym acting in a role for
298  // an entity, or if agent is a voting
299  // group acting for the entity to which
300  // it belongs, either way, this will be
301  // false.
302  // ** OR **
303  bool DoesRepresentAnEntity() const; // Whether the agent is a voting group
304  // acting for an entity, or is a Nym
305  // acting in a Role for an entity, this
306  // will be true either way. (Otherwise,
307  // if agent is a Nym acting for himself,
308  // then this will be false.)
309 
310  // Only one of these can be true:
311  // - Agent is either a Nym acting for himself or some entity,
312  // - or agent is a group acting for some entity.
313 
314  EXPORT bool IsAnIndividual() const; // Agent is an individual Nym. (Meaning
315  // either he IS ALSO the party and thus
316  // represents himself, OR he is an agent
317  // for an entity who is the party, and
318  // he's acting in a role for that
319  // entity.) If agent were a group, this
320  // would be false.
321  // ** OR **
322  bool IsAGroup() const; // OR: Agent is a voting group, which cannot take
323  // proactive or instant action, but only passive and
324  // delayed. Entity-ONLY. (A voting group cannot
325  // decide on behalf of individual, but only on behalf
326  // of the entity it belongs to.)
327 
328  // FYI: A Nym cannot act as agent for another Nym.
329  // Nor can a Group act as agent for a Nym.
330  //
331  // If you want those things, then the owner Nym should form an Entity, and
332  // then groups and nyms can act as agents for that entity. You cannot have
333  // an agent without an entity formed by contract, since you otherwise have
334  // no agency agreement.
335 
336  // For when the agent is an individual:
337  //
338  EXPORT bool GetNymID(OTIdentifier& theOutput) const; // If IsIndividual(),
339  // then this is his own
340  // personal NymID,
341  // (whether he DoesRepresentHimself() or DoesRepresentAnEntity()
342  // -- either way). Otherwise if IsGroup(), this returns false.
343 
344  bool GetRoleID(OTIdentifier& theOutput) const; // IF IsIndividual() AND
345  // DoesRepresentAnEntity(),
346  // then this is his RoleID
347  // within that Entity.
348  // Otherwise, if IsGroup() or
349  // DoesRepresentHimself(),
350  // then this returns false.
351 
352  // Notice if the agent is a voting group, then it has no signer. (Instead it
353  // will have an election.)
354  // That is why certain agents are unacceptable in certain scripts.
355  // There is an "active" agent who has a signerID, but there is also a
356  // "passive" agent who only has
357  // a group name, and acts based on notifications and replies in the
358  // long-term, versus being immediately
359  // able to act as part of the operation of a script.
360  // Basically if !IsIndividual(), then GetSignerID() will fail and thus
361  // anything needing it as part of the
362  // script would also therefore be impossible.
363  //
364  bool GetSignerID(OTIdentifier& theOutput) const;
365  // If IsIndividual() and DoesRepresentAnEntity() then this returns
366  // GetRoleID().
367  // else if Individual() and DoesRepresentHimself() then this returns
368  // GetNymID().
369  // else (if IsGroup()) then return false;
370 
371  // For when the agent DoesRepresentAnEntity():
372  //
373  // Whether this agent IsGroup() (meaning he is a voting group that
374  // DoesRepresentAnEntity()),
375  // OR whether this agent is an individual acting in a role for an entity
376  // (IsIndividual() && DoesRepresentAnEntity())
377  // ...EITHER WAY, the agent DoesRepresentAnEntity(), and this function
378  // returns the ID of that Entity.
379  //
380  // Otherwise, if the agent DoesRepresentHimself(), then this returns false.
381  // I'm debating making this function private along with DoesRepresentHimself
382  // / DoesRepresentAnEntity().
383  //
384  bool GetEntityID(OTIdentifier& theOutput) const; // IF represents an entity,
385  // this is its ID. Else
386  // fail.
387 
388  EXPORT const OTString& GetName()
389  {
390  return m_strName;
391  } // agent's name as used in a script.
392  // For when the agent is a voting group:
393  //
394  bool GetGroupName(OTString& strGroupName); // The GroupName group will be
395  // found in the EntityID entity.
396  //
397  // If !IsGroup() aka IsIndividual(), then this will return false.
398  //
399 
400  // bool DoesRepresentHimself();
401  // bool DoesRepresentAnEntity();
402  //
403  // bool IsIndividual();
404  // bool IsGroup();
405 
406  // PARTY is either a NYM or an ENTITY. This returns ID for that Nym or
407  // Entity.
408  //
409  // If DoesRepresentHimself() then return GetNymID()
410  // else (thus DoesRepresentAnEntity()) so return GetEntityID()
411  //
412  bool GetPartyID(OTIdentifier& theOutput) const;
413 
414  OTParty* GetParty() const
415  {
416  return m_pForParty;
417  }
418 
419  // IDEA: Put a Nym in the Nyms folder for each entity. While it may
420  // not have a public key in the pubkey folder, or embedded within it,
421  // it can still have information about the entity or role related to it,
422  // which becomes accessible when that Nym is loaded based on the Entity ID.
423  // This also makes sure that Nyms and Entities don't ever share IDs, so the
424  // IDs become more and more interchangeable.
425 
426  // Often we endeavor to avoid loading the same Nym twice, and a higher-level
427  // function
428  // will ask an OTParty for a list of all the Nym pointers that it already
429  // has,
430  // so they can be checked for various things if they are already loaded
431  // (when they are needed)
432  // without having to load them again in order to check those things, purely
433  // out of blindness
434  // to the fact that they had infact already been loaded and were floating
435  // around in memory somewhere.
436  //
437  void RetrieveNymPointer(mapOfNyms& map_Nyms_Already_Loaded);
438 
439  OTPseudonym* LoadNym(OTPseudonym& theServerNym);
440 
441  bool DropFinalReceiptToNymbox(OTSmartContract& theSmartContract,
442  const int64_t& lNewTransactionNumber,
443  const OTString& strOrigCronItem,
444  OTString* pstrNote = nullptr,
445  OTString* pstrAttachment = nullptr,
446  OTPseudonym* pActualNym = nullptr);
447 
449  mapOfNyms* pNymMap, const OTString& strServerID,
450  OTPseudonym& theServerNym, OTSmartContract& theSmartContract,
451  const OTIdentifier& theAccountID, const int64_t& lNewTransactionNumber,
452  const int64_t& lClosingNumber, const OTString& strOrigCronItem,
453  OTString* pstrNote = nullptr, OTString* pstrAttachment = nullptr);
454 
456  bool bSuccessMsg, // the notice can be "acknowledgment" or "rejection"
457  OTPseudonym& theServerNym, const OTIdentifier& theServerID,
458  const int64_t& lNewTransactionNumber, const int64_t& lInReferenceTo,
459  const OTString& strReference, OTString* pstrNote = nullptr,
460  OTString* pstrAttachment = nullptr, OTPseudonym* pActualNym = nullptr);
461 };
462 
463 } // namespace opentxs
464 
465 #endif // OPENTXS_CORE_SCRIPT_OTAGENT_HPP
void RetrieveNymPointer(mapOfNyms &map_Nyms_Already_Loaded)
Definition: OTAgent.cpp:670
bool DropServerNoticeToNymbox(bool bSuccessMsg, OTPseudonym &theServerNym, const OTIdentifier &theServerID, const int64_t &lNewTransactionNumber, const int64_t &lInReferenceTo, const OTString &strReference, OTString *pstrNote=nullptr, OTString *pstrAttachment=nullptr, OTPseudonym *pActualNym=nullptr)
Definition: OTAgent.cpp:842
bool DoesRepresentAnEntity() const
Definition: OTAgent.cpp:375
void ClearTemporaryPointers()
Definition: OTAgent.hpp:231
bool ReserveOpeningTransNum(const OTString &strServerID)
Definition: OTAgent.cpp:1155
bool VerifySignature(const OTContract &theContract) const
Definition: OTAgent.cpp:159
EXPORT bool GetNymID(OTIdentifier &theOutput) const
Definition: OTAgent.cpp:473
void SetNymPointer(OTPseudonym &theNym)
Definition: OTAgent.hpp:277
bool IsAGroup() const
Definition: OTAgent.cpp:399
int32_t GetCountAuthorizedAccts()
Definition: OTAgent.cpp:636
bool ReserveClosingTransNum(const OTString &strServerID, OTPartyAccount &thePartyAcct)
Definition: OTAgent.cpp:1102
bool GetSignerID(OTIdentifier &theOutput) const
Definition: OTAgent.cpp:514
bool GetRoleID(OTIdentifier &theOutput) const
Definition: OTAgent.cpp:488
OTPseudonym * LoadNym(OTPseudonym &theServerNym)
Definition: OTAgent.cpp:224
bool VerifyTransactionNumber(const int64_t &lNumber, const OTString &strServerID)
Definition: OTAgent.cpp:911
std::map< std::string, OTPseudonym * > mapOfNyms
Definition: OTWallet.hpp:161
EXPORT bool IsValidSignerID(const OTIdentifier &theNymID)
Definition: OTAgent.cpp:537
bool RemoveIssuedNumber(const int64_t &lNumber, const OTString &strServerID, bool bSave=false, OTPseudonym *pSignerNym=nullptr)
Definition: OTAgent.cpp:1051
EXPORT bool SignContract(OTContract &theInput) const
Definition: OTAgent.cpp:875
bool GetEntityID(OTIdentifier &theOutput) const
Definition: OTAgent.cpp:601
EXPORT bool IsValidSigner(OTPseudonym &theNym)
Definition: OTAgent.cpp:553
EXPORT const OTString & GetName()
Definition: OTAgent.hpp:388
bool VerifyIssuedNumber(const int64_t &lNumber, const OTString &strServerID)
Definition: OTAgent.cpp:892
bool DropFinalReceiptToInbox(mapOfNyms *pNymMap, const OTString &strServerID, OTPseudonym &theServerNym, OTSmartContract &theSmartContract, const OTIdentifier &theAccountID, const int64_t &lNewTransactionNumber, const int64_t &lClosingNumber, const OTString &strOrigCronItem, OTString *pstrNote=nullptr, OTString *pstrAttachment=nullptr)
Definition: OTAgent.cpp:717
bool GetGroupName(OTString &strGroupName)
Definition: OTAgent.cpp:650
bool HarvestTransactionNumber(const int64_t &lNumber, const OTString &strServerID, bool bSave=false, OTPseudonym *pSignerNym=nullptr)
Definition: OTAgent.cpp:933
bool DoesRepresentHimself() const
Definition: OTAgent.cpp:365
bool DropFinalReceiptToNymbox(OTSmartContract &theSmartContract, const int64_t &lNewTransactionNumber, const OTString &strOrigCronItem, OTString *pstrNote=nullptr, OTString *pstrAttachment=nullptr, OTPseudonym *pActualNym=nullptr)
Definition: OTAgent.cpp:810
EXPORT bool IsAnIndividual() const
Definition: OTAgent.cpp:390
bool GetPartyID(OTIdentifier &theOutput) const
Definition: OTAgent.cpp:663
void SetParty(OTParty &theOwnerParty)
Definition: OTAgent.cpp:314
bool VerifyAgencyOfAccount(const OTAccount &theAccount) const
Definition: OTAgent.cpp:699
void Serialize(OTString &strAppend) const
Definition: OTAgent.cpp:1211
bool RemoveTransactionNumber(const int64_t &lNumber, const OTString &strServerID, OTPseudonym &SIGNER_NYM, bool bSave=true)
Definition: OTAgent.cpp:1006
virtual ~OTAgent()
Definition: OTAgent.cpp:351
OTParty * GetParty() const
Definition: OTAgent.hpp:414
bool IsAuthorizingAgentForParty()
Definition: OTAgent.cpp:623