Internet Computer Wiki - User contributions [en]

Internet Computer wiki

2023-02-25T10:57:47Z

NikolasHaimerl:

==Welcome!==

This is a general source of information about the '''Internet Computer (IC)''', the world's fastest and most powerful blockchain network<ref>https://medium.com/dfinity/the-internet-computers-transaction-speed-and-finality-outpace-other-l1-blockchains-8e7d25e4b2ef</ref>. Created for and by the IC community, topics vary from cryptography, network governance, user experience, tokenomics, developer tutorials and more.

==Introduction to the Internet Computer==
The Internet Computer is a general-purpose blockchain that hosts [[canister smart contract]]s. It is designed to [[Replace traditional IT with a World Computer|provide a World Computer that can replace traditional IT]] and host a new generation of [[Web3:_The_bull_case_for_the_Internet_Computer|Web3]] services and applications that run solely from the blockchain, without the need for traditional IT. It can also play the role of Web3 orchestrator, by interacting with traditional blockchains.

It has a completely unique design that reflects a ground-up rethink of blockchain architecture and the application of modern cryptography, [https://web.archive.org/web/20150914013643/http://dfinity.io/ which can be traced back to 2015]. It was built by the largest [https://dfinity.org/team ongoing R&D effort in crypto], which has employed many notable cryptographers, computer science researchers and engineers. The blockchain underwent genesis in May 2021 and became part of the public internet.

The Internet Computer blockchain's protocols leverage novel [[chain key cryptography]] to combine multiple [[Limitless_Scaling#Subnet Architecture|subnet blockchains]] into a single blockchain. This allows it to [https://en.wikipedia.org/wiki/Scalability#Horizontal_(scale_out)_and_vertical_scaling_(scale_up) horizontally scale] the total volume of hosted [[canister smart contract]], and their computations and data, without limit. These smart contracts run at web speed, and with web-levels of efficiency, and uniquely, thanks to the blockchain architecture enabled by chain key crypto, can process HTTP requests and directly and securely serve interactive web experiences to the end-users of web3 services, without need for trusted intermediaries (whereas on other blockchains, the web experience users interact with is generally built on centralized, insecure and trusted servers or cloud computing services).

Through these kinds of unique capabilities, the Internet Computer provides a platform that can be used to build mass market web3 services that run 100% on-chain, without any need for traditional IT, such as web servers and databases running on cloud computing services. The longer-term objective is that the Internet Computer will completely replace traditional IT, creating a ''blockchain singularity'', in which everything runs fully on-chain in powerful new forms where it is unstoppable and cannot be hacked.

The development of the Internet Computer has heralded numerous notable technological developments, such as [[chain key cryptography]] and programming languages such as [https://wiki.internetcomputer.org/wiki/Motoko Motoko]. In another notable advance, the Internet Computer hosts an advanced [https://en.wikipedia.org/wiki/Decentralized_autonomous_organization DAO] within its protocols, called the [[Network Nervous System]], which provides the community with direct control over network governance, and can upgrade the protocol running on its network nodes, without requiring the network to fork. The network's utility token is ICP (see [[Roles of the ICP utility token]]).

A recent new technological advance has extended the Internet Computer's [[chain key cryptography]] protocols. This has enabled smart contracts hosted on the Internet Computer to directly interact with other blockchains, without need for dangerous centrally-controlled bridges or wrapping (see [[trustless multi-chain web3 using the IC]], and [[Extend Bitcoin, Ethereum and other blockchains|extending Bitcoin, Ethereum and other blockchains]]).

For example, a canister smart contract hosted on the Internet Computer can create bitcoin addresses, and directly send and receive bitcoins on the Bitcoin ledger as though it were hosted by the Bitcoin network itself. This is possible because chain key crypto enables blockchains to create public "chain keys", for which their nodes can create corresponding signatures. Recent work has now made it possible to create ECDSA chain keys. Since [https://en.wikipedia.org/wiki/Elliptic_Curve_Digital_Signature_Algorithm ECDSA] is the signature scheme used by most other blockchains, this means the Internet Computer can create TX on other blockchains.

Future work will enable its smart contracts to directly interact with other important blockchains such as [https://ethereum.org/en/ Ethereum]. This also leverages other important features such as [[HTTPS outcalls]]. As a consequence, many believe that the Internet Computer will play the role of an orchestration layer that combines different blockchains in the web3 environment, and helps combine them with off-chain services and systems, such as Web 2.0 services and enterprise systems, in a trustless way.

===Popular places to start===
* '''The Internet Computer project website (hosted on the IC): [https://internetcomputer.org/ internetcomputer.org]'''
* [https://www.youtube.com/watch?v=IfM3I8pudFs&t=327s Internet Computer overview video from 2022 IC hackathon]
* [https://www.youtube.com/watch?v=IfM3I8pudFs June 2022 IC hackathon, full launch video]
* [https://internetcomputer.org/icig.pdf Internet Computer Infographic (PDF)]

* [[Glossary]]

===For a general audience===
* [[Internet Computer overview]]
* [[Internet Computer vision]]
* [https://internetcomputer.org/roadmap/ Internet Computer roadmap]

===For a more technical audience===
* [https://eprint.iacr.org/2022/087 "Internet Computer for Geeks" paper]
* [[IC architecture overview]]
* The [https://internetcomputer.org/howitworks "How it works" series] with videos and in-depth articles on various topics.
* [https://www.reddit.com/r/dfinity/comments/ozboyi/megathread_technical_amas/ Technical AMAs on Reddit by different IC and DFINITY teams]

== Internet Identity Introduction ==
One of the core benefits of building on the Internet Computer is that end users do not need to pay fees or use tokens to access and use dapps. As an alternative to authenticating from a wallet, users can authenticate with an Internet Identity. Learn more information about Internet Identity (II), a blockchain authentication framework supported by the Internet Computer:

* [[What is Internet Identity]]
* [[How to create an Internet Identity]]
* [[Internet Identity technical overview]]
* [https://identity.ic0.app/ Internet Identity dapp]

==IC for Dapp Users ==

If you use or are interested in using dapps on the Internet Computer, this section will help you understand the user experience benefits of the IC, how to use Internet Identity, or find more IC dapps.

Examples:
* [[Introduction to the Internet Computer for dapp users]]
* [[Index of dapps on the Internet Computer]]

See more in [[Internet Computer for dapp users]]

== IC for ICP Token-holders, Stakers, and Neuron Holders==

The Internet Computer is governed by on-chain governance system called the Network Nervous System (NNS). To participate on governance, users need to stake ICP tokens. This section will explain how the NNS works, ICP tokens, staking, and options for managing one's ICP.

Examples:
* [[ICP token]]
* [[Tutorials for acquiring, managing, and staking ICP]]
* [[Staking, voting and rewards]]
* [[Governance of the Internet Computer]]
* [[Network Nervous System]]
* [[Total supply, circulating supply, and staked_ICP]]
* [[NNS neuron operations related to maturity]]

See more in [[Internet_Computer_token-holders,_investors_and_neuron_holders|Internet Computer token-holders, investors, and neuron holders]].

== IC for Smart Contract and Dapp Developers ==

The Internet Computer (IC) is a new platform for executing smart contracts. This section contains information for developers, including links to documentation, developer forums, and relevant dashboards.

Examples:
* [[Canisters (dapps/smart contracts)]]
* [https://smartcontracts.org/ Developer documentation on smartcontract.org]
* [https://forum.dfinity.org/ IC community developer forum]


* [[Bitcoin integration]]
* [[SNS Tokenization Considerations]]
* [[Web Speed]]
* [[Web Serving]]
* [[Limitless Scaling]]
* [[Users interact with dapps without tokens]]
* [[Parallelism]]
* [[Error Codes returned by Internet Computer]]

If you've been programming smart contracts on Ethereum before, you should read [[The Internet Computer for Ethereum Developers]].

See more in [[Internet Computer for smart contract and dapp developers]].

== IC for the Curious, Researchers and Blockchain Enthusiasts ==

This section is for those interested in how the Internet Computer works under the hood. It touches many different subject areas from cryptography, consensus protocols, virtual machines, operating systems, networking, distributed systems, etc.

Examples:
* [https://internetcomputer.org/howitworks/ How the Internet Computer Works]
* [https://dashboard.internetcomputer.org/ Internet Computer dashboard]
* [[Internet Computer performance]]
* [[DFINITY Foundation]]
* [[Bitcoin integration]]
* [[Third-party security audits]]
* [[Networking]]
* [[Replicated state structure]]
* [[New Subnet Creation]]
* [[Catch-Up Package]]
* [[Summary Block]]
* [[ICP technical design documents]]
* [[Boundary Nodes]]

== For Node Providers ==
Node providers invest in and operate node hardware, which powers the Internet Computer with processing and storage capacity. Running these nodes in data centers provides the high performance and the cost-effectiveness of the Internet Computer. Every node provider is allowed a limited amount of nodes.
* [[Node Provider Onboarding]]
* [[Gen-2 Data Center runbook]]
* [[Gen-2 Network Requirements]]
* [[Node rewards]]
* [[Node Provider Remuneration]]
* [[Node Provider Self-declaration]]
* Gen-1 Documentation:
** [[IC OS Installation Runbook - Dell Poweredge]]
** [[IC OS Installation Runbook - Supermicro]]
** [[Possible Node Onboarding Errors]]
** [[Storage Runbook]]
** [[Retrieving_a_Dell_TSR_Log|Assistance with iDRAC, TSR logs, and more]]

== Technical Working Groups ==
* [[Identity & Authentication]]
* [[Developer Tooling]]
* [[Ledger & Tokenization]]
* [[Scalability & Performance]]
* [[Education]]
* [[Governance]]

== FAQs, Tutorials, and How-tos==
Tutorials are guided introductions to user stories, intended for first-time users and characterized by a shallow learning curve. How-Tos are step-by-step instructions for specific, narrow goals.

===FAQs===
* [[FAQ]]

===Best Practices===
Example:
* [[Managing ICP holdings]]
* [[Managing Internet Identity]]
* [[Maximizing Voting and NNS Rewards]]
See more in [[Best Practices]]

=== Tutorials ===
Example:
* [[Tutorials for acquiring, managing, and staking ICP]]
* [[How-To: Claim neurons for seed participants]]
* [[How-To: Create an NNS motion proposal]]
* [[How-To: Set your neuron to follow another neuron]]
* [[How-To: Updating neuron following via quill]]
* [[How-To: Join the Community fund via quill]]
* [[How-To: SNS tokenomics configuration]]
* [[How-To: SNS sale participation via quill]]

See more in [[How-Tos]].

==Contributing to the Wiki==

=== How to contribute ===
Anyone can read the wiki. You can also edit pages, all you need to do is [https://wiki.internetcomputer.org/wiki/Special:CreateAccount create an account]. See more in [[Contributing to the wiki]].

==See Also==
* '''The Internet Computer project website (hosted on the IC): [https://internetcomputer.org/ internetcomputer.org]'''

How-To: SNS swap participation via quill

2023-02-24T09:03:20Z

NikolasHaimerl: Created page with "__NUMBEREDHEADINGS__ The goal of this page is to explain how to participate in the SNS sale via quill. == Background and objective == * We assume that you have a working insta..."

__NUMBEREDHEADINGS__
The goal of this page is to explain how to participate in the SNS sale via quill.
== Background and objective ==
* We assume that you have a working installation of quill and are familiar with the tool. For an introduction into quill, please see [https://medium.com/dfinity/introducing-quill-a-ledger-and-governance-toolkit-for-the-internet-computer-1df086ce5642 here]. For instructions on how to install and use quill please see the readme on [https://github.com/dfinity/quill GitHub] and the [https://internetcomputer.org/docs/current/references/quill-cli-reference/ quill documentation].
* For local testing with a local testnet see the corresponding [https://internetcomputer.org/docs/current/developer-docs/integrations/sns/get-sns/local-testing documentation]
* More information on SNS can be found [https://internetcomputer.org/sns/ here]
== Quill commands to participate in an SNS sale ==
For some more information on the commands that you can run with quill run '''quill help''' or '''quill sns help''' for SNS-specific commands.
=== Prerequisites ===
* PEM file: To use quill you need your secret key in a PEM file. For help on how to create new identities and manage them see the corresponding documentation for dfx [https://internetcomputer.org/docs/current/references/cli-reference/dfx-identity#:~:text=dfx%20identity%20new%E2%80%8B,new%20command%20in%20any%20project. here]. Save the path to the PEM file as you will need it later. The content of the PEM file should look something like this:
<pre>
-----BEGIN EC PRIVATE KEY-----
MHQCAQEEICJxApEbuZznKFpV+VKACRK30i6+7u5Z13/DOl18cIC+oAcGBSuBBAAK
oUQDQgAEPas6Iag4TUx+Uop+3NhE6s3FlayFtbwdhRVjvOar0kPTfE/N8N6btRnd
74ly5xXEBNSXiENyxhEuzOZrIWMCNQ==
-----END EC PRIVATE KEY-----
</pre>
* Canister Ids file: You will need a file which stores the mappings of canister ids to their names. It should look something like this (Note: The actual ids will be different for the sale you want to participate in):
<pre>
{
"root_canister_id":"sgymv-uiaaa-aaaaa-aaaia-cai",
"governance_canister_id":"sbzkb-zqaaa-aaaaa-aaaiq-cai",
"index_canister_id":"s24we-diaaa-aaaaa-aaaka-cai",
"swap_canister_id":"sp3hj-caaaa-aaaaa-aaajq-cai",
"ledger_canister_id":"si2b5-pyaaa-aaaaa-aaaja-cai"
}
</pre>
You can find the correct canister Ids from [https://dashboard.internetcomputer.org/canister/qaa6y-5yaaa-aaaaa-aaafa-cai the SNS-W]. Click ‘+’ next to list_deployed_snses, and then click “Call”.
Create a file called canister_ids and insert the SNS canister ids in the format from above.

=== Check Status of SNS ===
To verify that your setup works and the SNS is up and running.
<pre>
quill --pem-file <path> sns --canister-ids-file <path> status
</pre>
Quill will ask you to sign and send this transaction. The response will be a description of each canister that make up the SNS. For participation in the SNS sale the canister "swap" is important. It should look something like this:

<pre>
swap = opt record {
status = opt record {
controller = principal "r7inp-6aaaa-aaaaa-aaabq-cai";
status = variant { running };
freezing_threshold = 2_592_000 : nat;
balance = vec { record { blob "\00"; 30_000_000_000_000 : nat } };
memory_size = 11_029_070 : nat;
cycles = 30_000_000_000_000 : nat;
settings = record {
controller = principal "r7inp-6aaaa-aaaaa-aaabq-cai";
freezing_threshold = 2_592_000 : nat;
controllers = vec { principal "r7inp-6aaaa-aaaaa-aaabq-cai" };
memory_allocation = 0 : nat;
compute_allocation = 0 : nat;
};
idle_cycles_burned_per_day = 0 : nat;
module_hash = opt blob "d\92\91\d2W:^\05\d9\ac\ec\a0\cd\a6=\de\df\1b\0f\c9\86\e6\8d\86+\d0\01\8b\f8f\81\b1";
};
canister_id = opt principal "sp3hj-caaaa-aaaaa-aaajq-cai";
};
</pre>
It's vital that the canister's status in '''running'''.

=== Getting SNS Sale parameters ===
Before being able to buy any tokens, it is important to know what the parameters of the sale are. You can query them via '''dfx''':
<pre>
dfx canister --network https://ic0.app call <swap_canister_id> get_sale_parameters "(record {})"
</pre>
The response should look something like this:
<pre>
(
record {
params = opt record {
min_participant_icp_e8s = 100_000_000 : nat64;
neuron_basket_construction_parameters = opt record {
dissolve_delay_interval_seconds = 31_536_000 : nat64;
count = 3 : nat64;
};
max_icp_e8s = 50_000_000_000 : nat64;
swap_due_timestamp_seconds = 1_677_398_018 : nat64;
min_participants = 3 : nat32;
sns_token_e8s = 500_000_000_000 : nat64;
sale_delay_seconds = null;
max_participant_icp_e8s = 20_000_000_000 : nat64;
min_icp_e8s = 5_000_000_000 : nat64;
};
},
)
</pre>
The important parameters for the payment flow are the '''min_participant_icp_e8s''' and '''max_participant_icp_e8s''' with the former being the minimum amount of ICP per particpant and the latter being the maximum amount of ICP per participant to participate in the sale. Note that for your first payment you will have to pay with at least as many ICP as the number '''min_participant_icp_e8s''' suggests, otherwise your request will be denied. Any purchase after that can be of any amount as long as the total amount of ICP used for purchases is not higher than '''max_participant_icp_e8s'''.
=== Getting a Ticket ===
The first step in the actual payment flow is to acquire a ticket via quill. You can specify the amount you want to purchase but note that for the first time, it has to be at least as high as '''min_participant_icp_e8s'''.
The first command to get a ticket will create the transaction and has to be stored before it can be sent. For that purpose choose a path for this tx.json file:
<pre>
quill --pem-file <path> sns --canister-ids-file <path> new-sale-ticket --amount-icp-e8s <amount_to_be_purchased> > PATH/tx_new_ticket.json
</pre>
To do a dry run of this transaction run
<pre>
quill --pem-file <path> sns --canister-ids-file <path> send --dry-run PATH/tx_new_ticket.json
</pre>
It will show you the full transaction without sending it. To actually send the transaction use:
<pre>
quill --pem-file <path> sns --canister-ids-file <path> send PATH/tx_new_ticket.json
</pre>
The response will look something like this:
<pre>
(
record {
result = opt variant {
Ok = record {
ticket = opt record {
creation_time = 1_677_227_094_330_351_716 : nat64;
ticket_id = 2 : nat64;
account = opt record {
owner = opt principal "iowfl-yzooa-br3dt-77erl-nlm7f-kplhq-php75-hw3an-aeqn2-swh4t-3qe";
subaccount = null;
};
amount_icp_e8s = 100_000_000 : nat64;
};
}
};
},
)
</pre>
In this case, the amount specified was 100 Million e8 ICP. The important information here is the '''ticket_id''' and the '''creation_time''', you will need them in the next step. Note that you cannot create another ticket while a ticket is still open. Use the ticket within 24 hours or the time stamp on the ticket will be outdated and it can no longer be used. To delete an existing ticket call:
<pre>
dfx canister --network https://ic0.app --identity PATH/identity.pem --update call
<swap_canister_id> notify_payment_failure "(record {})"
</pre>
Now you can request a new ticket.
=== Sending the Payment Transaction ===
A ticket was created and the actual payment can now be done. Similarly, to the previous step you have to create a file for the transaction, optionally perform a dry run to see the transaction before sending it and the send the transaction to the Internet Computer. Note that the creation_time format from the ticket has to be changed from ''''1_677_227_094_330_351_716''' to '''1677227094330351716''' for the payment transaction to accept the timestamp format.
The three commands are the following:
<pre>
quill --pem-file <path> sns --canister-ids-file <path> pay --amount-icp-e8s <amount_to_be_purchased> --ticket-creation-time <creation_time> --ticket-id <ticket_id> > PATH/tx_pay.json
</pre>
To do a dry run of this transaction run
<pre>
quill --pem-file <path> sns --canister-ids-file <path> send --dry-run PATH/tx_pay.json
</pre>
and send it with:
<pre>
quill --pem-file <path> sns --canister-ids-file <path> send PATH/tx_pay.json
</pre>
You will have to sign multiple transactions during this process.
The response will look something like this
<pre>
(
record {
icp_accepted_participation_e8s = 100_000_000 : nat64;
icp_ledger_account_balance_e8s = 100_000_000 : nat64;
},
)
</pre>
The return value '''icp_accepted_participation_e8s''' shows how many ICPs were already accepted in the SNS sale and the return value '''icp_ledger_account_balance_e8s''' shows how many ICPs have been sent to the SNS sale canister. If at the end of the sale, these two numbers are not equivalent and '''icp_ledger_account_balance_e8s''' is greater than '''icp_accepted_participation_e8s''' you can get a refund of your ICP that were not used in the SNS sale after the sale has concluded. Should the SNS sale abort you will get the amount '''icp_accepted_participation_e8s''' refunded automatically.
=== Checking your balance ===
To query your balance of all accepted ICP during a SNS sale run
<pre>
quill --pem-file <path> sns --canister-ids-file <path> get-sale-participation
</pre>
To query your balance of the SNS ledger run
<pre>
quill --pem-file <path> sns --canister-ids-file <path> balance
</pre>
While the sale is still ongoing the return will most likely be
<pre>
(0 : nat)
</pre>
This is the balance of the SNS ledger which will '''NOT''' be updated until the sale is over and the SNS tokens are allocated. Thus, any purchase you make during the sale will not be visible through this command.
To check your balance of tokens that have already been committed and the total amount of ICP you have sent to the SNS sale canister you need to look at the return value of when you called '''pay'''.