eip-1491.md
1 --- 2 eip: 1491 3 title: Human Cost Accounting Standard (Like Gas but for humans) 4 author: Iamnot Chris (@cohabo) 5 discussions-to: https://github.com/freeworkculture/kazini/issues/11 6 status: Draft 7 type: Standards Track 8 category: ERC 9 created: 2018-10-12 10 --- 11 12 <!--You can leave these HTML comments in your merged EIP and delete the visible duplicate text guides, they will not appear and may be helpful to refer to if you edit it again. This is the suggested template for new EIPs. Note that an EIP number will be assigned by an editor. When opening a pull request to submit your EIP, please use an abbreviated title in the filename, `eip-draft_title_abbrev.md`. The title should be 44 characters or less.--> 13 14 15 ## Simple Summary 16 <!--"If you can't explain it simply, you don't understand it well enough." Provide a simplified and layman-accessible explanation of the EIP.--> 17 A standard interface for Human Capital Accounting tokens. 18 19 ## Abstract 20 <!--A short (~200 word) description of the technical issue being addressed.--> 21 The following standard allows for the implementation of a standard API for HUCAP tokens within smart contracts. This standard provides basic functionality to discover, track and transfer the motivational hierarchy of human resources. While blockchain architecture has succeeded in the financialisation of integrity by way of transparency; correspondingly real world outcomes will be proportional to the degree of individualisation of capital by way of knowledge. 22 23 ## Motivation 24 <!--The motivation is critical for EIPs that want to change the Ethereum protocol. It should clearly explain why the existing protocol specification is inadequate to address the problem that the EIP solves. EIP submissions without sufficient motivation may be rejected outright.--> 25 The Ethereum protocol architecture has a deterministic world-view bounded to the random reality of the human domain that supplies the intentions and logic. The yellow paper formally defines the EVM as a state machine with only deterministic parameters and state transition operators. Oracle requests to another on-chain contract, and/or off-chain HTTP lookups still make for multiple deterministic transactions. 26 27 A standard interface that allows the appraisal of individual capabilities concurrently with output and the overall knowledge-base will reduce market search costs and increase the autonomous insertion of mindful innovation into the blockchain ecosystem. We provide for simple smart contracts to define and track an arbitrarily large number of HUCAP assets. Additional applications are discussed below. 28 29 The Belief-Desire-Intention model is a plan-theoretic framework for establishing means-end coherence in agent based modelling system. 30 The blockchain's cryptographic security architecture reliably scales to a blockchain based PKI web-of-trust hierarchies. 31 ERC-20 token standard allows any tokens on Ethereum to be re-used by other applications: from wallets to decentralized exchanges. 32 ERC-721 token standard allows wallet/broker/auction applications to work with any NFT on Ethereum. 33 ERC-1155 Crypto Item standard allows a smart contract interface where one can represent any number of ERC-20 and ERC-721 assets in a single contract. 34 35 This standard is inspired by the belief–desire–intention (BDI) model of human practical reasoning developed by Michael Bratman as a way of explaining future-directed intention. A BDI agent is a particular type of bounded rational software agent, imbued with particular mental attitudes, viz: Beliefs, Desires and Intentions (BDI). The model identifies commitment as the distinguishing factor between desire and intention, and a noteworthy property that leads to (1) temporal persistence in plans and in the sense of explicit reference to time, (2) further plans being made on the basis of those to which it is already committed, (3) hierarchical nature of plans, since the overarching plan remains in effect while subsidiary plans are being executed. 36 37 The BDI software model is an attempt to solve a problem of plans and planning choice and the execution thereof. The complement of which tenders a sufficient metric for indicating means-end coherence and ascribing cost baselines to such outcomes. 38 39 ## Specification 40 <!--The technical specification should describe the syntax and semantics of any new feature. The specification should be detailed enough to allow competing, interoperable implementations for any of the current Ethereum platforms (go-ethereum, parity, cpp-ethereum, ethereumj, ethereumjs, and [others](https://github.com/ethereum/wiki/wiki/Clients)).--> 41 42 43 #### Main Interface 44 ```solidity 45 pragma solidity ^0.4.25; 46 pragma experimental ABIEncoderV2; 47 48 /** 49 @title ERC-**** Human Capital Accounting Standard 50 @dev See https://github.com/freeworkculture/kazini/issues/11 51 Note: the ERC-165 identifier for this interface is 0xf23a6e61. 52 */ 53 54 interface IERC_HUCAP { 55 56 /** 57 @notice Compute the index value of an Agents BDI in the ecosystem. 58 @param _address Set the stance of an agent 59 @dev For the purpose of 60 Throws on any error rather than return a false flag to minimize user errors 61 */ 62 function updateIndex() internal returns (bool); 63 64 /** 65 @notice Get the active/inactive and states of an Agent in the ecosystem. 66 @param _address Set the stance of an agent 67 @dev For the purpose of 68 Throws on any error rather than return a false flag to minimize user errors 69 */ 70 function iam() view public returns (bool iam_, IERC_HUCAP_TYPES.IS state_); 71 72 /** 73 @notice Fetch the bdi index value of an Agent in the ecosystem. 74 @param _address Set the stance of an agent 75 @dev For the purpose of 76 Throws on any error rather than return a false flag to minimize user errors 77 */ 78 function index() view public returns (uint8 index_); 79 80 /** 81 @notice Count of Public Keys in key ring of an Agent in the ecosystem. 82 @param _address Set the stance of an agent 83 @dev For the purpose of 84 Throws on any error rather than return a false flag to minimize user errors 85 */ 86 function ringLength() view public returns (uint ringlength_); 87 88 /** 89 @notice Get the PGP Public Key Id of an Agent in the ecosystem. 90 @param "" Set the stance of an agent 91 @dev For the purpose of 92 Throws on any error rather than return a false flag to minimize user errors 93 */ 94 function keyId() view public returns (bytes32 KEYID_); 95 96 /** 97 @notice Get the merit data of an Agent in the ecosystem. 98 @param "" Set the stance of an agent 99 @dev For the purpose of 100 Throws on any error rather than return a false flag to minimize user errors 101 */ 102 function merits() view public returns ( 103 uint experience_, 104 bytes32 reputation_, 105 bytes32 talent_, 106 uint8 index_, 107 bytes32 hash_); 108 109 /** 110 @notice Get the accreditation of an Agent in the ecosystem. 111 @param "" Set the stance of an agent 112 @dev For the purpose of 113 Throws on any error rather than return a false flag to minimize user errors 114 */ 115 function kbase() view public returns (IERC_HUCAP_TYPES.KBase kbase_); 116 117 /** 118 @notice Get the desire of an Agent in the ecosystem. 119 @param _desire Pro-attitude 120 @dev For the purpose of 121 Throws on any error rather than return a false flag to minimize user errors 122 123 */ 124 function desire(bytes1 _desire) view external returns (bytes32); 125 126 /** 127 @notice Get the intention of an Agent in the ecosystem. 128 @param _intention Conduct-controlling pro-attitude 129 @dev For the purpose of 130 Throws on any error rather than return a false flag to minimize user errors 131 132 */ 133 function intention(bool _intention) view external returns (bytes32); 134 135 /** 136 @notice Cycle the intention of an Agent in the ecosystem. 137 @param _intention Conduct-controlling pro-attitude 138 @dev For the purpose of 139 Throws on any error rather than return a false flag to minimize user errors 140 */ 141 function flipIntention() external returns (bool); 142 143 144 /** 145 @notice Get the user data of an Agent in the ecosystem. 146 @param "" Conduct-controlling pro-attitude 147 @dev For the purpose of 148 Throws on any error rather than return a false flag to minimize user errors 149 */ 150 function getDoer() view external returns ( 151 bytes32 fPrint, 152 bool iam_, 153 bytes32 email, 154 bytes32 fName, 155 bytes32 lName, 156 uint age, 157 bytes32 data_); 158 159 /** 160 @notice Get the belief data of an Agent in the ecosystem. 161 @param _kbase Source address 162 @dev For the purpose of 163 Throws on any error rather than return a false flag to minimize user errors 164 165 */ 166 function getBelief(IERC_HUCAP_TYPES.KBase _kbase) view external returns ( 167 bytes32 country_, 168 bytes32 cAuthority_, 169 bytes32 score_); 170 171 /** 172 @notice Get the desire data of an Agent in the ecosystem. 173 @param _desire Pro-attitides 174 @dev For the purpose of 175 Throws on any error rather than return a false flag to minimize user errors 176 177 */ 178 function getDesire(bytes1 _desire) view external returns (bytes32,bool); 179 180 /** 181 @notice Get the intention of an Agent in the ecosystem. 182 @param _intention Conduct-controlling pro-attitude 183 @dev For the purpose of 184 Throws on any error rather than return a false flag to minimize user errors 185 186 */ 187 function getIntention(bool _intention) view external returns (IERC_HUCAP_TYPES.IS,bytes32,uint256); 188 189 /** 190 @notice Sign the Public Key of an Agent in the ecosystem. 191 @param _address Address of key to sign, must belong to an Agent 192 @dev For the purpose of 193 Throws on any error rather than return a false flag to minimize user errors 194 195 */ 196 function sign(address _address) public onlyOwner returns (uint, bool signed); 197 198 /** 199 @notice Sign the Public Key of an Agent in the ecosystem. 200 @param "" internal helper function to add key in keyring 201 @dev For the purpose of 202 Throws on any error rather than return a false flag to minimize user errors 203 */ 204 function sign() external onlyDoer returns (uint, bool signed); 205 206 /** 207 @notice Revoke the Public Key of an Agent in the ecosystem. 208 @param _address Address of key to revoke, must belong to an Agent 209 @dev For the purpose of 210 Throws on any error rather than return a false flag to minimize user errors 211 212 */ 213 function revoke(address _address) external onlyDoer returns (uint, bool revoked); 214 215 /** 216 @notice Revoke the Public Key of an Agent in the ecosystem. 217 @param "" internal helper function to remove key from keyring 218 @dev For the purpose of 219 Throws on any error rather than return a false flag to minimize user errors 220 */ 221 function revoke() external onlyDoer returns (uint, bool revoked); 222 223 /** 224 @notice Set the trust level for a Public Key of an Agent in the ecosystem. 225 @param _level Degree of trust 226 @dev For the purpose of 227 Throws on any error rather than return a false flag to minimize user errors 228 229 */ 230 function trust(Trust _level) returns (bool); 231 232 /** 233 @notice Increment the number of keys in the keyring of an Agent in the ecosystem. 234 @param _keyd Target key 235 @dev For the purpose of 236 Throws on any error rather than return a false flag to minimize user errors 237 238 */ 239 function incSigns(bytes32 _keyd) external ProxyKey returns (uint); 240 241 /** 242 @notice Decrement the number of keys in the keyring of an Agent in the ecosystem. 243 @param _keyd Target key 244 @dev For the purpose of 245 Throws on any error rather than return a false flag to minimize user errors 246 247 */ 248 function decSigns(bytes32 _keyd) external ProxyKey returns (uint); 249 250 /** 251 @notice Set the knowledge credentials of an Agent in the ecosystem. 252 @param _kbase Level of accreditation 253 @param _country Source country 254 @param _cAuthority Accreditation authority 255 @param _score Accreditation 256 @param _year Year of Accreditation 257 @dev For the purpose of 258 Throws on any error rather than return a false flag to minimize user errors 259 */ 260 function setbdi( 261 KBase _kbase, 262 bytes32 _country, 263 bytes32 _cAuthority, 264 bytes32 _score, 265 uint _year 266 ) external ProxyBDI returns (bool qualification_); 267 268 /** 269 @notice Set the SNA metrics of an Agent in the ecosystem 270 @param _refMSD Minimum shortest distance 271 @param _refRank Rank of target key 272 @param _refSigned No of keys signed I have signed 273 @param _refSigs No. of keys that have signed my key 274 @param _refTrust Degree of tructThrows on any error rather than return a false flag to minimize user errors 275 @dev For the purpose of 276 Throws on any error rather than return a false flag to minimize user errors 277 */ 278 function setbdi( 279 uint _refMSD, 280 uint _refRank, 281 uint _refSigned, 282 uint _refSigs, 283 bytes32 _refTrust 284 ) external ProxyBDI returns (bool reputation_); 285 286 /** 287 @notice Set the talents of an Agent in the ecosystem 288 @param _talent Agent's talent 289 @dev For the purpose of 290 Throws on any error rather than return a false flag to minimize user errors 291 */ 292 function setbdi(bytes32 _talent) external ProxyBDI returns (bool talent_); 293 294 /** 295 @notice Set the desires of an Agent in the ecosystem 296 @param _desire Pro-attitude 297 @param _goal A goal is an instatiated pro-attitude 298 @dev For the purpose of 299 Throws on any error rather than return a false flag to minimize user errors 300 */ 301 function setbdi(bytes1 _desire, Desire _goal) public onlyDoer returns (bool); 302 303 /** 304 @notice Set the intention of an Agent in the ecosystem 305 @param _service Conducting-controlling pro-attitude 306 @dev For the purpose of 307 Throws on any error rather than return a false flag to minimize user errors 308 */ 309 function setbdi(Intention _service) public onlyDoer returns (bool); 310 311 /** 312 @notice Set the targeted intention of an Agent in the ecosystem. 313 @param _intention Conduct-controlling pro-attitude 314 @param _state Agent stance 315 @dev For the purpose of 316 Throws on any error rather than return a false flag to minimize user errors 317 318 */ 319 function intention(bool _intention, IERC_HUCAP_TYPES.IS _state) external returns (IERC_HUCAP_TYPES.IS); 320 321 /* End of interface IERC_HUCAP */ 322 } 323 324 325 ``` 326 #### User Defined Types Extension Interface 327 328 <!--The technical specification should describe the syntax and semantics of any new feature. The specification should be detailed enough to allow competing, interoperable implementations for any of the current Ethereum platforms (go-ethereum, parity, cpp-ethereum, ethereumj, ethereumjs, and [others](https://github.com/ethereum/wiki/wiki/Clients)).--> 329 330 ```solidity 331 332 interface IERC_HUCAP_TYPES { 333 334 /* Enums*/ 335 336 // Weights 1, 2, 4, 8, 16, 32, 64, 128 256 337 enum KBase {PRIMARY,SECONDARY,TERTIARY,CERTIFICATION,DIPLOMA,LICENSE,BACHELOR,MASTER,DOCTORATE} 338 339 340 enum IS { CLOSED, CREATOR, CURATOR, ACTIVE, INACTIVE, RESERVED, PROVER } 341 342 /* Structus */ 343 344 struct Clearance { 345 bytes32 Zero; 346 bytes32 Unknown; 347 bytes32 Generic; 348 bytes32 Poor; 349 bytes32 Casual; 350 bytes32 Partial; 351 bytes32 Complete; 352 bytes32 Ultimate; 353 } 354 /* End of interface IERC_HUCAP_TYPES */ 355 } 356 357 ``` 358 #### Web-of-trust Extension Interface 359 360 <!--The technical specification should describe the syntax and semantics of any new feature. The specification should be detailed enough to allow competing, interoperable implementations for any of the current Ethereum platforms (go-ethereum, parity, cpp-ethereum, ethereumj, ethereumjs, and [others](https://github.com/ethereum/wiki/wiki/Clients)).--> 361 362 ```solidity 363 pragma solidity ^0.4.25; 364 pragma experimental ABIEncoderV2; 365 366 interface IERC_HUCAP_KEYSIGNING_EXTENSION { 367 368 bytes32 constant public _InterfaceId_ERC165_ = "CREATOR 0.0118 XOR OF ALL FUNCTIONS IN THE INTERFACE"; // Complies to ERC165 369 370 // KEY MASKING TABLE 371 // bytes32 constant public MASK = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; 372 // bytes32 constant public KEYID = 0xffffffffffffffffffffffffffffffffff90EBAC34FC40EAC30FC9CB464A2E56; // EXAMPLE PGP PUBLIC KEY ID 373 // bytes32 constant public KEY_CERTIFICATION = 0x01ffffffffffffff << 192; // “C” Key Certification 374 // bytes32 constant public SIGN_DATA = 0x02ffffffffffffff << 192; // “S” Sign Data 375 // bytes32 constant public ENCRYPT_COMMUNICATIONS = 0x04ffffffffffffff << 192; // “E” Encrypt Communications 376 // Clearance constant public Trust = 0x03ff << 192; // Trust: Unknown 377 // BYTES32 Value with 378 // Public Key Id, masking 379 // Key Certification masking 380 // Split Key masking 381 // Generic masking 382 // Ordinary masking 383 // Trust.Unknown masking 384 // bytes32 constant public DOER = 0x11ff10ff100f03ffff00ffffffffffffffff90EBAC34FC40EAC30FC9CB464A2E56; 385 386 bytes32 constant public KEY_CERTIFICATION = 0x01ffffffffffffff << 192; // “C” Key Certification 387 bytes32 constant public SIGN_DATA = 0x02ffffffffffffff << 192; // “S” Sign Data 388 bytes32 constant public ENCRYPT_COMMUNICATIONS = 0x04ffffffffffffff << 192; // “E” Encrypt Communications 389 bytes32 constant public ENCRYPT_STORAGE = 0x08ffffffffffffff << 192; // “E” Encrypt Storage 390 bytes32 constant public SPLIT_KEY = 0x10ffffffffffffff << 192; // Split key 391 bytes32 constant public AUTHENTICATION = 0x20ffffffffffffff << 192; // “A” Authentication 392 bytes32 constant public MULTI_SIGNATURE = 0x80ffffffffffffff << 192; // Held by more than one person 393 bytes32 constant public TRUST_AMOUNT = 0xffffffffffff00ff << 192; 394 bytes32 constant public BINARY_DOCUMENT = 0xffff00ffffffffff << 192; // 0x00: Signature of a binary document. 395 bytes32 constant public CANONICAL_DOCUMENT = 0xffff01ffffffffff << 192; // 0x01: Signature of a canonical text document. 396 bytes32 constant public STANDALONE_SIGNATURE = 0xffff02ffffffffff << 192; // 0x02: Standalone signature. 397 bytes32 constant public GENERIC = 0xffff10ffffffffff << 192; // 0x10: Generic certification of a User ID and Public-Key packet. 398 bytes32 constant public PERSONA = 0xffff11ffffffffff << 192; // 0x11: Persona certification of a User ID and Public-Key packet. 399 bytes32 constant public CASUAL = 0xffff12ffffffffff << 192; // 0x12: Casual certification of a User ID and Public-Key packet. 400 bytes32 constant public POSITIVE = 0xffff13ffffffffff << 192; // 0x13: Positive certification of a User ID and Public-Key packet. 401 bytes32 constant public SUBKEY_BINDING = 0xffff18ffffffffff << 192; // 0x18: Subkey Binding Signature 402 bytes32 constant public PRIMARY_KEY_BINDING = 0xffff19ffffffffff << 192; // 0x19: Primary Key Binding Signature 403 bytes32 constant public DIRECTLY_ON_KEY = 0xffff1Fffffffffff << 192; // 0x1F: Signature directly on a key 404 bytes32 constant public KEY_REVOCATION = 0xffff20ffffffffff << 192; // 0x20: Key revocation signature 405 bytes32 constant public SUBKEY_REVOCATION = 0xffff28ffffffffff << 192; // 0x28: Subkey revocation signature 406 bytes32 constant public CERTIFICATION_REVOCATION = 0xffff30ffffffffff << 192; // 0x30: Certification revocation signature 407 bytes32 constant public TIMESTAMP = 0xffff40ffffffffff << 192; // 0x40: Timestamp signature. 408 bytes32 constant public THIRD_PARTY_CONFIRMATION = 0xffff50ffffffffff << 192; // 0x50: Third-Party Confirmation signature. 409 bytes32 constant public ORDINARY = 0xffffffff100fffff << 192; 410 bytes32 constant public INTRODUCER = 0xffffffff010fffff << 192; 411 bytes32 constant public ISSUER = 0xffffffff001fffff << 192; 412 413 // EDGES MASKING TABLE 414 Clearance internal TRUST = Clearance({ 415 Zero: 0x01ff << 192, 416 Unknown: 0x03ff << 192, 417 Generic: 0x07ff << 192, 418 Poor: 0xF0ff << 192, 419 Casual: 0xF1ff << 192, 420 Partial: 0xF3ff << 192, 421 Complete: 0xF7ff << 192, 422 Ultimate: 0xFFff << 192 423 }); 424 425 /** 426 /// @notice Cycle through state transition of an Agent in the ecosystem. 427 /// @param _address toggle on/off a doer agent 428 // @dev `anybody` can retrieve the talent data in the contract 429 */ 430 function flipTo(address _address) external onlyOwner returns (IS); 431 432 /** 433 /// @notice Turn Agent in the ecosystem to on/off. 434 /// @param _address toggle on/off a doer agent 435 // @dev `anybody` can retrieve the talent data in the contract 436 */ 437 function toggle(address _address) external onlyOwner returns (bool); 438 439 /** 440 /// @notice Set the trust level of an Agent in the ecosystem. 441 /// @param _level toggle on/off a doer agent 442 // @dev `anybody` can retrieve the talent data in the contract 443 */ 444 function trust(Trust _level) returns (bytes32 Trust); 445 446 event LogCall(address indexed from, address indexed to, address indexed origin, bytes _data); 447 448 /* End of interface IERC_HUCAP_KEYSIGNING_EXTENSION */ 449 } 450 451 ``` 452 #### Human Capital Accounting Extension Interface 453 454 ```solidity 455 pragma solidity ^0.4.25; 456 pragma experimental ABIEncoderV2; 457 458 interface IERC_HUCAP_TRACKUSERS_EXTENSION { 459 460 /// @notice Instantiate an Agent in the ecosystem with default data. 461 /// @param _address initialise a doer agent 462 // @dev `anybody` can retrieve the talent data in the contract 463 function initAgent(Doers _address) external onlyControlled returns (bool); 464 465 /// @notice Get the data by uuid of an Agent in the ecosystem. 466 /// @param _uuid Get the address of a unique uid 467 // @dev `anybody` can retrieve the talent data in the contract 468 function getAgent(bytes32 _uuid) view external returns (address); 469 470 /// @notice Get the data of all Talents in the ecosystem. 471 /// @param _address Query if address belongs to an agent 472 // @dev `anybody` can retrieve the talent data in the contract 473 function iam(address _address) view public returns (bool); 474 475 /// @notice Get the data of all Talents in the ecosystem. 476 /// @param _address Query if address belongs to a doer 477 // @dev `anybody` can retrieve the talent data in the contract 478 function isDoer(address _address) view public returns (IS); 479 480 /// @notice Get the number of doers that can be spawned by a Creators. 481 /// The query condition of the contract 482 // @dev `anybody` can retrieve the count data in the contract 483 function getAgent(address _address) 484 view public returns (bytes32 keyid_, IS state_, bool active_, uint myDoers_); 485 486 /// @notice Get the data of all Talents in the ecosystem. 487 /// @param _talent The talent whose frequency is being queried 488 // @dev `anybody` can retrieve the talent data in the contract 489 function getTalents(bytes32 _talent) 490 view external returns (uint talentK_, uint talentI_, uint talentR_, uint talentF_); 491 492 /// @notice Increment a kind of talent in the ecosystem. 493 /// @param The talent whose frequency is being queried 494 // @dev `anybody` can retrieve the talent data in the contract 495 function incTalent() payable public onlyDoer returns (bool); 496 497 /// @notice Decrement a kind of talent in the ecosystem.. 498 /// @param The talent whose frequency is being queried 499 // @dev `anybody` can retrieve the talent data in the contract 500 function decTalent() payable public onlyDoer returns (bool); 501 502 /// @notice Set the Public-Key Id of an Agent in the ecosystem. 503 /// @param _address Set the Public-key Id of an agent 504 // @dev `anybody` can retrieve the talent data in the contract 505 function setAgent(address _address, bytes32 _keyId) external onlyControlled returns (bytes32); 506 507 /// @notice Transition the states of an Agent in the ecosystem. 508 /// @param _address Set the stance of an agent 509 // @dev `anybody` can retrieve the talent data in the contract 510 function setAgent(address _address, IS _state) external onlyControlled returns (IS); 511 512 /// @notice Set the active status of an Agent in the ecosystem. 513 /// @param _address Toggle the true/false status of an agent 514 // @dev `anybody` can retrieve the talent data in the contract 515 function setAgent(address _address, bool _active) external onlyControlled returns (bool); 516 517 /// @notice Set the data of all Intentions of Agents in the ecosystem. 518 /// @param _serviceId Track number of offers available 519 // @dev `anybody` can retrieve the talent data in the contract 520 function setAllPromises(bytes32 _serviceId) external onlyControlled; 521 522 /* End of interface IERC_HUCAP_TRACKUSERS_EXTENSION */ 523 } 524 525 526 ``` 527 ## Rationale 528 <!--The rationale fleshes out the specification by describing what motivated the design and why particular design decisions were made. It should describe alternate designs that were considered and related work, e.g. how the feature is supported in other languages. The rationale may also provide evidence of consensus within the community, and should discuss important objections or concerns raised during discussion.--> 529 [WIP] 530 531 ## Backwards Compatibility 532 <!--All EIPs that introduce backwards incompatibilities must include a section describing these incompatibilities and their severity. The EIP must explain how the author proposes to deal with these incompatibilities. EIP submissions without a sufficient backwards compatibility treatise may be rejected outright.--> 533 [WIP] 534 535 ## Test Cases 536 <!--Test cases for an implementation are mandatory for EIPs that are affecting consensus changes. Other EIPs can choose to include links to test cases if applicable.--> 537 [WIP] 538 539 ## Implementation 540 <!--The implementations must be completed before any EIP is given status "Final", but it need not be completed before the EIP is accepted. While there is merit to the approach of reaching consensus on the specification and rationale before writing code, the principle of "rough consensus and running code" is still useful when it comes to resolving many discussions of API details.--> 541 [WIP] 542 543 ## Copyright 544 Copyright and related rights waived via [CC0](https://creativecommons.org/publicdomain/zero/1.0/).