💙Aleo Synthesis
This is a synthesized version of the published Aleo documentation (September 25th, 2022)
Last updated
This is a synthesized version of the published Aleo documentation (September 25th, 2022)
Last updated
Author Dylan Kawalec
Overview : goal, performant, secure, anonymous // Goal : Make any application runtime environment that allows your software to compile, execute, and finalize its state autonomously.
account seed generates – places is inside the proving key?
Secret key : Account Signature Scheme
Pseudorandom function seed : Tx Serial Numbers
Commitment randomness : Account commitment scheme
Viewing Key = (Base58 string = AViewKey1) decrypt account records, which are encrypted under the user's account address.Derived from the Private Key, it can decrypt records from the global ledger.
Secret Key : Account encryption scheme
Private Key = ( “Base58 string” - Encoded with a APrivateKey1) which essentially labels it as a “PK”. This will authorize a transaction, which updates the global state of account records. This is randomly constructed from an account seed.
Account Address = (“Bech32 string”, comprised of 63 characters - aleo1)enables users to interact with one another, sending and receiving records that encode values and application data.
Public Key : account encryption scheme
(View key decrypts the account, the account key allows interactions and encrypts values that are sent which then the private key verifies the Tx, and then updates the state of the account. The Private key is constructed from the account seed which generated the Secret key, pseudo key, and commit random scheme. )
proving key = (“Base58 string” == AProvingKey1) similar to an auditable private key that 3rd parties can use on behalf of the owner. It cannot spend on behalf of the prover, but it can access and view data.
Consists of
Public key : account signature scheme
Pseudorandom function seed : from account private key
Commitment randomness : From account private key
"Programs" help describe an Aleo application's state & logic, a framework known as “Aleo instructions” (Leo) is used to describe anonymous programs. Leo is similar to rust because it is statically typed and acts as the assembly language for writing Zero Knowledge Proving systems.
Program ID’s are stored in the program.json manifest inside of the records bin.
Program inputs are deposited and proven before they are sent to the public network to be verified as a note. This allows the user to make private inputs. Program State means that we follow a set of instructions inside of the program’s records that satisfies the overall state of the program, which means it uses a series of “gates” (input, cast, sub, output). Records.
A record is a data structure meant for storing applications assets, and the state of those assets. It’s very similar to an interface, because Words like address, private, public are methods.
Owner is the account holder, Gates store credits in the form of An integer value which does or Does not allow date to be passed, Data is a byte map of arbitrary information. A nonce is created once the transaction is made. All records are encrypted before stored On chain, and can only be opened or viewed by The sender or receiver with the right View key.
What you need to know...
Formally verified - the compiler does not deviate from the intent of the programmer.
Registrars store data for later use.
The keyword interface, is a struct type, similar to classes in other traditional languages.
The idea of leo, is to pass records into the state to be modified per transaction. All records are replaced after each transaction.
There are instructions (function keywords) we can use, such as add, cast, input.
"Functions", must be within scope and can use helper functions called closures that can run within the function’s scope.
"Mappings", contain key value pairs (key, value)
"Finalize", executes the logic of the program's function.
There’s a list of Opcodes that allow for methods to be used in a program.