"min-ada" bottleneck to Cardano analogous to "gas fee congestion" for Ethereum?

No, it would not be a bottleneck if Cardano implements babel fees that will enable you to pay (actually arbitrage) your fees in different tokens.
That being said, to keep a decentralized network secure, you always offer something of value for the work of validation blocks. Also, the author of the transaction might not be necessarily be the same party that pays for it.
In the future, most of the transaction will be probably one layer above (for example Hydra) and the final fee will be paid only for a settlement.


I would argue the Yoroi browser extension is much safer than the iOS application.
Browser extensions provides double-sandboxing and is considered safer than most of the desktop applications. The browser itself is sandboxed from the rest of your computer and the extensions itself is sandboxes from talking directly to other extensions or to other websites unless you explicitly approves it can do so.
That being said, the most important element in the this process are your private keys. So, whatever you are using Daedalus or Yoroi, always protect your private keys by using a hardware wallet.


There is no support for decimal places of native tokens on Cardano.


Here is a quick brainstorm.
Web Presence

Create a Website
- You should have your own URL
- Get a basic knowledge of SEO and follow the rules.
Dedicated Twitter account and follow and comment on everything ADA/Cardano
Start a dedicated YouTube account and start creating content geared toward your target market. Could be how-to videos, current events, price action talk, interviews, reviews of catalyst proposals and funded projects, developer stuff, education...
Other social media accounts could include TicTok, Instagram, Facebook, Twitch, etc.
Answer and Ask questions on stack exchange.
Create a Discord for your delegators, be available and quick to communicate.
Do lottery's, giveaways, rewards, raffles, NFTs, Merch, etc.
Collaborate with an artist to start making NFTs published by your brand.
Paying for advertising would come after all this stuff. You need to have something for people to see when they start looking into your pool.
Be yourself. You are unique and you have something to offer that no-one else does.

Real Life

Get some Cardano branded stuff and wear it.
Become active in your region. Start/join meet-up groups. Talk to people about Cardano.
Get some gear with your own stake pool brand on it and wear it. Give it to friends and family.
Give ADA, Native Tokens, NFTs as gifts to friends and family.
Attend conferences.


Plutus Pioneer Program - Problem with plutus playground client

Seems strange for it to be a timeout issue (though I'm not an expert) as the server and the client should both be running on your laptop. I followed the steps as shown in Leet Dev's YT channel - is that what you did to?


What are oracle services going to look like on Cardano?

An early oracle-like service nut.link run by the community is already running. It will not provide data to smart contacts, but various dApps might be able to consume its resources if they can read on-chain data.
As for real oracle solutions that will be able to provide inputs to smart contacts, we will have a lot of them, from community to IOG.
In fact, most of the work on oracle pools has already been done by Emurgo, not IOG. And implemented on Ergo.


This won't be possible, because Solidy and Plutus are both different languages and even the blockchain accounting system is different on both platforms.
There might be a side chain running KEVM in the future, where you will be able to run Ethereum smart contact and somehow interact with the Cardano mainnet, but this is still just in the planning at the moment and nothing specific has been shared to mention we will have this anytime soon.


What is the maximum number of contracts Cardano can store?

In Cardano, the smart contractors are submitted as transactions with a validator script. Funds locked in the smart contract are in UTXO with the address as the "Script Address". And based on three parameters called datum, redeemer, and context, the validator script provides the go-ahead for the release of funds.
Based on this setting theoretically, there is no limit to the number of deployable smart contracts since there is no limit on how many transactions can be submitted to the blockchain. The size of Datum, which can carry some bit of data, is yet to be promulgated.


How are DeFi projects funded (beyond Project Catalyst & external funds)

You are indeed right. I have seen plenty of DeFi projects get their funds by offering a 2017-style ICO model. YaySwap (not an endorsement, just an example) is one of these projects that takes ADA and plans to distribute their YAY token.
Uniswap also takes a fee. Then there's the genesis allocation to team, investors etc.


What is the difference between "Voltaire" and "Project Catalyst"?

Voltaire is the more general, umbrella term for all governance that will eventually be included in the Cardano protocol. This will include modifications to protocol level parameters such as "a0" and "k" (nOpt), CIPs (Cardano Improvement Proposals), as well as funding initiatives. The funding initiatives are what fall under the Project Catalyst arm of Voltaire.
Project Catalyst is like a beta for the eventual on-chain voting mechanisms that will be put in place. With Project Catalyst, the community can use their ADA as voting power to select projects that they want to see developed using funds from the treasury. The treasury funding will ultimately come only from a portion of the transaction fees. For now, some of the funding also comes from the reserves. You can see the monetary policy here.
Also, the Cardano Foundation webpage on Voltaire and governance: https://cardano.org/governance/


Could the CF (15 million) and IOG (3 million) funds be split between more small pools?

Yes, they could.
I think this question should be directed to these parties.


Where can I find Cardano's academic research papers?

IOHK has a list of papers and currently I see 103 of them:
https://iohk.io/en/research/library/


Voting on Catalyst with Ledger hardware wallet

Yes, firmwares updates for this feature has been already submitted to both Trezor and Ledger.
Now, it is up to them, when they will release an update of their firmware to their customers.


The node does support multi-signatures (for instance you can do a multi-signature when minting NFTs). However, the wallets do not yet support this. But its coming eventually!


Is there a Daedalus wallet planned for mobile devices (Android and/or Apple)?

There is however a talk about Daedalus lite for mobiles. Charles mentioned it a couple of times. But I dont think any time soon. It will be part of the next 5 year plan from IOG. But there will definitely be a Daedalus lite one day. For now its Yoroi!


Staying secure for every day users: What recommendations do security experts have for wallet management, safety, maintenance?

Some specific answers to your questions.

I don't know that there is a great answer to this. Your options range from putting it on paper and in a safe deposit box in a bank, to storing it one word at a time in random places (like an escape room scenario). There are some very cool physical devices for storing seed words that are made if metal to be fire resistant. Basically you use a punch to mark the seed words in the metal.

Hardware wallet backups are similar. You just have a list of seed words that you need to protect. One nice thing about Hardware wallets is that you can restore a second or third wallet with the same seed phrase and store them in separate locations.

This depends on your family and estate management scenario. Do you trust your family? It can be a good idea for you to share the details of your wallet with a spouse or parent that can manager your funds if you are incapacitated. You can also have safe-deposit box ownership be transferrable to someone should you become incapacitated and inside have instructions for them on how to manage your funds (a will helps here).

Some more thoughts...
Wallet safety, as any other cyber security question, comes down to risk vs. effort. That is, how much is what you are trying to protect worth and how much effort and expense are you willing to put it to protect it? The billions of dollars in Bitcoin on the Tesla balance sheet is managed much differently that my grandpa's $100 of crypto.
This is of course up to the individual, but something like below is what I tell people.

< $100 worth
Standard software wallet with seed phrase in a password manager shared with a family member is probably fine.
In between is kind of a grey area.
> $1000
This should definitely be on a hardware wallet if possible. Family members can share the PIN/passphrase (ex. in case of emergency who can access your funds?). The seed phrase (hardware wallet backup) should be stored off of a computer! You can store the seed in multiple places such as a home safe or bank safe deposit box if available (again your level of risk will help determine this). It's also probably a good idea to leave instructions for family.
~$1M I probably wouldn't want these seed words stored in my house...


How does the ERC20 converter actually work?

From the IOHK blog post: Bringing ERC20 to Cardano

Our ERC20 converter is a tool that will allow issuing organizations
and their users to handle ERC20 token migration to Cardano. It is
designed for token issuers (organizations that wish to enable the
migration of their tokens to Cardano), and their users (token holders)
to use the tool to move their ERC20 tokens to the Cardano network.
Users can convert their Ethereum tokens in just a few clicks, and when
moved across, these tokens will be ‘translated’ into a special native
token on Cardano that has the same value and works just like an ERC20.
Additionally, if the user wishes to do so at a later stage, they can
move their tokens back to the source network by burning them on
Cardano. Two-way convertibility is baked in.

After logging into the ERC20 converter, Users must authenticate their source account via Metamask and provide their Daedelus address for token delivery.  Tokens are then migrated to to the Cardano address.  All operations on the migrated token are visible on both Cardano explorer and Etherscan
Conversion is token specific and adding a token for conversion requires partnership to add a token to the list of tokens available for conversion.


There is a plan to port Solidity to Cardano. I believe there's even a running prototype. There are also plans for a cross-compiler that would transform most popular languages into Plutus. But personally, if you intend to jump in with both feet, I think it's worth learning the native language. For help getting started, look for the Plutus Pioneer lecture videos.
I see two major advantages in adopting Cardano today.

Transaction fees are demonstrably and vastly cheaper than Ethereum which is attractive to you and your end users.
Striking early, now, gives you a first-mover advantage to a captivated audience.


Can Marlowe contracts involve native assets?

Yes.
Marlowe is essentially a layer over top of Plutus Core and so it can access and/or manipulate anything that Plutus Core based Smart Contracts can access including native assets/tokens. Marlowe is more restrictive than Plutus but only in terms of computation to allow for easier/automated static analysis.
https://docs.cardano.org/en/latest/marlowe/marlowe-lang-guide.html


Its well known that Atala PRISM allows people to deal with Decentralized Identifiers (DIDs) and Verifiable Credentials (VC), this is a simplified version on how it could work, which should give you a better idea.
Let's take Cardano as a black-box that allow us posting data by leveraging the transaction metadata, which gives the distributed consensus (to make sure that an event occurred at a given time) and network dissemination (to be able to get the data distributed).
DIDs are known to have public keys attached, which means that whoever controls the corresponding private keys, controls the DID, we can define some events about a DID, like:

DID created
DID updated (key added/rotated/revoked, etc)

By using those events, we can define the following:

The way to serialize an event to store it in the transaction metadata.
The validity criteria to check whether a new event is valid given the existing events (digital signatures and hashes involved).

Until now, we have defined a protocol that allows posting events to Cardano, as well as to compute the current state given the existing events in Cardano, implementing such protocol would require an application that:

Provides an API to submit new events to the Cardano network.
Runs a process that pulls transactions from the Cardano network, looking for the defined events, validates and applies the events when possible (computing a new state).
Provides an API to query for the current state, for our example, it would mean being able to query which DIDs exists and each DID's state.

For PRISM, there is a similar protocol defined with a different set of possible events, including how to deal with credentials.


What are the technical difficulties with implementing voting on hardware wallets?

One of the main problems with adding new features to hardware wallets is the long update cycle.
Developers can't just upload a new version. A hardware wallet like Ledger Nano series can only get an update once a month, and it has to go through a 3rd party process beforehand.
Therefore, they lag a bit behind in functionality. You don't usually do iterative updates on hardware wallets. Instead, you release one when it's ready.


What is the difference between Plutus (Marlowe) and Glow?

Plutus is specific to Cardano while Glow works across multiple blockchains. Saying this, Glow is a 'domain specific language' which is only meant to be used for programming DApps while Plutus is a Haskell library.


How do i calculate the fingerprint of an asset?

As per CIP14: User-Facing Asset Fingerprint, we calculate it as:
assetFingerprint := encodeBech32
  ( datapart = hash
    ( algorithm = 'blake2b'
    , digest-length = 20
    , message = policyId | assetName
    )
  , humanReadablePart = 'asset'
  )

Or you can just use an existing library, such as cip14-js by Emurgo.


Is Cardano working on any solutions to work out disputes between parties?

I'm a little torn here about whether the question will attract opinion-based responses. If answered with facts only then a smart contract has already defined rules, if they are fulfilled there is no room for dispute. Means: Either everyone agrees to these rules or no contract is concluded.
Of course, these results may not meet the expectations of the contractual partner, but this is fundamentally not the problem of smart contracts and to discuss this Stack Exchange is not the right place. For such open questions and extensive discussions, e.g. forum.cardano.org would be a good place.


The pragma {-# LANGUAGE NoImplicitPrelude #-} and
import PlutusTx.Prelude might help.
It replaces the implicitly defined functions in Haskell by inlinable alternatives. Here is an example for Boolean operators.


How can an oracle guarantee certain update rates respectively uptime?

If they are consumed, the provider would just create new UTXOs from the fees they have collected.
Keep in mind, an oracle would have to consume all of its UTXOs anyway to update the price.


What prevents a bad user to provide a wrong signature to a transaction?

I don't know the specifics, but I believe under the hood the corresponding private key is used to sign the transaction and the public key is used for verification. So you cannot use any other public key, since you do not know the corresponding private key.


How do I determine who the moderators are for Project Catalyst?

The members of the campaign team are listed at the bottom of the "about" tab for each challenge (Ideascale calls them campaigns)
e.g. for the "Dev Ecosystem" challenge, they are listed at the bottom of this "about" tab.


Ideal computer specifications for own staking?

To earn staking rewards, there is no requirement to run your own pool. You can use Yoroi app for Phone or Daedalus application for Computer. You can delegate to pools in the app and earn rewards. Ensure that you are using a verified application else you will lose your funds to scammers.
If you want to start run a stake pool, please read about the economics of running a stake pool. You will require about 1M ADA to run a profitable stake pool at the moment. If you have less money, you need to find people with this much ADA to delegate to your pool. Currently, there are about 2500 pools, and it's a tough business to get delegators.
The recommended specifications for a topology of a stake pool are 1 - Block Producer Node and 2 Relay Nodes. The configuration reference of the computer for this node are:

4 GB of RAM (8-12 GB ideal)
24 GB of hard disk space (200 GB Ideal)
a good network connection and about 1 GB of bandwidth per hour
a public IP4 address


There is no way to burn ADA.
You can burn the native tokens, if you have the singing keys for the tokens policy and the policy allows it.
If the policy doesn't allow it (locked by time slot), at the moment, there is no way to burn them, but IOG is going to introduce a way to do it in the near future, so keep them around.


Why are staking rewards still coming to my Daedalus wallet when I moved the funds to a hardware wallet?

You start getting rewards 3 epochs after you first delegate. You will be getting your reward for the next 3 epochs after you move, unless you undelegate and get your 2 ada you deposited at first.


Are there safeguards preventing big centralised exchanges like Binance and Kraken from having too much power in projects like Catalyst?

The current voting process is anonymous. It will be impossible to prevent any major ADA holders from influencing voting to favor a particular project proposal and take money from Treasury. However, robust safeguards are in place. These are as follows:-

The proposal goes through an open assessment process. Most probably, a
pure money-draining proposal will get highlighted and will be assigned a lower rating.
Voting security has features very similar to the proof of stake therefore even for a major exchange, and it will be almost impossible to push through a wrong project.
Most importantly, Catalyst projects are the ones that are going to add value to
Cardano. Therefore any major holder of Cardano will not be
undermining Project Catalyst since it is only going to hurt his
interest.

Like all features of Cardano, the catalyst process seems to be designed following "game theory". It is designed so that unless one is in self-harming mode and holds more than 50% of ADA in circulation, a successful proposal is not likely to be a pure scam. Will they be able to influence the outcome? Yes, they can and should in a positive way for their own good.


You can learn more about the Basho phase at the Cardano Roadmap, but I will briefly summarize what it says.
The Basho phase is focused on improvements to scalability and interoperability, this will improve the performance of the Cardano network as it grows and transaction volumes increase. One important core development this phase will bring is the implementation of sidechains, which are new blockchains that are interoperable with the main chain. Basho will also allow for parallel accounting styles, meaning that while the main chain uses the UTXO model, a sidechain could use account-based models giving the ability to support and switch between the two models.
I hope my brief summary helps, but you should definitely look at the road map for more information.


How to import Yoroi seed phrase to computer using cardano-address for use with cardano-cli?

You can use Daedalus to restore your wallet on the machine and that should create a wallet file with the addresses you need.  Daedalus also contains cardano-cli as its built on cardano-node.
I did not try launching cardano-node / cardano-cli from a Daedalus install though, there may be additional wrinkles to solve.


Is there a maximum amount of ADA I can send in one transaction?

The limit amount of output ADA is specified as Word64 which is an 64-bit unsigned integer, therefore the maximum output is 18 446 744 073 709 551 615 lovelaces in the current implementation.
So, sending all 45 billion of ADA is theoretically possible.


What are Catalyst "challenge setting" challenges for?

A "challenge setting" challenge is how the Catalyst community chooses the themes and funding for some of the Catalyst challenges following the next six-week cycle.
They are significantly different than most other challenges.

No reward is given to proposers
Proposals suggest new challenges
They do not contains proposals or solutions
Funds requested become the budget of the challenge
The outcome takes 3+ months to complete

There is a long lead time on funds proposed in the challenge budget being delivered to the proposals that win in the resulting challenge.  If the challenge has a timeliness component (e.g. a "Women" theme to coincide with = International Women's day) it is best to propose it about 90 days in advance.


How to get around a "withdrawal address format is wrong" error?

It may be that your copy/paste is carrying across more characters than you expect. It may contain a trailing whitespace or non-visible character (e.g. cr or newline).
On Windows, I eliminate this possibility by pasting to notepad and then copying from notepad to the destination.
Try with a small transaction first to verify the process and correct destination address.


Will there be a web-based Daedalus wallet?

No.
Daedalus is a full-node wallet, which means it runs cardano-node (no web version) and downloads a copy of the blockchain onto your computer. With a blockchain size of 10GB and growing, it doesn't really make sense for Daedalus to run in a full web browser.
Yoroi is the official web/light wallet, available as a chrome extension, iOS, or Android app. https://yoroi-wallet.com/


When a UTxO becomes available for consumption?

That is correct. For a UTxO to be consumed it first has to exist on the blockchain. For it to exist on the blockchain the transaction that created it must exist in a block that has been confirmed by the network.


Is there a minimum amount of ADA I can send in a transaction?

There is a minimum UTxO transaction size of 1 ADA not including fees. That means the absolute minimum transaction is 1 ADA + fees.


Is there an equivalent to the Wallet Connect protocol in the Cardano ecosystem?

There is no open standard published right now, but work is ongoing to create one.
Emurgo is working on porting the EIP-0012 Ergo standard that the Yoroi Ergo dApp connector is using to Cardano. Have a look at the CIP-Dapp-Connector pull request.


What is the relationship between addresses and stake addresses?

Usually, the Shelley address contains the staking address inside (delegation part), so it is not possible to change it. But they are other types of addresses.
One of the best resources to learn about Cardano's addresses is CIP19: Cardano Addresses.


Why was the platform/foundation named after Gerolamo Cardano?

I think the answer you are looking for can be found at the 3:10 mark (bold part in the transcript below) on this video, but for the consistency of ideas please watch from the 1:43.
The transcript of this portion of the video is:

Gerolamo Cardano (1501–1576) was an Italian mathematician, physicist, biologist, physician, chemist, astrologist, philosopher, writer, and gambler.
During his lifetime he wrote over 200 scientific works and was one of the key figures in the mathematical field of probability during the Renaissance.
Gerolamo Cardano, is well known for his achievements in algebra.
He was a teacher in Milan Italy in the 16th century.
In his 1545 book Ars Magna, he made the first systematic use of negative numbers in Europe, published with attribution the solutions of other mathematicians for the cubic and quartic equations.
He also acknowledged the existence of imaginary numbers now used in geometry.
His book about games of chance, Liber de ludo aleae written around 1564, but not published until 1663, contains the first systematic treatment of probability.
He used the game of throwing dice to understand the basic concepts of probability.
He demonstrated the efficacy of defining odds as the ratio of favorable to unfavorable outcomes.
For a cryptocurrency project that is looking to utilize scientific methods based on mathematical proofs and game theory to build highly flexible and interoperable money, I think this choice seems to match perfectly.


How can metadata.json properties be changed after a token is minted?

Technically you cannot change the metadata for a token once its minted. Thats the whole point of putting something on the blockchain-its immutable. On Cardano, token metadata is just metadata in the minting transaction. What you are doing is just adding new metadata to a new transaction with the token. This is not changing the minting metadata. You should just burn the token and start fresh.


What decisions are left to the slot leader?

The Haskell reference implementation of the Cardano node, leaves no such decisions to the slot leader, and most (if not all) are using that node implementation.
As far as the Cardano protocol is concerned, however, the slot leader could cherry pick transactions and for example prefer those with higher fees.


Will I be able to stake ada from coinbase?

Currently Coinbase does not support staking ADA tokens. Implementation of ADA staking within Coinbase is something you would need to take up with Coinbase.


Yoroi doesn't need to be involved. You can access your keys using the cardano-wallet suite of tools. You just need your seed phrase.
Yoroi and other wallets are just interfaces to the blockchain. The private keys on the chain are the same. Using the command line tools developed my IOG is basically what the wallets are doing behind the scenes.


Is there a browser-based wallet like Metamask planned for Cardano?

We have Yoroi Web extensión for Chrome, Firefox and Edge.
www.yoroi-wallet.com


is it possible in future to buy ADA directly?

LocalBitcoin.com might have some options.


I would not say that PoS is faster per se, but you have to carefully balance PoW challenges in order to avoid single entities or groups to dominate the blockchain with huge computing powers. This somewhat limits how fast you mine new blocks, which store verified transactions, impacting transaction speed.
PoW and PoS are "tools" to select who will create the next block. A big difference is that "winning" the proof of work also determines when a new block is created, while the rate can be fixed for PoS chains.
For PoW you want a task that takes a reasonable time: too easy, and you create too many, potentially empty blocks too fast. This will grow the chain, and potentially flood the ecosystem with coins - depending on the protocol. And if the challenge is already easy to solve, someone with a lot of computing power and no competition could just spam new blocks.
If the challenge is too hard, new blocks will only rarely be created, and all transactions are collected in an "unconfirmed transactions" list. Depending on the block size, not all transactions can be included into a new block. This would make the blockchain an unreliable financial instrument. To compensate, you could use fees and allow transactions to be processed with a higher priority, guaranteeing a spot in the next block. All this is influenced by the number of participating miners, the challenge, and must always be balanced to avoid extremes. To give some examples: Bitcoin creates a new block every 10 minutes, while Ethereum only takes less than 15 seconds.
A proof of stake chain can just dictate at what interval blocks are created. The system to select the node that created the new block is not "work" dependent, and thus not time dependent. You can create blocks at a fixed interval and guarantee that transactions are processed in time - as long as the number of transactions does not exceed the block size.
Cardano allows adjustments to this, enabling a high transaction speed. Cardanos block time is 20 seconds, and this parameter is adjustable.
If the number of nodes suddenly grows by a factor of 10, the speed would not be impacted. A PoW chain would have to adjust its difficulty, same when it's combined hashing power decreases - effectively making it slower.
To summarize: PoW can be faster than PoS. The PoW speed can change and must be adjusted, which is easier with slower target speeds (time at which new block is created). PoS is not work (time) dependent and can provide a fixed and thus potentially faster, reliable block creation speed.


The easiest way to mint an NFT IMG token on Cardano is by using https://www.nft-maker.io/. If you want to make it yourself then https://docs.cardano.org/en/latest/native-tokens/getting-started-with-native-tokens.html is a good starting point.


Difference between "normal key" and "extended key" in cardano-cli address key-gen

I'll preface with the note that cardano-cli is a legacy project from the Byron era prior to the restructuring of cardano-sl into the modern infrastructure used today. You likely want to use the cardano-address if you can. The Adrestia repo keeps track of the official tools, libraries, and APIs as well as their support for the various eras.
To give a short explanation, the way key generation in Cardano works is as follows:

You create a Recovery or Seed Phrase. This is a deterministic seed that then derives your extended private key. This is the famous 24 word phrase that you store. It derives your xprv key but it does not represent it. This means if you do not have a seed phrase, you can not get one and you'll have to create a new wallet to get it.

You create the Extended Private Key. This is the root key from which all other keys are derived (including the extended public key). This key can either be created from scratch or derived from a seed phrase. If you want your key to be loadable into Daedalus/Yoroi without poking around in the internals and manually editing the SQLite database, you need to start from a seed phrase.

You derive Child Private Keys. These are various keys that serve specific purposes. Examples include the delegation(staking) keys, the various stake pool keys, and spending keys. As the protocol grows, there'll be more of these keys however as long as you have your extended private key or seed phrase, you'll be able to gain access to those with little to no action required.

You derive whatever else from the Child Private Keys. This is where you would derive addresses, stake pool certificates, etc. This is essentially all handled by the node itself and you don't really have to worry about much of this stuff unless you are doing something specific.

So in summary, the seed phrase is the "seed" that creates everything else (and is easy to store/remember), the extended key is your "master key", and the normal key (now called a spending key) derives from the extended key and lets you spend your funds.
Also note that the terminology differs a bit between eras. Byron used a rather different key system so you should generally avoid using it unless you absolutely have to. Icarus established the basis for modern key derivation in the Cardano ecosystem and Shelley has extended upon that (with staking related keys).


eUTXO transaction model Vs Account Based Transaction Model

There is a nice blog post bu IOG: Cardano’s Extended UTXO accounting model – built to support multi-assets and smart contracts that discusses the difference between two models.
For a more in depth comparison, I recommend the UTxO- vs account-based smart contract blockchain programming paradigms paper.
To sum UTXO up:

A UTXO is the output of a previous transaction, which can be spent in
the future
UTXO chains have no accounts. Instead, coins are stored as
a list of UTXOs, and transactions are created by consuming existing
UTXOs and producing new ones in their place
Balance is the sum of
UTXOs controlled by a given address
UTXOs resemble cash in that they
use ‘change’, and are indivisible (UTXOs are used whole)

To sum up the Account/Balance model:

This accounting model resembles how a bank operates
Users have accounts that hold their coin balance
It is possible to spent partial balances
The concept of change does not apply


How can I stop Daedalus filling up my Time Machine backup drive on MacOS?

It is safe to exclude all Daedelus directories from time-machine if you have your recovery phrase stored elsewhere.


Right now the only way I know is using pool.pm because Smaug created a metadata specific for this purpose.
The wallets aren't yet fit to the same metadata therefore first, the proposal must be accepted.
I hope it will.


Can the value of the NFTs be added to the stake size of the pool?

If the value of NFTs (their purchase price or last traded value) were to be added to staking then both the ADA used to purchase them and the NFT would counted.  This would make it possible to double your staking rewards by selling an NFT to yourself or a collaborator.
It would also affect the Cardano monetary policy.
Stake pool operation is a serious undertaking and gathering enough stake to establish a viable pool is part of that challenge.


How can I find the Haskell source code for the sqrt function?

By entering :i sqrt using ghci, we can see that sqrt is

-- Defined in ‘GHC.Float’

A quick google shows that the source code repo is on https://gitlab.haskell.org/ghc/ghc.
Entering sqrt in the search bar for the repository yields several pages of interesting results (including tests). From what I see, using sqrt includes calling the corresponding sqrt operation on a CPU level (check out the x86 related code as one example).
Of course, GHC is not the only implementation of Haskell, but at least within these realms, both terms are most often used as synonyms.
Edit: OP found the implementation detail with this approach in https://gitlab.haskell.org/ghc/ghc/-/blob/master/libraries/base/GHC/Float.hs, where sqrt is defined as follows:
sqrt x              =  x ** 0.5


Can Cardano be used to mint and trade gaming NFTs?

Not currently.
NFTs are essentially smart contracts implementing auctions for assets embedded in the Interplanetary Filesystem (IPFS). So, you need a blockchain that supports smart contracts.
Ethereum supports these via the Solidity VM and language, but Cardano's smart contract VM and language (Plutus) is forthcoming in the Goguen release of the Cardano blockchain.
You can start getting familiar with the Plutus language and the smart contract platform via the Cardano Plutus Pioneer Program lectures (being released actively over the next few weeks). The first one is here: https://www.youtube.com/watch?v=IEn6jUo-0vU .
Apparently NFTs are implemented as native tokens on the Cardano blockchain (which don't require writing a smart contract). So, yes. You can make an NFT (platform) on top of the Cardano blockchain.


How to derive addresses from a key exported from Yoroi

I would suggest you leave Yoroi out of it. You have a seed phrase that can generate your wallet private keys. So, use the cardano-wallet tools to generate your keys, derive addressed, etc. You can do this in bash or call the cardano-wallet executables from a Python script.


What companies and institutions accept ADA as payment?

I do not know of such a list, but it would be very cool if someone started such a list within a repository, similar to essential Cardano.


In order to calculate the leaderlogs, the calculations require the epoch nonce. This epoch nonce value is calculated from the rolling nonce value at 1.5 days before the next epoch starts. This 1.5 days is also called the stability window. The nonce calculation also includes the block hash of the first slot of the previous epoch.
Finally, if there is extra entropy that needs to be added, the extra entropy protocol parameter is included in the epoch nonce calculation.
By using these two (sometimes 3) pieces of data along with a blake2b hash, we end up with a new epoch nonce value that can be used to calculate leaderlogs.


How does a stake pool node certify a block for the block chain?

In Cardano, time is segmented into 5 day epochs and 1 second slots.
As users publish transactions on the network, pools distribute the transactions to their peers and store valid transactions locally in a queue, known as the mempool.
In each slot, one or more validators (pools) may be selected to forge a block. That block will contain transactions from the mempool, up to max block size.
Validators are able to independently check if they are elected as the slot leader. From the Ourobouros Praos paper:

only a slot leader is aware that it is indeed a leader for a given slot; this assignment is unknown to all the other stakeholders—including other slot leaders of the same slot—until the other stakeholders receive a valid block from this slot leader

Blocks are signed by a validator with their operational key and includes the validator's operational certificate. The certificate is composed of the public portion of the operational key, certificate issue number, beginning KES period, and a cold key signature as defined in the ledger spec.
Once the new block is distributed to the network, each other validator can verify that the new block is valid, and that the publisher was eligible to forge a block in that slot.
All of this happens automatically as part of the cardano-node software. Operators only need to update their certificate periodically.
The proof of this distributed random selection process is a bit much for this answer, as is the proof for how the network selects a longest chain and handles soft forks, but worth reading up on if you're interested in this topic!


Are there plans to keep the blockchain/node size small enough to maintain decentralisation?

I assume with "blockchain/node size" you mean the growing size of the immutable ledger database. The current growth rate is pretty linear. In the last 100 days it grew from 7 up to 10.5 GB

So we see a growth rate of about 1 GB per month, which would result in a 12 GB per year.
Keep in mind the ledger DB folder now contains every UTXO action since Nov-2017, not just since Shelley-Mainnet launch in Aug-2020.
New capabilities like Metadata or additional activities from native Tokens, NFTs and soon Smart-Contracts may increase the growth rate a bit.
So existing Hard drives with 2-12 TeraByte capacity should provide plenty of space for the next years.


What encoding is used for Yorois Wallet export?

After a lot of trial and error, I figured it out myself.
TLDR
The "key" that results from the Yoroi export indeed needs to be encoded with bech32, using the prefix acct_xvk.
Demonstration/Proof
To test this, we need multiple things:

The seed phrase of our test wallet (for this demonstration we store it in the file phrase.prv): maximum vacuum toe conduct jazz tray romance crawl fossil wisdom disease crazy mountain bird discover
The "key" exported by Yoroi (for this demonstration we store it in the file root_yoroi_raw.pub): 95e74df114717de17ebfb24c05f9fd1c8019bb6f1de117eec10a43670a692866b837a4a5f51d62f3dc3d630d075c8e39e5294323ba146c386c48123aeef5438a
The bech32 tool.
The cardano-addresses tool.

We can now test, whether we can get the same results using our seed phrase and the exported key:
./cardano-address key from-recovery-phrase Shelley < phrase.prv > root.xsk
cat root.xsk | ./cardano-address key child 1852H/1815H/0H | ./cardano-address key public --with-chain-code > root.xvk

./bech32 acct_xvk < root_yoroi_raw.pub > root_yoroi.pub

cat root.xvk
cat root_yoroi.pub

This gives the following result:
acct_xvk1jhn5mug5w977zl4lkfxqt70arjqpnwm0rhs30mkppfpkwznf9pntsday5h636chnms7kxrg8tj8rneffgv3m59rv8pkysy36am658zsh2qnm6
acct_xvk1jhn5mug5w977zl4lkfxqt70arjqpnwm0rhs30mkppfpkwznf9pntsday5h636chnms7kxrg8tj8rneffgv3m59rv8pkysy36am658zsh2qnm6

This means, that the key exported by Yoroi, when being bech32 encoded with the prefix acct_xvk matches the extended public root key that can be derived from the seed phrase.


What are the ways of making NFTs unique?

NFTs have to be minted in some way or the other. In order to mint you will have to run a script with monetary policy for which you have to pay a fee, so might as well use that UTxO.
You can mint multiple NFTs in a single script though. Remember that a Value is identified by its CurrencySymbol and the TokenName. The CurrencySymbol is unique because of the UTxO input and is shared across all NFTs minted in the same contract. You can use a different TokenName for each NFT to ensure uniqueness.


Why is the growth in value of ADA being described as "parabolic" rather than "exponential" or something else?

Searching Google for "cardano ada exponential" gives ~305k results.
Searching Google for "cardano ada parabolic" gives ~309k results.
Likely is just some resistance in the community to the mass-media habit of applying the adjective "exponential" for any sort of super-linear growth.  I don't know that parabolic is a better adjective, but it seems to be adapted by the community.


What happens to fees when Cardano's chain reaches 1509GB data?

The fees are based on the size of the transactions and have nothing to do with the blockchain size. I think the same applies to Etherum.
About when we will see the size of the blockchain depends on the usage of network of course. But if we keep the current max_block_size set to 65536 bytes and account for about average of 4320 blocks a a day it is about 280MB a day with full capacity usage.
In theory, it would take about 14 months to reach 1 509 GB of size if the network has been utilized to its fullest potential, almost 11 years if we use only 10% of the network capacity.
But that is very theoretical and it the real world, we will probably get shredding mechanisms before reaching that size.


How to implement continuous interest accruing with native tokens

No. Not exactly.
Since all the tokens on Cardano are native, they all have the same behavior; they just sit there. It's only through transactions that you can change the state of the chain.
I think you can get the desired behavior though!
Let's say when you submit your USDT for aUSDT you get a "receipt" UTxO. The receipt includes two pieces of data: deposit amount and deposit slot. Whenever you want to receive your interest, you could submit a transaction to the issuance script with your aUSDT and the receipt UTxO and the contract will calculate the interest based on time since deposit slot. Then the script can either re-issue you aUSDT with the interest and a new receipt or pay out your USDT with interest.
There might be better ways too, but that's an example how it could probably work.


Where to find current transactions per second statistic?

I found cardanowaves.com the other day on r/cardano and it looks useful. Shows over 1M transaction in last 28 days, which is 35K/day. Agrees with previous answer; this may update more dynamically. It updates statistics from the blockchain.


Is it possible to reuse the blockchain for both relay and block producing nodes?

This is not possible, as both nodes are two different blockchain nodes and might have different views of the network in forks as in transactions in the mempool.


What are the pros and cons of Cardano's liquid staking over other protocols that use a bonded staking model?

In my understanding, hardening the system by locking your coins is great. It has the disadvantage of not being a realistic economic policy, where the velocity of money (i.e. using it) is a must for sustainance. GDP = VELOCITY X MONETARY BASE, for example.
Cardano solves this by taking snapshots of the locked coins, so the next epoch happens in, sort of, a parallel universe where all the tokens are locked, but lets the economy of the ecosystem be heakthy by letting then move freely. Then the next snapshot happens, and hence the system keeps being secure no matter if there is a large dump, things change hands or tokens are sold for fiat.
I hope I made myself clear, otherwise let me know and I will give you a more structured answer.


Referencing onchain contract as 3rd party

In short:
In my understanding, the actual smart contracts are always shipped with the transaction, so you need all code that you want to execute. Merely the script hash ensures that actually the right script code is shipped with the transaction. And this hash will also be the location (the public key address) of potential funds or information.
In long:
A good example is given in the oracle lecture of the Plutus Pioneer Program:
from Swap.hs:
swapInst :: Oracle -> Scripts.ScriptInstance Swapping
swapInst oracle = Scripts.validator @Swapping
    ($$(PlutusTx.compile [|| mkSwapValidator ||])
        `PlutusTx.applyCode` PlutusTx.liftCode oracle
        `PlutusTx.applyCode` PlutusTx.liftCode (oracleAddress oracle))
    $$(PlutusTx.compile [|| wrap ||])
  where
    wrap = Scripts.wrapValidator @PubKeyHash @()

Here the oracle contract is passed to swap contract as a parameter. If somebody wants to use it, he has to provide an instance:
    h3 <- activateContractWallet (Wallet 3) $ swap oracle

And as far as I understand the code, this is only possible if you have access to the source code. But please correct me if I'm wrong.
The oracle API is used in the sense that there are multiple possibilities for valid redeemers, which define the endpoints: data OracleRedeemer = Update | Use
Later somebody can

search for the oracle (this is in a sense library code coming from the oracle provider):

findOracle :: forall w s. HasBlockchainActions s => Oracle -> Contract w s Text (Maybe (TxOutRef, TxOutTx, Integer))
findOracle oracle = do
    utxos <- Map.filter f <$> utxoAt (oracleAddress oracle)
    return $ case Map.toList utxos of
        [(oref, o)] -> do
            x <- oracleValue (txOutTxOut o) $ \dh -> Map.lookup dh $ txData $ txOutTxTx o
            return (oref, o, x)
        _           -> Nothing
  where
    f :: TxOutTx -> Bool
    f o = assetClassValueOf (txOutValue $ txOutTxOut o) (oracleAsset oracle) == 1

use it by providing the right redeemer for the wanted endpoint (in this case "Use", see "Redeemer"):

useSwap :: forall w s. HasBlockchainActions s => Oracle -> Contract w s Text ()
useSwap oracle = do
    funds <- ownFunds
    let amt = assetClassValueOf funds $ oAsset oracle
    logInfo @String $ "available assets: " ++ show amt

    m <- findOracle oracle
    case m of
        Nothing           -> logInfo @String "oracle not found"
        Just (oref, o, x) -> do
            logInfo @String $ "found oracle, exchange rate " ++ show x
            pkh   <- pubKeyHash <$> Contract.ownPubKey
            swaps <- findSwaps oracle (/= pkh)
            case find (f amt x) swaps of
                Nothing                -> logInfo @String "no suitable swap found"
                Just (oref', o', pkh') -> do
                    let v       = txOutValue (txOutTxOut o) <> lovelaceValueOf (oFee oracle)
                        p       = assetClassValue (oAsset oracle) $ price (lovelaces $ txOutValue $ txOutTxOut o') x
                        lookups = Constraints.otherScript (swapValidator oracle)                     <>
                                  Constraints.otherScript (oracleValidator oracle)                   <>
                                  Constraints.unspentOutputs (Map.fromList [(oref, o), (oref', o')])
                        tx      = Constraints.mustSpendScriptOutput oref  (Redeemer $ PlutusTx.toData Use) <>
                                  Constraints.mustSpendScriptOutput oref' (Redeemer $ PlutusTx.toData ())  <>
                                  Constraints.mustPayToOtherScript
                                    (validatorHash $ oracleValidator oracle)
                                    (Datum $ PlutusTx.toData x)
                                    v                                                                      <>
                                  Constraints.mustPayToPubKey pkh' p
                    ledgerTx <- submitTxConstraintsWith @Swapping lookups tx
                    awaitTxConfirmed $ txId ledgerTx
                    logInfo @String $ "made swap with price " ++ show (Value.flattenValue p)
  where
    getPrice :: Integer -> TxOutTx -> Integer
    getPrice x o = price (lovelaces $ txOutValue $ txOutTxOut o) x

    f :: Integer -> Integer -> (TxOutRef, TxOutTx, PubKeyHash) -> Bool
    f amt x (_, o, _) = getPrice x o <= amt

So I suspect that you always need the third-party code. But that would actually be a good thing since you want to make sure anyway that the third party can't fool you.
Additionally, I don't see a way how it could be possible to execute another contract without the code since it isn't stored on the blockchain itself. The blockchain just stores the hash of the code (the public key address) and all funds (eUTxOs) located at that address.


Validation is deterministic, so decidedly non-random. And this is a desirable feature, because it means you can validate a transaction off-chain before ever submitting it, thus being sure you'll never have to pay fees for a transaction that will turn out to be invalid.
In order to get randomness, one could for example use an oracle that provides entropy.
Alternatively, one could use a commitment scheme: In your example, the lottery operator publishes the hash of the random draw up-front, then later, after players have signed on, reveals it. The operator can't cheat, because he has committed already (by publishing the hash up front).


How would Cardano applications function with intermittent internet connection?

Most blockchains currently rely heavily on a stable and relatively low-latency internet link. Relaxing the latency requirements may allow for more decentralisation since more people would be able to participate in the consensus mechanism (ie. by setting up a validator), but this comes at the cost of performance (decreased throughput).

what is the minimal internet traffic and time needed to send funds from one phone, and get final confirmation on the other?

If you use a light wallet like Yoroi, the bandwidth requirements are pretty low, a narrowband link of a few kbps should be enough.

Would it matter if the phones are on the same local network?

No, that usually doesn't help since validating a transaction requires the transaction to be broadcasted to the blockchain network, not only among the parties directly involved in the transaction inputs/outputs. However, if the wallets used by those phones are connected to some relay node in their local network (theoretically possible), then it would be different.
Note that the only bandwidth/storage intensive operation is to validate transactions in the way full nodes do. Submitting a transaction does not require much resources.
On the other hand, it is theoretically possible to establish a payment channel between these phones, which may lower the requirements for connectivity (though I don't know of any solution like this in Cardano).


How will Cardano address the ledger growth problem?

The answer to this question is not clear yet, as more research is needed into this problem.
For now, the effort is to prevent the blockchain growing into large sizes with using layer one two solutions such as Hydra and possibly with side-chains, where you won't have just one blockchain but many, so the data might be distributed this way.
Shredding will be used too to provide a light-weight view of the blockchain, but many services such as Blockfrost will still have to run full archived nodes to access all the data on the blockchain.


General approach for allowing multiple smart contract transactions per block

Not as far as I know. The current model is limited to one state change (transaction) per block per smart contact.
However, depending on the specific smart contact and its use case, I can see people using a centralized entity (or a group of users) post transition proposals and then have an incentive to bundle all of those up into one that actually modifies the global state. Not ideal, but this is the price to pay to have a state-full smart contact design.


How does one decide what is the best stake pool to delegate to?

There are lots of reasons to choose a stake pool other than the parameters and the ranking in Daedalus.
It depends on your values. Do you value decentralization? Do you want to support a big pool operation that has multiple pools under one brand or a single pool operator? You could support a pool that gives a percentage of it's operator rewards to charity. You could choose a pool that runs on Raspberry Pi's over a pool that runs on Google servers. You could look for a pool who's operator is easy to contact and interact with, they are active on twitter and/or YouTube. They have a strong web presence with good resources for delegators. Some stake pools are offering extra rewards in the form of ADA lottery or their own Cardano native tokens that they have minted themselves.
The fist pool I delegated to ran on solar panels and was ranked in the top 10. Now, I wouldn't even look at the ranking in the wallet. I've chosen a stake pool because the operator is active in the community and creating valuable content for the community. He is running a single pool on Raspberry Pi, under 1M ADA in active stake. I value supporting smaller pools that are trying to get up and running.
It's very much a personal choice based on countless variables.


Problem starting a plutus devcontainer in windows

Ok i fround the issue, someone removed the nsswitch file here: https://github.com/input-output-hk/plutus/commit/5dbd3b833b40217cb1a63d4f52351ae8876ba86c
The file tells the system to lookup the hosts file, but without the filt, it won't.
So i just opened a my wsl-ubuntu and created the file in my home folder:
vi ~/nsswitch.conf

and put the content
passwd:    files mymachines systemd
group:     files mymachines systemd
shadow:    files

hosts:     files mymachines dns myhostname
networks:  files

ethers:    files
services:  files
protocols: files
rpc:       files

now i changed the devcontainer.json so it mounts the file:
{
    "name": "Plutus Starter Project",
    "image": "plutus-devcontainer:latest",

    "remoteUser": "plutus",

    "mounts": [
        // This shares cabal's remote repository state with the host. We don't mount the whole of '.cabal', because
        // 1. '.cabal/config' contains absolute paths that will only make sense on the host, and
        // 2. '.cabal/store' is not necessarily portable to different version of cabal etc.
        "source=${localEnv:HOME}/.cabal/packages,target=/home/plutus/.cabal/packages,type=bind,consistency=cached",
        "source=${localEnv:HOME}/nsswitch.conf,target=/etc/nsswitch.conf,type=bind,consistency=cached",
    ],

    "settings": {
        // Note: don't change from bash so it runs .bashrc
        "terminal.integrated.shell.linux": "/bin/bash"
    },

    // IDs of extensions inside container
    "extensions": [
        "haskell.haskell"
    ],
}

Now i'm back in busines


Why is there a 45 Billion coin cap for ADA?

Charles Hoskinson stated that it is a fairly arbitrary number in one of his AMAs.
He jokingly explained,

It's because 44 999 999 999 was not enough, and 45 000 000 001 was too much.

With 1 Million Lovelaces per ADA, there is plenty to go around for the foreseeable future.


Why do Daedalus Rewards Report Epoch End Dates differ from other sources?

Rewards for a given epoch X are paid out at the end of the next epoch, X+1. This is because the calculation of which stake keys get rewards is done during epoch X+1.
Applying this to your example, the order of events would be:

April 25th - epoch 261 ends
April 30th - epoch 262 ends - rewards from epoch 261 are paid
April 30th - epoch 263 starts - CSV report and adastat.net list current date and epoch.

The terminology of rewards being "paid" is somewhat misleading, since there are no transactions that correspond to the rewards entering your wallet. Instead, the amount of rewards for all stake keys is stored separately in the ledger, and that table is updated on epoch boundaries. Your private stake key then allows you to withdraw/send the rewards along with regular transactions.


You can get away with the mismatch between the ghc nix derivations: Tell Nix to use the IOHK binary cache. (It is indeed indicated as "IMPORTANT" the we should enable the IOHK binary cache at the top of the Plutus README file)
On tradition linuxes, that should do it:
sudo mkdir -p /etc/nix
cat <<EOF | sudo tee /etc/nix/nix.conf
substituters = https://cache.nixos.org https://hydra.iohk.io
trusted-public-keys = iohk.cachix.org-1:DpRUyj7h7V830dp/i6Nti+NEO2/nhblbov/8MW7Rqoo= hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=
EOF

On NixOs:
# configuration.nix
{ config, pkgs, ... }:
{
  # ... all the rest of the configuration of the server

  # iohk binary caches
  nix =
  {
    binaryCaches          = [ "https://hydra.iohk.io" "https://iohk.cachix.org" ];
    binaryCachePublicKeys = [ "hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ=" "iohk.cachix.org-1:DpRUyj7h7V830dp/i6Nti+NEO2/nhblbov/8MW7Rqoo=" ];
  };
}


What prevents flash loans attacks from occurring on the Cardano network?

Flash loans generally exploit financial protocol vulnerabilities to manipulate the prices and exploit the system. For example, In the 2020 attack on Fulcrum built using bZx protocol, attackers used borrowed Ether to manipulate the price of sUSD( a stable coin); naturally, the price of the stable coin should have remained stable to prevent the attack. Smart contract writers should have anticipated the instability of stable coin prices under unusual market conditions. Formal verification methods would have identified this hidden issue.
Theoretically, these higher protocols are influenced by the underlying blockchain technology, which results in unreliable smart contract state estimation.
Cardano has brought the "Formal Methods" paradigm in creating smart contracts, enabling precise estimation of smart contracts behaviors provably. Moreover, Plutus is designed with such care to enable this technology. The potential of this mathematical precision has not yet been realized in the current ETH-dominated DeFi. In short, Cardano will prevent this type of protocol attacks by enabling smart contract writers to predict what can go wrong in which setting.


Run cardano-node 1.27.0 testnet error, adaPerUTxOWord not found on testnet-shelley-genesis.json

Make sure you download official genesis file from the build system of cardano-node.


Will I receive rewards for all epochs when I switch my stake pool?

You will continue to get rewards every epoch. Cardano works on epoch "snapshots" that occur every 5 days. It takes 3 epochs to get paid the rewards from a snapshot. This means that if you change stake pools, it will take 3 epochs (from the first snapshot that the change is effective) to receive rewards from the other pool. However, the other two epochs you will still get rewards because the snapshots with your ADA in the old pool will be paying out.
The only time you stop getting rewards is when you stop delegating your ADA and that is included in a snapshot. Then you will get the remain rewards for the next two epochs and rewards will stop on the third epoch after undelegating.


How does Cardano compare with other blockchains in terms of being eco-friendly?

The rate of transactions per second does not affect Cardano's power consumption significantly, but implementation of smart contracts, scaling mechanisms, etc. may have a measurable impact in the future.
Cardano is largely as eco-friendly as all proof-of-stake blockchains.  Its actual energy consumption is roughly the power consumption of a typical staking pool node times the number of staking pool nodes.  The power consumption per transaction is millions of times more energy efficient than Bitcoin.
In general

Proof-of-work (PoW) blockchains rely on the miner's ability to produce the answer to a question whose answer must be guessed, then proven to be correct.  The more guesses and proofs that the miner can make per second, the higher their odds of winning the next reward.
Proof of stake (PoS) blockchains rely on the quantity of a cryptocurrency owned or delegated to the miner to raise their odds in a fair lottery to win the next reward

PoW blockchains favor miners with the most computing power and PoS blockchains favor miners with the most coins (owned or delegated).
Over time this has led to the two largest PoW cryptocurrencies (Bitcoin and Ethereum) using millions of times more power than PoS blockchains.
Cambridge Bitcoin Electricity Consumption Index


You're using tags/1.23.2. The most recent release was tags/1.26.2. You can see the file on master at the moment [0] so I'd suggest checking out a more recent version of cardano-node and opening a PR or submitting an issue on GitHub to update the node version that the docs suggest using.
[0] https://github.com/input-output-hk/cardano-node/blob/master/scripts/bin-path.sh


Does the testnet faucet still exist? How to create testnet ADA?

You can request tAda from the test faucet here. By adding an address without an API key you will receive 1000 tAda. You could also request an API key from IOHK to have a bespoke amount of tAda/Testcoin if required. Once you're finished with your tAda you should return them to this address (which you can see on the official documentation page too).
addr_test1qqr585tvlc7ylnqvz8pyqwauzrdu0mxag3m7q56grgmgu7sxu2hyfhlkwuxupa9d5085eunq2qywy7hvmvej456flknswgndm3


Stuck at Creating Keys for Token - cardano-cli address key-gen

Ok I am an idiot for asking and answering this,but I am doing it anyways in case somebody stumbles in the same problem.
The folder for the keys needs to be created in the the directory where the node is in. In my case Cardano.


Running a stake pool requires two main components, technical ability and marketing savvy. I'll outline some of this at a high level for you below.
Technical

Linux server administration. You must be able to setup and administer a server that will run your pool and relay nodes. You will need to be comfortable running applications in the terminal.
Bash scripting (for setting up your pool, running the nodes, etc.)

Marketing

A pool cannot make blocks without attracting delegation. It take around 1.2M ADA to average one block per epoch.
Pools need effective marketing to attract enough delegators unless you own enough ADA yourself.
This is actually the hardest part about running a pool.

One last thing is pledge, currently the pledge only has a small effect on the rewards a pool earns. However, this is set to increase in the future. The exact amount of pledge needed is unknown but will be more than a few thousand ADA. Looking at most of the pools that are out there I would assume anything less than 50-100k ADA will not be sufficient.
There is a plethora of resources for how to setup a node, but hopefully this helps to answer the question of whether or not this is something you want to pursue. Good luck!


How are the key parameters that control Cardano governed?

The parameters are controlled by IOG currently. There are a number of keys that govern update proposals. Update proposals are special certificates posted to the chain that can change the parameters. Each update proposal is required to have 5 signatures in order to become active. These signatures have to be in place 1.5 days before the end of the epoch in order for them to become active at the next epoch.
If you do a ledger state dump using cardano-cli, you can view the parameter change proposals and how many signatures they have.
CIP that talks about the process https://github.com/cardano-foundation/CIPs/blob/master/CIP-0009/CIP-0009.md


It is possible to determine wallet addresses from the staking address. There is currently no way to lock a token to be redeemable only by someone who is delegating to a specific stake pool. I assume this will be possible once smart contracts are live.
The simplest way to find other wallet addresses associated with a stake address is to look the address up on Cardanoscan.
If you want some details on how these addresses are derived, checkout Andrew Westberg's video here.


Stake pool operation: estimated effort in time?

Your question has no direct answer.
Its hard or not impossible to estimate the time spent on marketing, from my side its a full time job.
I spend all day on twitter and reddit, these are my favourite social media.
To setup a pool you can check Cardano Forum and ask mr. Alex post about CNTOOLS.
if you understand something about Linux OS its easy for you, if not, you'll need to learn and some DevOps is required for basic firewall configuration for example.
There's no direct answer to that, if you are already experienced on linux I would not expect more than 1 hour to setup a block producer and two relay.
Check here for CNTOOLS setup tutorial, I'd recommend this because it saved me a lot of time.
https://forum.cardano.org/t/how-to-set-up-a-pool-in-a-few-minutes-and-register-using-cntools/48767
good luck


What are your favorite resources to explain Cardano to people without a technical background?

Recommended videos

The philosophy of Cardano short version

The philosophy of Cardano longer version

Charles Hoskinson's whiteboard video for those who are not afraid of 50 mins of words like bandwidth, scaling, replication, etc. is a great intro to the challenges Cardano is designed to solve

How does bitcoin actually work, the best explanation


Where and when do I get a chance to review and contest community advisor (CA) assessments of my proposal?

The assessments made by Community advisors are mailed to the proposer as a Google Sheet. The proposer can mark infringements as he finds in the assessment in the sheet. If a proposer has not received he can contact in the related telegram channel. Please refer this QA Stage


Pool operators do use the CLI directly, or have some shell scripts to streamline the transaction building steps. There are also several different suites of pool management scripts that automatically build the transactions required, in addition to many other features built on top of calls to cardano-cli.
As a pool operator, administration transactions often require special flags to cardano-cli which wallet software doesn't support. Specifically, pool operators must do these 3 functions:

Register the pool, which involves 2-3 transactions
Every 65 days, renew KES (Key Evolving Signature)
Other pool updates, like changes to fees, relays, and metadata

"A transaction is a binding between inputs and outputs". This is true of all Cardano transactions, but the pool management actions above also include metadata. Some of the metadata fields are special/reserved and passed as flags to the CLI, and some metadata is supplied as user-defined JSON.
The stake pool setup documentation walks through the setup & KES management in much more detail.


What are the practical motivations for owning ADA crypto currency?

This is very subjective and can only be answered from an opinionated position. With that, it has value, IMO because it has

been developed by a very methodical, mathematical, and scientific method
derivative tokens which are "native", compared to Ethereum, where tokens are implemented via smart contracts – this has one major implication (among other benefits): transaction fees are a small fraction; no "gas" fees are required to execute a contract
a dedicated and sophisticated, and ever expanding, ecosystem of people and companies working to solve real problems, create valuable businesses, etc.
outreach programs targeting new developers, governments, and education
a treasury system where regular rounds of Catalyst fund winning Cardano-based projects via grants
smart contracts that can be mathematically verified, enabling greater trust in the proper handling of funds


Do old UTXO's ever get pruned from the blockchain?

No, it never gets pruned. One of the appealing features of blockchain is that the history stays there forever.
The size of the blockchain grows roughly linearly (ignoring the effect of adoption), whereas storage capacities follow Moore's Law and grow exponentially. So the expectation is that, yes, the blockchain will grow bigger and bigger, but that that is no problem, because hard drives get bigger (and cheaper) faster.


What is the expected ROA (Return of ADA) after all coins are minted?

In ADA all coins are already minted. The total supply is 45 billion tokens. About 13 billion coins are not used and are "locked" in the treasury. It is used to be able to pay out the rewards for every block created by the stakepool and from where you will get delegators' awards. Because there not so many transactions to pay for, all the block awards the missing coins are used from the treasury. Once the transaction fees are sufficient to pay out all the block rewards, the treasury will only be used to fund proposals in what is now called Catalyst which in due time will start to solve the Voltaire stage. When Voltaire is ready it will be up to the community what to do with the rest of all ADA from Treasury.
And this is a very interesting idea to vote the greedy out in favor of the Cardano Ecosystem to be sustainable.


How do I make a payment from a node address to a wallet using cardano-cli on mainnet?

If possible, always use the official documentation to protect yourself from scams. For sending a simple transaction using the cardano-cli, have a look at docs.cardano.org.
As for the error, when inspecting it, you will find it says OutputTooSmallUTxO. This is because of the minUTxOValue protocol parameters which is used to prevent dusting up the UTXO set. It is now set to 10000000 lovelaces, that means you cannot send an output smaller than this amount, which is probably something you are trying to do.


Why are Cardano transaction fees so high?

There are a important reason that explain why the fees can't be 0.00017 ADA,the prevention of DDoS attacks
The minimal fees for a transaction are calculated according to the formula
a + (b × size),
where 'a' and 'b' are constants and 'size' is the size of the transaction in Bytes. At the moment, the constants 'a' and 'b' have the values
a = 0.155381 ADA,
b = 0.000043946 ADA/Byte.
This means that each transaction costs at least 0.155381 ADA, with an additional cost of 0.000043946 ADA per Byte of transaction size. For example, a transaction of size 200 Byte (a fairly typical size) costs
0.155381 ADA + 0.000043946 ADA/Byte × 200 Byte = 0.1641702 ADA.
Why did we pick this particular formula? The reason for having parameter 'a' is the prevention of DDoS attacks mentioned above: even a very small dummy transaction should cost enough to hurt an attacker who tries to generate many thousands of them. Parameter 'b' has been introduced to reflect actual costs: storing larger transactions needs more computer memory than storing smaller transactions, so larger transactions should be more expensive than smaller ones.
Therefore, it is better to perform transactions of a large number of Ada than to perform multiple transactions of a lower number of Ada.


Stake pool - Failed to start all required subscriptions

"Failed to start all required subscriptions"

As recommended by @KC Gibson, reduce the valency for the IOHK node to two, and restart the node. The remote host is closing your connections, probably due to some connection limiting policy on their end.

I recently went through a router failure and an upgrade. And with that local and external IP addresses changes. After an IP address update both relay and producer nodes are fetching updates from the blockchain (as in passive node) but not processing transactions. Or at least this is what Guild Live View is showing.

If your issue is that gLiveView is not 'processing transactions', then you must first set TraceMempool to true in your mainnet-config.json to enable this feature.

Interestingly the producer node just minted a block that I take that will be lost on network write sync up.

cardano-node uses a 'pull' system for sharing blockchain data, so your ability to broadcast blocks depends on other nodes connecting to yours to pull data.
pool.vet suggests that you may not be well connected because you don't use topologyUpdater. Nevertheless, it reports that you should have one inbound connection from an IOHK node, and this is enough for you to publish blocks. Your netstat example doesn't show this, but if you run netstat -pant | grep cardano-node on your relay, you will see an incoming connection from IOHK.


128 bit for 11 seed word and 256 for 27 seed word
for 128 bit 1.02 x 10^18 years.


Why are proposals to solve issues discouraged during the insights phase (first week)?

The Catalyst Team identified research that showed an "ideation" phase where participants shared their observations and experiences without proposing solutions led to better results when proposals/solutions were put forwards.
Catalyst has translated this research into their "insights" phase process.


Are there any API's I can integrate with to accept Cardano as a merchant?

To answer my own question, you can currently use https://nowpayments.io/,  https://adapay.finance/, or to roll your own solution https://blockfrost.io/.
There's also an ongoing petition to get Cardano added to BitPay.


Is there any kind of help for people who want to start a stake pool?

You can apply for support from the Cardano Foundation here. https://iohk.io/en/blog/posts/2021/04/01/announcing-a-new-round-of-community-stake-pool-delegation/
These happen quarterly, there's no guarantee that you'll get it, but it's worth a shot, especially if the mission and vision of your stakepool aligns with that of the foundation.
Edit.
It seems the form is closed, but I'd suggest keeping an eye out for the next round of delegations.


To what extent does Cardano's "off-chain governance" in the form of a Board of Directors pose a threat to Cardano's mission of being decentralized?

It won't once all parts of the Cardano road map are complete. Voltaire isn't complete yet, but once it is. The Board of Directors at Cardano foundation do not have the power to control or change the network. This process is being done in multiple steps, like staking and SPOs are now 100% community-produced blocks.
Check out project Catalysts as it is the foundation to what Voltaire completion will bring.


Visit a site like pooltool.io to see current delegated total for the network (top left corner), currently 30.24b ADA but changes day to day. Each epoch we have 0.05 (active slot coefficient network parameter) of the available slots on average assigned a leader slot (chance to produce a block), which is 5 * 24 * 60 * 60 * 0.05 = 21600 blocks per epoch on average.
Doing the simple maths for, say, 1 million ADA delegated to a pool yields 1,000,000 / 30,240,000,000 * 21600 = ~ 0.7 blocks per epoch. Alternatively you can do 1/21600 * 30,240,000,000 to get a result of 1,400,00 ADA for one block on average.


From https://iohk.io/en/blog/posts/2021/04/13/plutus-what-you-need-to-know/:

When validating an address, the script will access the data being
carried by the output, the transaction being validated, and some
additional pieces of data called redeemers, which the transaction
provides for every input. By looking up all this information, the
script has enough context to give a ‘yes’ or ‘no’ answer in what can
be highly complex situations and use cases.

In lecture 1 of the current plutus pioneers program, you find a redeemer on the auction validation script. When making a bid, there are essentially five cases to check. All these five cases need to pass or the transaction will not be even committed to the blockchain (which is good, because you're saving on fees for something that won't succeed anyway):

Is the bid sufficient (the bid is >= the minimum valid bid)
The auction hasn't closed

The three other cases also do data checks (output datum/value, bid refund).
The redeemer (in the auction example) itself is a simple data type that we can define (AuctionAction) to do data validation (particularly on inputs).


A validator script is compiled into Plutus Core by the Plutus Tx compiler. (It's actually a bit more complicated: see https://iohk.io/en/blog/posts/2021/02/02/plutus-tx-compiling-haskell-into-plutus-core/)
This compiled script is shipped within the transaction.
Hashing the validation script ensures that funds potentially located at a script address can only be consumed by transactions that include the exact same script.


Micro-transactions could be done one layer above (for example Hydra) and the transaction fees will only for settlement.
Also, it is fairly easy to lower to fees to match the real-world price. In the future, maybe an AI system can do that will a help of oracle.


In regards to the fee changes, this attack is somewhat mitigated by the protocol itself. Fee changes take effect in N+2 epochs. So, even if a pool operator raises their fees right before an epoch ends, the delegators still have 5 days to switch their delegation before those fees start to take effect. The attack on the Cardano Foundation's delegation was not successful because of this.
To be made aware of pool changes, I believe there are telegram bots from both adapools.org or pooltool.io and several other services that notify you of pool changes.


All the techniques you have learned for development on the Playground (or using the EmulatorTrace-monad) will still be valuable and relevant for Goguen.
The only difference is that with Goguen, you will additionally write a UI for your contract(s).
But you still need to write on- and off-chain contracts and test them on the Playground or in the EmulatorTrace-monad.


Cardano-graphql: Hasura migration failing for me

Can you make absolutely sure you are using the cardano-db-sync release 9.0? The specific field merkle_root has been removed only some days ago and this change is still only in the master branch, unreleased.


Native Token Names: How may I prevent other Projects from using my Project's Cardano Native Token Ticker/Name (fungible) on any blockchain network?

Tokens are identified on Cardano by their policy id. This will be completely unique to your token when you mint it. You can then register your token in the github token registry. Wallets like Daedalus will use this information to determine how to display your token in the wallets. The CardanoFoundation maintains this repository so they can clean up any scam tokens that are trying to impersonate yours.
https://github.com/cardano-foundation/cardano-token-registry


How will dapps handle cardano inflation from staking rewards?

There are many ways how to handle this and it's really up to the dApp creator.
But, keep in mind, that the smart contact can delegate their ADA too and earn rewards on it as well. I can see some dApps redistributing this rewards back to the users in the future.


Using cardano-cli with a Daedalus wallet

You can use the cardano-address cli tool


Why do we need parameterized contracts? Can't we just use datum?

Yes. It's important to have both options though.
Remember that the script address is derived from a hash of the compiled script code. So, if you parameterize parts of the script, the script address will be different with each parameter.
An example Lars gives in the PPP is an NFT. If you parameterize the forging policy to take a specific UTxO, and that script consumes that UTxO, you guarantee that there is only one instance of that policy. Only the person who owned that UTxO could possibly create that token, thus guaranteeing the creation only happens once.
If you had the same UTxO field in the datum, any instantiator of the script could specify some UTxO they own and the script address would be the same. Since the Currency Symbol is in fact the Script Address, any caller could create duplicates of the token and those tokens would be fungible.


How is inflation offsetting staking rewards?

Each epoch .22 % of the remaining pool are distributed as rewards (therefore .22 % of a slowly declining pool) . So there will be a smooth reduction of inflation. This is unlike Bitcoin where inflation rate only adjusts every four years (when it gets cut in half). Although I have not done the math, I've heard that the .22 % rate was chosen so that the rate of inflation will effectively be the same as Bitcoin (i.e. four years from now it will be  about half what it is today.)


How Cardano is different from Ethereum (2.0)?

TL;DR:

Research-led design (102 academic papers to-date)
eUTXO transaction model (vs. Ethereum's account-based models)
Formal verification (related to 1.)
Functional-language-based (Haskell-based) smart contract language and VM (Plutus vs. Solidity)
Strong presence in emerging economies (Africa and Asia) in order to accelerate economic development and accelerate adoption
Guarantees regarding cost and executability of a smart contract prior to deployment, avoiding unnecessary gas fees.

I'm not an expert, so don't expect this to be a complete answer. But, Cardano is being developed in the context of academia and industrial partnerships. As of writing, the developers of Cardano (and their associates) have produced 102 academic papers formalizing the mathematical behavior of blockchains, generally, and of the delegated proof of stake and extended UTXO (unspent transaction output) model that the Cardano blockchain has spearheaded.
Related is that a very large emphasis is being placed on formal verification of Cardano's source code/implementation. Formal verification is the process of using software to prove, mathematically, that a certain set of code performs exactly as its designed to. A simple example would be formal verification of a function that calculates the hypotenuse of a right triangle given the lengths of the perpendicular sides. A formal verification system would operate on the source code (not the binary output, I understand) to verify that the routine does compute (and only computes, I think?) the Pythagorean theorem and isn't a virus that you might otherwise execute on your system.
Related to the above is the development of a function programming language based on Haskell, called Plutus to be used with Cardano's smart contracts platform (also called Plutus). By contrast Ethereum's smart contract language is called Solidity and is loosely based on ECMAScript/JavaScript, Python, and C++. Functional programming languages (LISP, Scala, Haskell) are preferred in environments where algorithmic and runtime safety is paramount, since the use of functions over classes/objects ensures side-effect free programs which are unlikely to mutate in an unintended way.
Additionally, Cardano is looking to work within a solid regulatory framework. Recently, the Cardano development company announced a partnership with the Ethiopian government to establish a decentralized identity system using the Cardano blockchain.
Cardano is also working hard in developing countries to bank the unbanked and provide loans and opportunity to historically disenfranchised communities.
Additionally, the Plutus platform includes, as a design goal, the feature that the cost to execute a smart contract is known prior to deployment (unlike Solidity) and the Plutus platform provides strong guarantees about the runtime behavior of your contract (it will either execute successfully or fail to execute, it won't fail while still incurring fees for partial execution.


Signs for the trustworthiness of the Sundaeswap project?

As much as I'm voting to close this question as it is opinion based, I'm going to provide my insight as it can save people money.
For me, they are not trustworthy because:

The initial team and most of the team is anonymous
They have no track record of previous projects
They have a plan to take millions of dollars from the community but they do not have a value-offering by having at least a whitepaper. Several dates promising the whitepaper has been posted but later deleted by the team
They are banning people raising concerns from their twitter and discord, censoring discussion
They have no skills to even run their own pool and are trying to outsource it, which is a basic technical skill when you try to build on Cardano

Several highly trusted community members have already warned about the red flags, for example Sebastien.


ERC-20 converter - eth native vs ada native tokens

The original Ethereum tokens are known as AGI tokens
The translated tokens that are Cardano tokens are AGIX tokens.  The X at the end of the name differentiates them.


How secure is Ouroboros Proof of Stake compared to Bitcoin Proof of Work?

Initially, consensus protocols using Proof of Stake for sybil resistance faced several technical problems that needed to be addressed in order to provide sufficient security properties in a trustless environment. Among the most important we have:

The nothing at stake problem
Long range attacks
The need for a decentralised and robust source of randomness

The fact that "stake" is not tightly coupled with a physical resource (like energy in PoW) means that when a fork of the chain occurs, there is no direct incentive for a node to pick only one chain. With PoW, validating an additional chain has a significant energy cost for a node. In PoS, it's just some marginal disk, computation and bandwidth usage. Similarly, a malicious node can create an alternative chain from genesis and present it to the network as the legitimate chain, since there is no much cost involved in doing so. These two problems I just described correspond to the nothing at stake and the long range problems, respectively, and for a time were considered unsolvable.
Problem 3. was relatively easy to solve. Ouroboros classic introduced publicly verifiable secret sharing (PVSS), but it was not robust to adaptive attacks (see more details in the linked paper). Then Ouroboros Praos introduced a much more robust mechanism based on Verifiable Random Functions (VRF). In short, with VRFs the pieces of data required to compute the random beacon are computed locally by each node, and are not broadcasted to the network. This way, an attacker cannot know who the next block proposer will be.
The long range problem, also known as the bootstrapping problem, was perhaps one of the most difficult. In simple terms, it is about how to guarantee that a new node joining the network can actually reconstruct the whole blockchain history of the legitimate chain. PoW chains solve this issue with the simple and elegant longest chain rule, and that's probably one of the main reasons why they were considered superior in terms of security. As far as I know, Ouroboros Genesis was the first PoS-based protocol that solved this analytically.
Finally, every blockchain design needs to meet properties such as guaranteed finality and liveness. All the Ouroboros family of protocols provide analytically proven finality and liveness properties under certain theoretical conditions. It is important to make this distinction because the theoretical models might not always take into account all the possible attacks and disruptions that may happen in real world conditions. Also, research results from different blockchains are typically presented over a different set of theoretical assumptions, so it's important to understand them before comparing them.
That being said, recent versions of Ouroboros have been studied under a rather relaxed set of conditions, and according to the results presented in the papers, their security properties are comparable to those of Bitcoin.


The Cosmos Blockchain and Atom token are not based on ERC-20, they support their transfer, so there is no prospect that the Cardano ERC-20 converter could be used directly.
No mention has been made of a Cardano-Cosmos bridge that I am aware of.


Is Project Catalyst the only source of non-commercial funding for Cardano projects?

While Project Catalyst is for commercial and non-commercial Cardano projects, you are not limited to specific resources that fund only Cardano projects.
Venture Capital and non-commercial typically do not go hand-in-hand together. VCs have an interest in your company/project's success. They give you money so you (or one of your competitors who they also fun) can make them more money.
Depending on your project/company/organization you want to build, different avenues are at your disposal that have nothing to do with blockchain.
It also depends on your jurisdiction and whether you can apply for public money. Applying to grants (outside of Project Catalyst) and fundraising efforts are big parts of a non-profits. This question is a little bit too broad to give an accurate answer. If you can be more detailed what it is what you're trying to do (link to your proposal), you may receive more and better suggestions.


I am looking for a practical example of a smart contract with three parties

Your example is interesting and could be really meaningful if real world data (e.g. weather data) can be included.
Here's a simpler example that I can think of based on your example.
Let's say John put up the fence as Bob instructed, but there is misalignment between Bob's instructions and Alice's requirements. Now Alice is thinking about suing Bob, because in her view, Bob acted against her will. But Alice also does not like the courts. But she heard about this dispute resolution DApp on Cardano (to be build) where an independent third party helps the disputants solve their dispute.
This third party can be a mediator that simply helps the parties find a mutually agreeable solution. The payment of said mediator can be in the form of a smart contract. Alice opens a case and initiates the payment of the mediator for her share (usually mediators and arbitrators get paid an equal amount by both parties). This amount is now in escrow and will only be dispersed if the other party (Bob) agrees to mediate this case as well (by paying the mediation fee).
Instead of having two contracts (one between the mediator and Alice, the other one between the mediator and Bob), both transfers can be rolled up into one smart contract.
Of course, there are many more interesting examples, but I hope this example helps. Btw, I will be proposing a dispute resolution marketplace in an upcoming Project Catalyst fund, so keep an eye out for that. There's a lot of little disagreements between neighbors (as you indicated) where smart contracts has the potential of making life a little bit nicer for communities of varying shapes.


Does ADA have any credit features built into it?

This is really up to the users (or dApps) on Cardano, but in order to get credit you normally have to provide a collateral. The lender wants to make sure they are getting their money back. Getting credit without putting down a collateral will at least require some form of identification and proof of trustworthiness. Simply having an account/address on Cardona won't be sufficient because anyone create those indefinitely. So in the end it depends on what kind of solutions will be deployed to Cardano and how they are integrated to identity providers all around the world.


Re-Implementing Policy Hashing in Python

It seems I was close, but the str.encode() function was not the correct one to use.
Also a zero byte needs to be prepended to the data to be hashed. Thanks to user bwbush from the cardano forum for helping me out, couldn't have done this without his help!
Here's the final solution:
import hashlib
from cbor2 import dumps, loads, shareable_encoder, CBORTag

class Sig:
        def __init__(self, hash, slot):
                self.hash=hash
                self.slot=slot

def default_encoder(encoder,value):
        encoder.encode([1, [[0, bytes.fromhex(value.hash)], [5, value.slot]]])

obj=Sig("37c19eca0d623d804bfeb8951bf1eb0f7fe193deeb71793985dbd25e", 32241869 + i)

serialized = bytes.fromhex("00") + dumps(obj, default=default_encoder, value_sharing=False)

m=hashlib.blake2b(digest_size=28)
m.update(serialized)

print(m.hexdigest())


What is the logic behind Cardano's tokenomics and emmission schedule?

The uncirculated (reserve) coins are distributed over time at a specific percentage rate.  As the reserve decreases in size, the amount distributed each epoch (5 days) will decrease.  At the current percentage rate the reserve will halve approximately every 4-5 years.

Ada has a fixed supply of 45 billion coins
30 Billion coins were issued/sold during the ICO rounds
The other 15 Billion coins were placed into a reserve for operation of the network
Every 5 days (each epoch) the transaction fees and a fixed percentage of the reserve are added to a pot
A fixed percentage of the epoch's pot is added to the treasury and the rest are distributed as staking rewards

Cardano monetary policy has a more precise explanation.


Why is there a minimum amount of ADA required to vote for Project Catalyst proposals?

As Dor Garbash mentioned there are several reasons:

performance - the reason why they delayed Fund4 is that now the engineering team is working to improve the overall processes so that more people can participate
fraud - to prevent people who don't want to invest time and resources of the project but want to harm the community. So if this barrier is low more scammers/spammers can participate which will lead to lower quality of the whole ecosystem
meaningful participation - this point is connected with the previous one: people who are interested in the development of Cardano and can add value to Cardano should participate


What enables the Cardano blockchain to be capable of storing so much information?

You don't have to store a lot of information on the blockchain itself to provide certain evidence. (that something existed at a certain time or was signed by someone, or that something was not tampered with).
Usually, it is enough to store for example a link to something and a hash or a signature. (i.e. onchain should be stored only the data that are absolutely necessary to prove the required evidence)
Metadata Example: please look into this transaction (on adastat go to metadata tab and look at the data that is actually stored onchain)
You will find the link to http://api.cardano.scantrust.io/publicdata/71a7f9d0.json (where the actual data is offchain, basically, this could even be stored somewhere where only a limited group has access to it)
A good onchain/offchain design combined with batch processing, therefore, enables the cost-effective use of blockchain technology and the preservation of privacy. (which is not Cardano specific)
To get an idea for example with Atala PRISM hundreds of credentials can be signed in only 1 (one) transaction.


What are the security risks of storing an encrypted wallet seed in a password manager?

One of the biggest security threats right now is malware and key loggers.
That is why offline backup and hardware wallets are so important, as you try to shield your signing keys from your day to day computer.
You could use the method you have described on a dedicate laptop that has been airgapped (no network or outside world connection). However, hardware wallets are today very cheap and probably make sense to invest into one instead spending your time with a dedicated hardware.


How big is the Cardano blockchain (now and in the future)?

I'm only answering about the size for now: on one of the cardano nodes that I just checked some seconds ago
$ du -sh state-node-mainnet
9.4G

I can't say how fast it grows. I just look at it from time to time.


Wallet transfer upon death - what process is the safest for transferring wallet details to family members after death?

You could use a safety deposit box containing the wallet keys with ownership of the box going to your spouse/family member on death. That way you can share the key with your spouse/family member before death  but they'll only have access to it as part of your will.


Yes, it does. At the moment you deregister your stake key, you will get your deposit back and at that moment, you are no longer able to receive rewards. All your rewards will go to the treasury.


The list of the word lists is included in BIP39, this is used directly in Yoroi as part of the BIP39 JavaScript module.
It appears, Daedalus is using its own wordlist.


The metadata of a native token must be included in the minting transaction.
The token itself only has a Policy Id, an Asset Name and a Fingerprint.
Here's an example of a token, there you can see under the tab "mint transactions" the Tx and the metadata of the NFT: https://cardanoscan.io/token/59fdb627c01bd87326bef5f4df179bcccb2a2f43


Can Daedalus be used to query the blockchain, like a passive node?

Daedalus runs its own instance of cardano-node under the hood, so by installing and using cardano-cli, one can connect to this node and interact with the blockchain directly.

Start Daedalus, and wait until it reaches the wallet home screen; the cardano-node.socket file is only made available after the cardano-node has started fully.
Use cardano-cli: [Documentation]

Ubuntu Example (Bash)
export CARDANO_NODE_SOCKET_PATH=/home/$USER/.local/share/Daedalus/mainnet/cardano-node.socket
cardano-cli query tip --mainnet

MacOS Example
export CARDANO_NODE_SOCKET_PATH=~/Library/Application\ Support/Daedalus\ Mainnet/cardano-node.socket
cardano-cli query tip --mainnet

Windows Example (PowerShell)
On Windows, a socket file isn't used, instead we specify the pipe used, which has a different name every time Daedalus runs.
cd "C:\Program Files\Daedalus Mainnet"
$ENV:CARDANO_NODE_SOCKET_PATH = (Get-ChildItem \\.\pipe\ | Where-Object {$_.name -like "cardano-node-mainnet*"}).FullName
.\cardano-cli.exe query tip --mainnet


Yes Sir. ADA has a fixed supply and just like Bitcoin it is always going to be deflationary. It's the mindset. What is "deflationary"? That's only when you convert it to FIAT correct? The whole purpose of Crypto is not ultimately converting it into FIAT. If you remove FIAT from the picture, people will use it as SOV and also for transactions as value exchange. Then the whole concept of "deflationary" will slowly die and we will only be talking about "finite supply".


How does Cardano differentiate itself in the DeFi space?

At this moment, they are no DeFi applications deployed on Cardano as we're waiting for smart contracts.


How do I prevent text in Catalyst proposals and insights from losing formatting?

Right now, you cannot, as IdeaScale does not support it. It's embarrassing.
Over time, the Catalyst project hopefully migrates away from IdeaScale to a custom solution. It would be also very cool, if this is built from the catalyst funds by the community.