Reading/Translating from the state of the Wealth Architect Smart Contract

Reading and Writing bytes32(1)

Option 1.

When reading from or writing to the smart contract, it is essential to understand how to convert a bytes32 encoded string into a string value and a string into a bytes32 encoded string. You need to know how to do this because strings values(more commonly seen as text) take up a lot of gas when using the ethereum virtual machine (Making transactions much more expensive.) To mitigate this issue, we instead use bytes32 encoded strings which only require 32 bytes of space. Doing this makes it possible for us to fit more functionality into a single contract. 

Our final hurdle is teaching the users how to create bytes32 encoded string values and decode those values. In this smart contract (The Wealth Architect), we have included two functions to assist in these matters. 

The first function is;

agetbytes32ToString(bytes32 _bytes32)

          public

          pure

          returns (string memory) {

              uint8 i = 0;

              while(i < 32 && _bytes32[i] != 0) {

                  i++;

              }

              bytes memory bytesArray = new bytes(i);

              for (i = 0; i < 32 && _bytes32[i] != 0; i++) {

                  bytesArray[i] = _bytes32[i];

              }

              return string(bytesArray);

      }

Using this function makes it possible for a user to take a bytes32 encoded string value and convert it from a bytes32 encoded string value into a string(text) that can get read easily.

For Example.

A bytes32 encoded string value like the one below can get converted using the function by inputting the value and calling the function. Once called, the function will decode the value and return the string below.

bytes32: 

0x546865205765616c746820417263686974656374205769746820457363726f77

Converts to

String(Text):

The Wealth Architect With Escrow 2021

Using this method makes it simple to read the bytes32 encoded strings in the smart contract(The Wealth Architect.)

The second function is;

agetstringToBytes32(string memory source)

          pure

          public

          returns (bytes32 result) {

          bytes memory tempEmptyStringTest = bytes(source);

          if (tempEmptyStringTest.length == 0) {

              return 0x0;

          }

          assembly {

              result := mload(add(source, 32))

          }

      }

Using this function makes it possible for a user to take a string value and convert it from a string value into a bytes32 encoded string.

For Example.

A string value like the one below can get converted using the function by inputting the value and calling the function. Once called, the function will encode the value and return the bytes 32 encoded string below.

String(Text):

The Wealth Architect With Escrow 2021

Converts to

bytes32: 

0x546865205765616c746820417263686974656374205769746820457363726f77

Using this method makes it simple to create the bytes32 encoded strings essential to the smart contract(The Wealth Architect.)

Reading and Writing differences(2)

Now that we have gone over how to read and write bytes32 encoded strings, we are ready to start covering the smart contract’s different getter functions that allow any user to read from the smart contract state. First, we need to understand the difference between functions that read from the smart contract and functions that write to the smart contract.

Smart Contract functions that meet the criteria below get considered as view-only functions that read from the state;

View functions ensure that they will not modify the state. A function can get declared as a view smart Contract function. If present in the Smart Contract functions, these things change the state, and the compiler will throw a warning in such cases. If included in a Smart Contract function, any of the below criteria will disqualify it from a no gas view call.

  1. Smart Contract functions that get to modify state variables when called.
  2. Smart Contract functions that get to emit events.
  3. Smart Contract functions that get to create other contracts.
  4. Smart Contract functions that get to use self-destruct.
  5. Smart Contract functions that get to send ether via calls.
  6. Smart Contract functions calling any Smart Contract function which did not get marked as view or pure.
  7. Smart Contract functions that get to use low-level calls.
  8. Processes using inline assembly containing specific opcodes.

All of the functions described on this page are qualified as view-only functions. They only read from the state of the contract. Using the functions described on this page, you can stay up-to-date with the latest information on properties, escrow agreements, token balances, and any other user-related state information. None of the functions on this page can make a “state change” to the smart contract(The Wealth Architect)

What does it mean precisely by “state change?”

A state change in a smart contract refers to a Transaction, which means two parties involved in the transaction will have some changes. For instance, if you send some money from one account to another – there will be changes on both sides. Similarly, it applies to related data transactions as well.

If you want to update the value of a variable defined in the smart contract, since you will use blockchain storage, updating the variable is a state change because you are making a transaction to make it happen. With this update/addition transaction, you will end up spending some gas.

Where the “state changes” get stored?

The state changes get stored on the ethereum blockchain in terms of the transactions on the distributed ledger.

Are “state changes” called a distributed ledger?

A distributed ledger is not state or state changes, but on a distributed ledger, you will have blocks of all transactions(state-changes) that happen on a blockchain.

Except for transactions, are there any events that cause state changes?

No, only transactions cause state changes on the blockchain.

Are any of the functions on this page “State Changing?”

None of the functions described on this page for the smart contract(The Wealth Architect) are state-changing functions.

The Reader Functions(3)

A public variable generates a public getter, without any permission scheme possible: it is accessible by anyone.

Variables that aren’t public that should be public have getter functions that the developers manually created to retrieve that information.

ERC20 Functions(1)

The following standard allows for the implementation of a standard API for tokens within smart contracts. The ERC20 token standard provides basic functionality to transfer tokens and will enable tokens to be approved so another on-chain third party can spend them.

NOTES:

  • The following specifications use syntax from Solidity 0.4.17 (or above)
  • Callers MUST handle false returns (bool success). Callers MUST NOT assume that false never gets returned!

name

Returns the name of the token – e.g., “MyToken.”

OPTIONAL – This method can improve usability, but interfaces and other contracts MUST NOT expect these values to be present.

function name() public view returns (string)

Using this method, you can return the token’s name, which is useful when adding the token to web3 wallet providers as a new asset and is also required most of the time to make the addition.

string public name = “TheWealthArchitect”;

symbol

Returns the symbol of the token. E.g., “HIX.”

OPTIONAL – This method can improve usability, but interfaces and other contracts MUST NOT expect these values to be present.

function symbol() public view returns (string)

Using this method, you can return the token’s symbol, which is useful when adding the token to web3 wallet providers as a new asset and is also required most of the time to make the addition.

string public symbol = “AVEC”;

decimals

Returns the number of decimals the token uses – e.g., 8, means to divide the token amount by 100000000 to get its user representation. (There are eight zeros.)

OPTIONAL – This method can improve usability, but interfaces and other contracts MUST NOT expect these values to be present.

function decimals() public view returns (uint8)

Using this method, you can return the token’s decimals, which is useful when adding the token to web3 wallet providers as a new asset and is also required most of the time to make the addition.

uint8 public decimals = 18;

 totalSupply

“totalSupply” returns the total supply of the tokens in the ERC20 smart contract.

The Wealth Architect all tokens, including AVEC, ONUS, and OMNI, contribute to this value as they are all get contained, accounted for, and balanced in the same Smart Contract.

In the Wealth Architect Smart Contract, this value represents every single property’s combined token value.

function totalSupply() public view returns (uint256)

uint256 public totalSupply;

 balanceOf

It returns the account balance of another account using the “address _owner” field of the function.

When the balance of function gets called in the Exist Wealth Architect Smart Contract, it returns from the balance of the currently set transferring property id of the user input as address _owner. When no balance is available, it returns 0.

Using this function as a user, you can check another wallet’s current balance. Inputting the address of the wallet balance you are searching for and calling the function will return the balance of that wallet currently set transferring property id.

function balanceOf(address _owner) public view returns (uint256 balance)

function balanceOf(address _UserAddress)

          view

          public

          returns(uint256)

      {

          return GUsers[_UserAddress].PropertyAvecBalance[GUsers[_UserAddress].transferingPropertyid_];

      }

allowance

Returns the amount which _spender is still allowed to withdraw from _ owner.

function allowance(address _owner, address _spender) public view returns (uint256 remaining)

When calling the transfer from function to move these funds, it is essential to note that the function will fail if the user wallet that the allowance is getting spent out of doesn’t have an available balance in their current set transferring property id. The information here is critical when trying to draw from any user addresses property AVEC token balance ledger because of the necessity of a pre-imminent approval using the A A swap type function by the user wallet from which you are spending the AVEC allowance. Generally speaking, the transferring property ID of any given wallet is set to the ONUS property id by default, including after every transfer. That is why it’s vital to get approval using the function below.

IMPORTANT

The function below changes the state of the contract and does not get considered as a view-only function.

function aaswapType(

          bytes32 _propertyUniqueID, 

          uint8 _tokenType)

In the Wealth Architect Smart Contract, you can view the allowance granted to any wallet by any other wallet using this allowance function. The token owner’s address and the allowances spender must be input into the functions fields to view the allowance granted from one wallet to another. Then, by calling the function, it will return the allowance.

function allowance(address tokenOwner, address spender)

          public

          view returns (uint remaining) {

              return GUsers[tokenOwner]._allowed[spender];

      }

ERC20 Events(2)

Q What does the “indexed” keyword do in the below line of code? I’m guessing it just tells the event object that the ethereum virtual machine should log the following input?

The indexed parameters for logged events will allow you to search for these events using the indexed parameters as filters when using a block explorer. With the ability to search for indexed values, you can return results that get related, i.e., address values, bytes32 values, etc. In simpler terms, if you want to see all the transfers on a wallet using the emitted events, you can do so by searching the wallet address in the events that got indexed. For example, when transfer functions get called the “from” address of the msg.sender and “to” address of the recipient, they get indexed in transfer events. All ingoing and outgoing transactions are searchable for any given wallet address because of this.

Q Can we use it in other places, i.e., outside of events?

The indexed keyword is only relevant to logged events.

Q Can we use it in other places, i.e., outside of events?

msgsender indicates the sender of the current message or (current call). The msg.sender indicates the person currently connecting with the contract. In case of a contract calling another contract, msgsender gets used to represent the contract address.

 Transfer

The transfer event MUST trigger when tokens are transferred, including zero value transfers. Doing this allows a contract to meet the full erc20 standard for the transfer function.

function transfer(

          address _toAddress, 

          uint256 _amountOfTokens)

This event indexes the “from” address of the message sender and “to” address of the recipient for the transfer and archives the event’s transfer value.

event Transfer(address indexed _from, address indexed _to, uint256 _value)

A token contract that creates new tokens SHOULD trigger a Transfer event with the _from address set to 0x0 when tokens get created. In the case of the Wealth Architect Smart Contract, when tokens get minted, it is done with the address of the owner and a special event;

AVECMinted(

    GUsers[_toAddressStacked].Ceva, 

    _commissionFounderDeveloper,  

    _toAddressStacked, 

    _amountOfTokens, 

    _escrowTokensStacked);

This event is described in further detail later on this page.

 Approval

MUST trigger on any successful call to; 

approve(

  address _spender, 

  uint256 _value).

This event indexes the “owner” address and the “spender” address of the approval and archives the event’s allowance value.

event Approval(

  address indexed _owner, 

  address indexed _spender, 

  uint256 _value)

Exist Functions(3)

When reading information from the smart contract, you’ll notice that most of it gets contained by structs.

A struct in solidity is just a custom type that you can define. You define the struct with a name and associated properties inside of it.

For example;

struct PropertyEscrow {

          bytes32 PropertyID;

          address payable recipientOfFunds;

          bytes32 recipientName;

          uint8 escrowAgreementNumber;

          bool escrowCompleted;

          uint256 milestonePriceOfEscrowInETH;

          uint256 tokensAvailableTotal;

          uint256 tokensAvailableCurrent;

          uint256 totalETHReceived;

          uint256 ethPerToken;

          uint256 propertyIncrease;

          mapping(address => uint256) AgreementAmountDueInTokens;

      }

The Wealth architect structures and stores most of its information using these structs, storing and referencing multiple pieces of data using a single piece of information like a property id. Allowing users to reference essential details about escrow agreements, properties, and other user addresses with a single piece of information like a wallet address or bytes32 property id simplifies keeping track of information. Doing this saves users of the Wealth Architect Smart Contract gas on their complex equity transactions too.

Other information is stored more simply inside single uint256, bool, bytes32, and address variables very similarly to the ERC20 standard public variables or with mapping type variable that can hold a list of values that functions and the smart contract can reference with a key.

For Example;

/*=================================

      = Mapping =

      =================================*/

      mapping(address => TotalHolds) private LatestTotalHolds;

      mapping(bytes32 => FeeWallet) private GFeeWallets;

      mapping(bytes32 => Property) Properties;

      mapping(address => User) GUsers;

      mapping(address => uint256) amountDueInTokens;

      mapping(bytes32 => mapping(uint8 => PropertyEscrow)) private GEscrowAgreements;

      /*=================================

      = bytes32 =

      =================================*/

      bytes32 private GfeeWalletSecretID_;

      bytes32[] private GListFeeWalletSecretIDs;

      bytes32[] propertyIDs;

      /*=================================

      = address =

      =================================*/

      address[] userAccounts;

     /*================================

      = uint =

      ================================*/

      uint256 ETHERTOTALRECEIVED;

      uint256 ETHERESCROWED;

      uint256 ETHERTOTALWITHDRAWN;

      /*================================

      = bool =

      ================================*/

      bool internal adminset_ = false;

Below, the key to referencing the value of the mapping would be the property id. Even more interesting is the value of this mapping; the value is a struct. In essence, this mapping stores a list of structs, each struct holding multiple pieces of data about the different WHOA properties. Any property can be referenced in this list using the property id.

mapping(bytes32 => Property) Properties;

Now that the basics have gotten covered, we can start going over the Wealth Architects Getter Functions.

Get an escrow agreement info.

This function returns the following information about an escrow agreement;

The property ID used to reference the Escrow Agreement.

  • (PropertyID)0:bytes32: 0x0000000000000000000000000000000000000000000000000000000000000000

The “ethereum address” referencing the QI wallet that will receive the escrow agreements milestone ethereum commitment. 

  • (recipientOfFunds)
  • 1:address: 0x0000000000000000000000000000000000000000

The bytes32 encoded string value representing the recipient’s name.

  • (recipientName)
  • 2:bytes32: 0x0000000000000000000000000000000000000000000000000000000000000000

The number of this specific escrow agreement between 0-255.

  • (escrowAgreementNumber)
  • 3:uint8: 0

The true-false value represents whether or not the escrow agreement has gotten completed, and contributors can withdraw funds along with the ethereum recipient.

  • (escrowCompleted)
  • 4:bool: false

The milestone funding price to complete the agreement and make the escrow completed value = true.

  • (milestonePriceOfEscrowInETH)
  • 5:uint256: 0

The available tokens that users can purchase from the escrow agreement before the agreement completes and makes the escrow completed variable = true;

  • (tokensAvailableTotal)
  • 6:uint256: 0

The currently available tokens that users can purchase from the escrow agreement before the agreement completes and makes the escrow completed variable = true;

  • (tokensAvailableCurrent)
  • 7:uint256: 0

The total amount of ethereum received so far in the escrow agreement.

  • (totalETHReceived)
  • 8:uint256: 0

The price in ethereum per token the escrow agreement. The value represented as a Wei value.

  • (ethPerToken)
  • 9:uint256: 0

The value that this escrow agreement will add to the token once the funding gets completed.

  • (propertyIncrease)
  • 10:uint256: 0

Amount due to the user wallet that is currently viewing the escrow agreement retrieved by this function.

  • (AgreementAmountDueInTokens)
  • 11:uint256: 0

This function retrieves the struct holding the different relevant and live pieces of data you can use to make informed decisions when contributing to an escrow agreement.

function agetEscrow(

          bytes32 _PropertyID) 

Get a property’s info.

This function returns the following information about any property’s info;

The true-false value represents whether a property got set or not. When this value gets set to false the property gets turned off.

  • (Set)
  • 0:bool: false

The address value here is representing the CEVA founder developer that represented this property when they set it.

  • (Ceva)
  • 1:address: 0x0000000000000000000000000000000000000000

The address value here represents the Founder Developer responsible for calling the minting function to mint the property.

  • (FounderDeveloper)
  • 2:address: 0x0000000000000000000000000000000000000000

The address value here represents the property owner that receives the tokens that got minted by the contract.

  • (Owner)
  • 3:address: 0x0000000000000000000000000000000000000000

The number value here represents the value of the property in USD.

  • (Value)
  • 4:uint256: 0

The number value here represents the number of single tokens reserved for escrow on the property.

  • (NumberOfTokensToEscrow)
  • 5:uint256: 0

The bytes32 value here represents the Property ID of the property.

  • (PropertyID)
  • 6:bytes32: 0x000000000000000000000000000000000000000000000000000000000000000

The number value here represents the number of property value adjustments that have taken place on a property.

  • (propertyPriceUpdateCountAsset)
  • 7:uint256: 0

The number value here represents the amount of AVEC that gets converted into ONUS and contributes to the global properties value.

  • (propertyGlobalBalance_)
  • 8:uint256: 0

The value here represents the last minting price of the property.

  • (lastMintingPrice_)
  • 9:uint256: 0

The value here represents the number of completed escrow agreements on a single property.

  • (escrowAgreementNumber)
  • 10:uint256: 0

The value here represents the currently active escrow agreement number on the property.

  • (currentEscrowAgreementNumber)
  • 11:uint8: 0

The true-false value here represents whether or not the first escrow agreement got set.

  • (firstEscrowSet)
  • 12:bool: false

All of the above values will get referenced by calling this function; the values are then returned to your UI by the Smart Contract. 

function agetProperty(

          bytes32 _PropertyID) 

Get the number of properties that got digitized.

Every property gets stored in an array then numbered in the order it went in, starting at zero. We can view the number of all-time properties that got digitized by the smart contract. Calling the function below will return the number of properties in the portfolio.

function agetPropertiesCount() 

          view

          public

          returns (uint) {

        return propertyIDs.length;

      }

Get a wallet share-hold in one of the thirteen envelopes.

Suppose you are a member that has digitized a property, and this property has given a continuous stream of income over the time you’ve had it. The payment you have received so far creates a track record, and the track record exhibits value making each share-hold worth something. To determine this value is vital when exchanging share-holds with other members to acquire the desired outcome. Suppose you would like to utilize that future value now. Most cases involving something that can generate a recurring income can get sold if the value the buyer receives over time is more significant than the income’s purchase value. In simpler terms, the greater the discount on what a share-hold can generate over time, the more attractive the purchase will appear to a buyer interested in making a profit.

function agetShareHoldOf(

          address _UserAddress, 

          uint8 _envelopeNumber)

Get the dividends due to a wallet for any of the given thirteen envelopes.

When dividends accrue to the thirteen envelopes, and you carry a share-hold within that account, you are immediately entitled to a portion of the accrued fees in the envelopes. To see the amount that got accrued so far for any wallet that didn’t get withdrawn yet, enter the user address and envelope number of the envelope that you are referencing, then call the function. Doing so will return the fees accrued so far for the wallet.

function agetDividendsOf(

          address _UserAddress, 

          uint8 _envelopeNumber)

Get user information.

When you use the wealth architect, it is essential to input the correct info into functions when producing the desired outcome. When it’s relating to a user of the wealth architect, you can search for that information. Using this function, input the User Address you are looking into and call the function. It will return the following information.

The true-false value here represents whether a user account has been set or not.

  • (Set)
  • 0:bool: true

The true-false value here represents whether CEVA has approved a user account to purchase their founder developer license or not.

  • (approvedByCevaForFD_)
  • 1:bool: false

The address value here represents the address assigned to the user account getting viewed.

  • (UserAddress)
  • 2:address: 0x0000000000000000000000000000000000000000

The address value here represents the address of the CEVA that is writing approvals for this user.

  • (Ceva)
  • 3:address: 0x0000000000000000000000000000000000000000

The address value here represents the address of the Founder Developer Two for this user’s organization.

  • (FounderDeveloperTwo)
  • 4:address: 0x0000000000000000000000000000000000000000

The address value here represents the address of the Founder Developer One for this user. The Founder Developer One here is the individual/contract who will mint the tokens for this user.

  • (FounderDeveloperOne)
  • 5:address: 0x0000000000000000000000000000000000000000

The number value here is the user privilege level of the individual user account getting viewed.

  • (UserPrivilegeLevel)
  • 6:uint8: 4

By entering the User Address of the user you’re looking for and calling the function, the smart contract will return the above information to your UI.

function agetUserCard(

          address _UserAddress)

Count the number of users on the smart contract.

Suppose you would like to keep track of how many users have set a user on the smart contract. Calling the function below will return a numeric value representing the number of single wallets that have established an account on the smart contract.

function agetUserCount()

Get a user’s property count.

Suppose you would like to know the number of properties that an individual user has had minted for them by an FD. Entering the User Address you would like the count from and calling the function will return the count of properties minted for that address to the UI.

function agetUserPropertiesCount(

          address _UserAddress)

Get any user and property AVEC balance.

The address value here represents the address holding the balance.

  • (UserAddress)
  • 0:address: 0x0000000000000000000000000000000000000000

The numeric value here represents the total token balance ledger of all the above user addresses combined tokens.

  • (TokenBalanceLedgersTotal)
  • 1:uint256: 0

The numeric value here represents the total AVEC balance that the user address holds on the property.

  • (PropertyAvecBalance)
  • 2:uint256: 0

Entering the account’s user address, you are getting the balance for along with the property ID of the AVEC balance, and calling the function will return the above information to the UI.

function agetUserPropertyAvecBalance(

          address _InsUserAddress, 

          bytes32 _PropertyID) 

Get a user’s property card.

Suppose you would like to see any user accounts relevant to working and transferring property information (the active info governing the transactional functions.) Calling the function here will return the following information.

The bytes32 value here represents the working property id of the address input to the function. This value determines what property ceva and founder developers can work.

  • (workingPropertyid_)
  • 0:bytes32: 0x0000000000000000000000000000000000000000000000000000000000000000

The bytes32 value here represents the transferring property id of the address input to the function. This value determines what property value is being drawn from when making transfers or other transactional calls as a user.

  • (transferingPropertyid_)
  • 1:bytes32: 0x0000000000000000000000000000000000000000000000000000000000000000

Here, the numeric value represents the Total Token balance ledger total on all tokens owned by the address input to the function.

  • (TokenBalanceLedgersTotal)
  • 2:uint256: 0

Here, the numeric value represents the AVEC token balance ledger on the above transferring id of the address input to the function.

  • (PropertyAvecBalance)
  • 3:uint256: 0

Here, the numeric value represents the number of updates on the above transferring id for the function’s user account input. This value tells how many times this wallet got updated on the transferring property id’s value.

  • (propertyPriceUpdateCountMember_)
  • 4:uint256: 0

Here, the numeric value represents the minting deposits granted through tokenization for the address input to the function.

  • (mintingDepositsOf_)
  • 5:uint256: 0

Here, the numeric value represents the amount circulated for the address input to the function.

  • (amountCirculated_)
  • 6:uint256: 0

The true-false value here represents whether or not CEVA can burn this property using this address. Suppose the address searched isn’t the owner of the property. This value will return false because all burn white lists get stored on the property owner’s user address.

  • (burnrequestwhitelist_)
  • 7:bool: false

Here, the numeric value represents the last known property value on the above transferring id for the function’s user account input. This value tells the previously known value this wallet got updated on for the transferring property id’s value. This value gets used to calculate inflation and deflation on a user’s token balance ledger.

  • (propertyvalueOld_)
  • 8:uint256: 0

Here, the numeric value represents the number of the escrow agreement on the above transferring id for the function’s user account input. This value tells how many escrow agreements the transferring property id’s for this wallet has completed.

  • (lastknownPropertyEscrowAgreementNumber)
  • 9:uint8: 0

Here, the numeric value represents the transfer type currently set for this wallet. 1 for AVEC 2 for ONUS.

  • (transferType_)
  • 10:uint8: 0

Here, calling the function below with the user address that you need the property card will return the information about that user’s current property card to the UI.

function agetUserPropertyCard(

          address _UserAddress) 

Exist blockchain events.

event AVECtoONUS

MUST trigger on any successful call to; 

function amemberConvert(

          uint8 oneAVECtwoONUS, 

          uint256 tokens, 

          bytes32 _PropertyID)

This event indexes the “MemberAddress” address and the “PropertyID” bytes32 encoded string of the conversion and archives the event’s conversion value. This event gets triggered when the uint8 “oneAVECtwoONUS” is a “1” as input when called.

      event AVECtoONUS(

          address indexed MemberAddress,

          uint256 tokensConverted,

          bytes32 indexed PropertyID

      );

event ONUStoAVEC

MUST trigger on any successful call to; 

function amemberConvert(

          uint8 oneAVECtwoONUS, 

          uint256 tokens, 

          bytes32 _PropertyID)

This event indexes the “MemberAddress” address and the “PropertyID” bytes32 encoded string of the conversion and archives the event’s conversion value. This event gets triggered when the uint8 “oneAVECtwoONUS” is a “2” as input when called.

      event ONUStoAVEC(

          address indexed MemberAddress,

          uint256 tokensConverted,

          bytes32 indexed PropertyID

      );

event OnWithdraw

MUST trigger on any successful call to; 

function amemberWithdrawDividends(

          uint8 _envelopeNumber)

This event indexes the “MemberAddress” address and the “envelopeNumber” address of the approval and archives the event’s tokensWithdrawn value.

      event OnWithdraw(

          address indexed MemberAddress,

          uint256 tokensWithdrawn,

          uint8 indexed envelopeNumber

      );

Envelope Numbers

/**

       * withdraw an envelope hold shareholders specific envelope dividends based on the chosen number

       * 1 = Taxes Envelope

       * 2 = Insurance Envelope

       * 3 = Maintenance Envelope

       * 4 = Wealth Architect Equity Coin Operator Envelope

       * 5 = Hold One Envelope

       * 6 = Hold Two Envelope

       * 7 = Hold Three Envelope

       * 8 = Rewards Envelope(OMNI)

       * 9 = Tech Envelope

       * 10 = Exist Holdings Envelope

       * 11 = Exist Crypto Envelope

       * 12 = WHOA Envelope

       * 13 = Credible You Envelope

       */

event Burn

MUST trigger on any successful call to; 

function aBurnProperty(

          uint256 _propertyValue, 

          address _clearFrom)

This event indexes the “from” address. The “propertyValue” number of the burn and the event’s token value get archived.

      event Burn(

          address indexed from,

          uint256 tokens,

          uint256 propertyValue

      );

event PropertyValuation

MUST trigger on any successful call to; 

function adjustPropertyValue(

          uint256 _propertyValue)

This event indexes the “from” address and the “_propertyUniqueID” bytes32 encoded string of the Property Valuation and archives the event’s property value.

      event PropertyValuation(

          address indexed from,

          bytes32 indexed _propertyUniqueID,

          uint256 propertyValue

      );

event ContributionMade

MUST trigger on any successful call to; 

function contributeToEscrowForProperty(

          bytes32 _PropertyID)

This event indexes the “contributor” address, the “PropertyID” bytes32 encoded string of the contribution made and the event’s escrow number. This event archives the contribution amount and the true-false value of funding complete to indicate the escrow’s completion.

      event ContributionMade(

          address indexed contributor, 

          uint256 amount, 

          bytes32 indexed PropertyID, 

          uint8 indexed escrowNumber, 

          bool fundingComplete

      ); 

event UserSet

MUST trigger on any successful call to either; 

function asetMyUser()

function asetUser(

          address _UserAddress,

          address _Ceva,

          address _FounderDeveloperOne,

          uint8 _UserPrivilegeLevel)

This event indexes the “User” address of the UserSet.

      event UserSet(

          address indexed User

      );

event LicensePurchase

MUST trigger on any successful call to; 

function amemberBuyFounderDeveloperLicense()

This event indexes the “User” address, the “CEVA” address of the, and the “FDone” address of the event. This event archives the “FDTwo” address.

      event LicensePurchase(

          address indexed User,

          address indexed CEVA,

          address indexed FDone,

          address FDTwo

      );

event AVECMinted

MUST trigger on any successful call to; 

function afounderDeveloperMintAVEC(

          uint256 _founderDeveloperFee)

This event indexes the “CEVA” address and the “FD” address, and the “USER” address. This event archives the “AVECMinted”  Amount value and the “AmountEscrowed” value of single tokens.

      event AVECMinted(

          address indexed CEVA,

          address indexed FD,

          address indexed USER,

          uint256 Amount,

          uint256 AmountEscrowed

      );

event EscrowCreated

MUST trigger on any successful call to; 

function createEscrowForProperty(

          bytes32 _PropertyID, 

          address payable _recipientOfFunds, 

          bytes32 _recipientName, 

          uint8 _escrowAgreementNumber,

          bool _override,

          bool _escrowCompleted,

          uint256 _milestonePriceOfEscrowInETH, 

          uint256 _tokensAvailableTotal,

          uint256 _propertyIncrease

          )

This event indexes the “CEVA” address, the “Recipient” address of and the “PropertyID” of the “EscrowCreated” and archives the event’s recipient name bytes32 encoded string value, the milestone ETH amount value, the tokens available single tokens value, and the escrow agreement number.

      event EscrowCreated(

          address indexed CEVA,

          address indexed Recipient,

          bytes32 REcipientName,

          uint256 MilestoneETH,

          uint256 TokensAVAILABLE,

          bytes32 indexed PropertyID,

          uint8 EscrowAgreementNumber

      );

event PropertySet

MUST trigger on any successful call to; 

function asetProperty(

          bool _Set,

          address _FounderDeveloper,

          address _Owner,

          address _holdOne,

          address _holdTwo,

          address _holdThree,

          uint256 _Value,

          uint256 _NumberOfTokensToEscrow,

          bytes32 _PropertyID

          )

This event indexes the “PropertyID” bytes32 encoded string, the “CEVA” address, and the “Value” of the approval and archives the event’s FDOne address value and the “OWNER” value.

      event PropertySet(

          bool Set,

          bytes32 indexed PropertyID,

          address indexed CEVA,

          address FDOne,

          address OWNER,

          uint256 indexed Value

      );

event AVECWithdrawnFromEscrow;

MUST trigger on any successful call to; 

function withdrawAVECFromEscrow(

          bytes32 _PropertyID)

This event indexes the “User” address and the “PropertyID” bytes32 encoded string of the escrow agreement and archives the event’s amount value.

      event AVECWithdrawnFromEscrow(

          address indexed User,

          uint256 amount,

          bytes32 indexed PropertyID

      );

event FeeShareholdSOLD

MUST trigger on any successful call to; 

function aSellFeeSharehold(

          address _toAddress, 

          uint256 _amount, 

          uint8 _envelopeNumber)

This event indexes the “Seller” address and the “Buyer” address of the share-hold sale and archives the event’s amount value in single share-holds sold.

      event FeeShareholdSOLD(

          address indexed Seller,

          address indexed Buyer,

          uint256 amount

      );

event ValueUpdate

MUST trigger on any successful call to; 

function updateRollingPropertyValueMember(

          address _holderAddress, 

          bytes32 _propertyUniqueId)

This event indexes the “User” address and the “PropertyID” bytes32 encoded string value of the value update and archives the “Before” value and the “After” value.

      event ValueUpdate(

          address indexed User,

          bytes32 indexed PropertyID,

          uint256 Before,

          uint256 indexed After

      );

Alright, covering everything about reading from the Wealth Architect Smart Contract with this education, understanding the UI will be much easier. Usually, to figure these things out, it would take a lot of community research but using this page, you can get straight to the point and learn a lot about reading from any ethereum smart contract.

Scroll to Top