What events are kicked off when a transaction is submitted? I'm wondering what the exact chain of events looks like once a transaction is submitted.

When a transaction is submitted, it is loaded into the node's mempool. This is like a waiting room for transactions that haven't yet made it on the blockchain. Whether the node is daedalus, or a stakepool, the nodes communicate with each other using the TxSubmission mini-protocol. New transactions are sent to all other nodes in the network.
Once a stakepool has been elected to make a block, it drains its mempool while validating all the transactions. It will fill up the block with all the transactions or until 65536 bytes (the current max block size which could be increased in the future).
That block is published on the blockchain. The BlockSync mini-protocol transmits the block until it propagates to all nodes. All nodes process the transactions in the block and remove any transactions from their mempool that have made it into the block.


What are Catalyst "challenge setting" challenges for? I have a solution idea that can be solved by Cardano and couldn't find the right category for it.  I want to put it in the "challenge setting" challenge.
Do "challenge setting" challenges have limits on what can be proposed?

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.


What does Atala Prism use ADA and the Cardano network for? Can Atala Prism operate or be useful without performing transactions that require ADA?

No. If Atala Prism is going to record its information on the Cardano blockchain (as IOG have said on numerous occasions), then it will have to do so with transactions that pay transaction fees in ADA.
For example, that means that the 5 million Ethiopian high schoolers enrolled in Atala will be driving some transaction volume into the Cardano blockchain.


What are your favorite resources to explain Cardano to people without a technical background? Many of us have been in this situation I suppose: You're with some friends/family and you get asked what exactly this "Cryptocurrencies", "Bitcoins" etc. are.
I'm looking for an easy to understand overview of what Cardano is. Something along the lines of what it can be used for, what the benefits and the risks are and what the goal of the project is.
Are there any such resources available? Videos, blog posts, anything that could be understood by someone who has no clue about the topic.

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


Could the CF (15 million) and IOG (3 million) funds be split between more small pools? There are a lot of small pools out there that find it hard to get the minimum stake to ensure at least one block per epoch.
As you may know, CF and IOG have rounds of funding every three months: CF delegates 15 million ADA and IOG 3 million.
The minimum amount of stake to get one block per epoch is about 1 million ADA.
So my question is, will CF or IOG ever consider delegating just one million to many more pools, thus helping more pools achieve their social goals?

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


Wallet transfer upon death - what process is the safest for transferring wallet details to family members after death? What is a safe / vetted process for handing over 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.


How to market a stakepool? Besides:

Running a zero percent margin pool
Offering a bonus of 1000 Ada for a stake of 1 million
Starting a podcast
Advertising on Adapools.org using coinzilla
NFT giveaways

What other mechanisms are possible to market a stakepool?

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.


Can Daedalus be used to query the blockchain, like a passive node? Daedalus is a full node wallet application, but can I use the full node to query the ledger?

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


Node.js - Plutus/Haskell Wrapper Do you think a Node.js/JavaScript Wrapper for the Plutus programming language (I think it was Haskell?) is possible? This would bring millions of developers onto the Cardano ecosystem and their smart contracts.
I'm not that deep in the blockchain world, so I'm just wondering if this is technically possible.

Technically it should be possible once the IELE virtual machine is finished. Currently it is still under R&D.
Once complete, we should be able to run code from any platform/framework inside the virtual machine if the appropriate conversion tools are also built.


Logistics of Developing Contracts We've done a lot of development on the Plutus Playground; in what ways will the logistics of developing and deploying contracts differ in Gougen?

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.


Multisig wallet for Cardano? Does Cardano support multisig wallets? If not, are there any ongoing projects to have them implemented, any standards defined or at least drafts proposed?

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!


How can I stop Daedalus filling up my Time Machine backup drive on MacOS? Every time I open Daedalus, a multiple gigabyte backup is triggered to Time Machine at the next backup time.  This is likely to fill up a Time Machine backup drive fairly quickly.
Thus I'm wondering what is a good choice of directories to exclude (from within the Daedalus state dir, found at ~/Library/Application Support/Daedalus Mainnet), to exclude transient files from backup, which don't need to be backed up. (Excluding directories from backup is done via System Preferences/Time Machine/Options, for those who don't know.)
It would seem unnecessary to backup the blockchain itself(!) (I think we can rely on that being done elsewhere... :), but, it may not be ideal to exclude the entire data dir, because, some people may be using software wallets, in which case including those in a default backup, should a full system restore ever be needed, might be sensible.
For clarification, this question isn't about recovery seed backups, which are essential and should already be being done in all cases. The question here is about how to achieve an effective time machine backup ("time machine" is apple's rsync style backup, for those from the linux world, not familiar with mac).

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


How do I determine who the moderators are for Project Catalyst? I am trying to find out who to contact if I need to ask a question, make a suggestion or make a request about changes to a proposal or challenge.

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.


When will Daedalus show NFT'S? I believe it is already possible to see NFT'S in Yoroi, I am wondering when could we expect similar features in Daedalus.

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.


What will the ERC20 converter use as an exchange rate? Will it convert tokens based on ADA/ETH pair price at the moment of conversion? If so, which exchange will it use for knowing the rate of exchange?

I assume that a good solution would be to provide an oracle that calculates the average price coming from different exchanges.


Can two-factor authentication (2FA) be added to the Daedalus and Yoroi wallets? I would like to ask if it is possible to implement 2FA at the wallets of cardano for increased security. As I see it we like to attract people from developing world they don't have access to hardware wallets and definitely the price of them isn't helping.
So is it possible?

2FA (in the traditional sense) relies on a shared secret. By design, this can only work in a centralized environment like an exchange or an online wallet, not with a wallet that interacts directly with the blockchain.
But there are other ways to achieve this, and a multi-sig would be possible and kind of the blockchain equivalent of 2FA. Multi-sig means, for example, you need two private keys to access the funds. (both keys should live on different devices)
There are also more advanced and configurable multi-sig solutions (m-of-n type) like: there are three private keys (m), and two of them (n) are sufficient to control the funds. We will see beautiful solutions here in the future.


How to get around a "withdrawal address format is wrong" error? I would like to transfer some ADA from a binanceus.com account to a Coinbase Pro account.
To do this, I get a receive address from the Coinbase Pro web site, which I copy-paste as-is to the appropriate blank in the binanceus.com site's funds transfer form.  After I initiate the transfer, it fails immediately with an error of the form:

addr1vyXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
The withdrawal address format is wrong. Please check the withdrawal address length and character content and try again

(Though I have redacted with X's most of the receive address in the listing above, I have preserved the original number of characters, namely 58.)
I have attempted this multiple times, with new receive addresses from the Coinbase Pro site, with pretty much the same results.  (FWIW, all these other addresses have had the same length as the one shown above, and they all have begun with the addr prefix.)
I submitted a ticket to binanceus.com's customer support several days ago, but have received no answer (other than an automatic "we're really busy" one).

Qs: Is there some alternative format I could use for such an address?  If so, are there tools I could use to safely convert a specific address to this alternative format?  Alternatively, where can I find a description of the algorithm to convert from one format to another, so that I can implement the conversion myself?

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.


How big is the Cardano blockchain (now and in the future)? This may sound a naively simple question, but...

How big is the blockchian today?

How big is it likely to become in future?

I note that Daedalus' state directory on my machine is currently ~10.3G.
Is it correct then to say that that's the "size of the chain" today?
For the second question, we could hypothesize a number of scenarios, like:
5 million Digital Identities are issued.
What impact is that likely to have on storage requirements of Daedalus?

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.


Is there a Daedalus wallet planned for mobile devices (Android and/or Apple)? Will I be able to delegate to a stake pool from my mobile phone with Daedalus?

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!


How do i calculate the fingerprint of an asset? If i have an asset with
policy id: 2697bec9e609932eaaaafb34c8e1ea706549d268166ef60285026b85
asset name: redomgrun
how do i calculate the fingerprint asset107k0vzcplp8rjc3d2y8cew6z2gdhvnqru2uluu?

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.


What are the pros and cons of Cardano's liquid staking over other protocols that use a bonded staking model? As some background, Cardano has a "liquid" staking model, which means that stake is never locked when it is being delegated. Other, "bonded" staking models require a locking period of various lengths (anywhere from days to months), which means the coins can not be moved and spent. I'm hoping a two-fold answer can be provided that discusses security and economics.

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.


Is Cardano working on any solutions to work out disputes between parties? I know dispute resolution within smart contracts (when used as a method of transaction) is not a simple issue. Is Cardano working through any innovative solutions to work out disputes between two parties?
Thanks!

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.


Relay Node vs Block-Producer Node This might be a novice question, but please bear with me :)
I'm working towards becoming an SPO and have a question regarding setting up the two types of nodes:

I have a Raspberry Pi 4 and an AWS, which should I (ideally) configure to be the relay node and which, the BP?

Regards

You would probably want to use the AWS node as relay. This way you don't have to distribute the IP address of the Raspberry Pi in the Cardano network. (I assume you want to run the Raspberry from your home).
You also need to figure out if you have a static IP where you setup the Raspberry or if you get a dynamic IP from your ISP. If you get a dynamic IP, you need to make sure you either update it in your relay node every time it changes or you need to setup some sort of dynDNS service.


How to get intellisense/auto suggestion working for Plutus in VSCode? I've been seeing Lars get auto suggestions from his terminal when he's typing. I want the same in VSCode, how to get it?
PS: I don't get auto suggestions in cabal repl too.

Simply install the Haskell extension from inside Visual Studio Code. You'll get there by pressing Ctrl+Shift+X and searching for Haskell.
Note that the extension requires a ghc installation (=<8.10.4) on your system. The current release of ghc 9.0.1 is not yet supported.


Verify that Token is NFT I was wondering how it is possible to actually validate if a certain Token is an NFT without having to inspect the code of the script which mints that Token? Only by checking if the current quantity is 1 will certainly not ensure that it won't be possible to mint more of that Token.

You can check the token policy for that. For most NFT projects you can look it up on https://pool.pm
A token policy can look like this:
{
  "scripts": [
    {
      "keyHash": "66833acfcf26d87e56bc829aa7bcef13295d4eee4d8b442175bd67a9",
      "type": "sig"
    },
    {
      "slot": 31882046,
      "type": "before"
    }
  ],
  "type": "all"
}

You can see the "slot": 31882046 and "type": "before" values which means tokens with this policy can only be minted before slot 31882046. To be sure that your NFT is unique, you can check that the quantity is 1 and the current slot of the blockchain is later than the one mentioned in the policy.
This policy is from the following NFT: https://pool.pm/1131301ad4b3cb7deaddbc8f03f77189082a5738c0167e1772233097.CardanoBits1947


What is the maximum timeout for a contract that you can define in Marlowe? We know that Marlowe contracts always end mandatorily because a maximum timeout is defined. I wonder what the maximum timeout is, it seems like you can put a huge epoch/slot in which would be practically "infinite".

You're correct that the duration of a Marlowe contract could be practically "infinite": there is no specific limit on the timeout slot for a Marlowe contract.


As I front-end developer, how should I start learning more about blockchain and should I start with Plutus? I'm currently a front-end dev - HTML, Javascript, CSS, PhP. I'd like to get into blockchain, but I don't know where to start. Any advice? Should I start by learning Plutus? If so, where should I start? Are there any online tutorials?

Smart contracts on Cardano are actually developed using Haskell which is then compiled into Plutus Core by the Plutus Tx compiler. Plutus Core is a very low-level programming language and programming wouldn't be fun.
The best place to start learning is to participate in the Plutus pioneers program.
More Haskell resources:
If you are not familiar with Haskell, grab a book such as Learn You a Haskell for Great Good!, as it will be very helpful.
If you want to focus on the Haskell features required for programming smart contracts, have a look at the Mongolia class recordings: Haskell and Crypto Mongolia 2020
Also see this YouTube playlist: Haskell for Imperative Programmers


Is Project Catalyst the only source of non-commercial funding for Cardano projects? If I have an idea that is not funded on Project Catalyst, where else can I find funding other than venture capital firms
Please disclose any affiliations (if you have them) when answering.

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.


Is the NFT ticker unique? When I create a new token, how can I differentiate it from another token?
Can various NFT tokens exist with the same ticker?

Tokens are uniquely differentiated by their Policy ID and Asset Name, which are combined to make a unique Asset ID. The Policy ID is a hash of the monetary policy script that was used to mint the token, and the Asset Name identifies the token under that Policy ID. So long as you just mint one token with the a particular asset name under that policy, the NFT will be unique.
So, the ticker (its Asset Name or the "Ticker" field its minting metadata) is not unique by itself, but the Asset ID or its Policy ID will distinguish it from other tokens with the same ticker.


How do I build a debug configuration of a Plutus project? When I try to set a breakpoint in a small Plutus project such as this, I always get the following error:
:b Week05.Homework1.mkPolicy
cannot set breakpoint on Week05.Homework1.mkPolicy: module Week05.Homework1 is not interpreted

(Using Windows, cabal version 3.4.0.0, ghc version 8.10.4.)
Removing -fobject-code or adding -fPIC to the ghc-options won't help, which was suggested here for other Haskell projects. -fPIC does even fail as it is not a Windows thing, anyway.
The error is the same for off- and on-chain functions. So the INLINABLE pragma is not to blame.
Does this have anything to do with the PlutusTx compiler?

This may have to do with Haskell being a functional language. Meaning that unlike imperative languages, there is no 'breakpoints' due to the nature of the language.
The other link you mentioned only works with I/O operations where they follow an 'imperative' style. The answer for your question would be to find a new way to debug functional programs seeing as they dont work with imperative style debugging.


I would like to run a relay node on Ubuntu 20 server without creating a wallet, what are my options? Are packaged binaries available? I am looking to setup a full node on an Ubuntu 20.04 server for mainnet and leave it running. I don't intend to run a stakepool. Are there any packaged distributions I can use?

A stake pool is just a full node with some additional configuration, so the binaries are the same.
If you need to run cardano-node, you might want to start with its Getting started documentation and you can find the release binaries on the Github's release page of cardano-node.


Where to find current transactions per second statistic? Is there any official website to find it?
I can't find it on internet.

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.


Validators for Asset Type What happens / what is the defense against creating a transaction using a validator that isn't expecting an asset type?
In other words: the validator determines "Can this UTXO be spent in this transaction", but is there something on-chain that determines "Can this UTXO be created with this validator script?"
For example: Validator script says "UTXO can be spent if ada amount is 100 ada"; someone creates a transaction that creates a UTXO of 100 USDT locked by this transaction; Is that 100 USDT locked forever?

No validation happens for outputs: Anybody can send anything with arbitrary datum to any address.
So in your example, those 100 USDT would indeed be locked forever.


Can Cardano be used to mint and trade gaming NFTs? Being a total noob when it comes to using blockchain for development, I would like to know if Cardano can be used, at the time being, to mint and trade NFTs for gaming purposes and if this could be fairly easy to achieved on an engine like unity or unreal.
Or should I stick to something that is more directed towards that purpose, like Enjin?

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.


ERC-20 converter transaction history When Ethereum projects move over to Cardano via the erc20 converter, will their existing transaction history be maintained on the Cardano blockchain?

Not directly, as the token minted on the Cardano blockchain will be a new asset.
If such an use case is needed, one might use an oracle to see it or metadata to record it at the minting time.


How to implement continuous interest accruing with native tokens In Ethereum some ERC20 tokens use a calculation to compute the balance, is not just a value stored in a map.
Take for example AAVE. When you deposit 100 USDT in AAVE, you get 100 aUSDT, this aUSDT is an AToken that represents your share in the pool and is 1:1 convertible back to USDT. Initially your balance is 100, but (simplifying a lot) if interest rate is 5%, and you ask aUSDT.balanceOf(me) after a year, you get 105.
Just for reference, this is the AAVE's AToken code: https://github.com/aave/protocol-v2/blob/master/contracts/protocol/tokenization/AToken.sol#L208
This would be possible with native tokens in Cardano? My understanding is no custom code is executed to get the balance (custom code is run in any other operation besides mint/burn?).
If not possible, what will be the best way to model something like this in Cardano.

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.


What should I be doing to become a top tier Plutus Developer?(Besides Plutus-Pioneer-Program) I want to know everything there is to know about development on Cardano. I am currently following the plutus pioneer program, but would like to dig deeper.
Are there any videos, articles, documents or lectures that some more experienced developers can recommend?
Thanks in advance!

Fello Plutus Pioneer here.
Besides following the lectures closely and doing the homework (potentially several times), I would recommend digging into the actual plutus project, go through the source and find your way around. As you know, plutus is currently being developed, so any videos, articles, and documents (even comments in the source code itself) can be outdated rather quickly. So my suggestion is to work with plutus closely. Find some use cases to implement, but also follow the development closely.
See if you can fix some of the issues and/or review the PRs that are made on the GitHub repo and contribute your own.


Why am I prompted to recover Yoroi Wallet every time on startup? Every time I start the app, despite it logging in, I can not see my wallet.
I can see the two options to add a wallet. After that, I can choose between creating, restoring, and connecting to a ledger.
How can I recover the wallet upon startup?

Not sure which platform (iOS/Android) you're using or which version of Yoroi wallet. And, I'm a bit confused about the two options. In my Yoroi application (Android, Yoroi v4.0.2, Commit ea5c1120) I see the option to access my wallets (saved) or, at the bottom,

ADD WALLET (SHELLY-ERA)
ADD WALLET (BYRON-ERA DEPRECATED)

So, if you don't see your wallet(s) listed under (My wallets) then you'll need to either:

A. CREATE WALLET (which will create a new wallet that will be saved in the application in the future)

B. RESTORE WALLET (which requires you to have already created a wallet and have your 12/24 word recovery phrase, your private key)

C. CONNECT TO LEDGER NANO (which requires you to have a Ledger Nano hardware wallet)

You'll need to decide which path makes the most sense for you, but my guess is you'll want to do 1. -> A.


Cardano-Ethereum Bridge What is the best way to write a smart contract that will work across both Cardano and Ethereum? It doesn't have to be released yet but preferably something that will be usable by the end of the year. I believe that this is what the KEVM may allow?

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.


Do old UTXO's ever get pruned from the blockchain? From what I've read, downloading a full Daedalus node is currently around 6-10GB. Do old UTXO's ever get pruned from the blockchain? If not, what's to stop the size of the blockchain from growing indefinitely to the point where it's impractical to store on consumer hardware?

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.


Withdraw ADA from delegation I am shown the following screen when I go to withdraw my ADA from a delegation.

It reads as if I deregister I will stop receiving rewards. Does that apply to the last few epochs where rewards have been earned, but not received as well?

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.


What makes Cardano different from other cryptocurrencies like Bitcoin and Dogecoin? From Wikipedia, cryptocurrency is:

A cryptocurrency, crypto-currency, or crypto is a digital asset designed to work
as a medium of exchange wherein individual coin ownership records are stored in a
ledger existing in a form of a computerized database using strong cryptography to
secure transaction records, to control the creation of additional coins, and to
verify the transfer of coin ownership.

This applies to Bitcoin and other cryptocurrencies.
So, what makes Cardano different?

Cardano is classified as a third-generation Cryptocurrency due to the following reasons.

Smart Network  It is almost impossible to have smart transactions in Bitcoin Network. In Cardano, the transactions will be programmable.
Energy Consumption Cardano uses the Proof of stake concept for evolving consensus with respect to the selection of valid transactions. This reduces energy consumption for running the network by approximately a million times. Cardano can be run using embedded processors.
Research Cardano is an organically evolving financial operating system with more than 100 peer-reviewed academic research papers. While Bitcoin protocol is more or less frozen since the mechanism for adaptation does not exist.
Governance  There is a established mechanism for governance financed by the protocol itself through treasury for continuous research, management, and guidance of the project by its stakeholders. No such mechanism exists in Bitcoin.
Bottom-up Approach   Cardano aims to have practical utility in the lives of millions of people neglected by the traditional financial system. While Bitcoin is just a store of value.

I am avoiding mentioning the other project being compared in the question since I feel it's a meme made with the purpose to discredit cryptocurrency and does not deserve an effort for answers.


Why is there a small difference between addresses derived by the cardano-address tool and Yoroi? Let's consider a Yoroi test wallet with the following seed phrase:
maximum vacuum toe conduct jazz tray romance crawl fossil wisdom disease crazy mountain bird discover
The first address generated by Yoroi is then:
addr1q96a42g6ajjhu5gfw8gch2w0vflfxkqw53pxyufgacscal5f0vdmnq834g9upwe2g0cfzwemmwvfnyawg89g8xeqx4kstanhan
However, if I derive the first address using the cardano-addresses tool like this (where phrase.prv holds the seed phrase):
./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
cat root.xvk | ./cardano-address key child 0/0 | ./cardano-address  address payment --network-tag mainnet

I get the following address: addr1v96a42g6ajjhu5gfw8gch2w0vflfxkqw53pxyufgacscals656txx
For direct comparison:
addr1q96a42g6ajjhu5gfw8gch2w0vflfxkqw53pxyufgacscal5f0vdmnq834g9upwe2g0cfzwemmwvfnyawg89g8xeqx4kstanhan
addr1v96a42g6ajjhu5gfw8gch2w0vflfxkqw53pxyufgacscals656txx
So the first part of the addresses is identical (except for the first letter after the prefix), but there seems to be missing something. What am I doing wrong?
Thanks.

There is indeed missing a part of the address: the delegation part. For more information, please refer to this partially duplicate question and CIP-0019.
To derive Yoroi addresses from a seed phrase using the cardano-addresses tool:
./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

# Derive the stake key.
cat root.xvk | ./cardano-address key child 2/0 > stake.xvk

# Only the index of the payment address is incremented to yield the next Yoroi address:

# First address
cat root.xvk | ./cardano-address key child 0/0 | ./cardano-address address payment --network-tag mainnet > payment.addr
./cardano-address address delegation $(cat stake.xvk) < payment.addr > payment-delegated.addr

# Second address
cat root.xvk | ./cardano-address key child 0/1 | ./cardano-address address payment --network-tag mainnet > payment.addr
./cardano-address address delegation $(cat stake.xvk) < payment.addr > payment-delegated.addr

# Third address
cat root.xvk | ./cardano-address key child 0/2 | ./cardano-address address payment --network-tag mainnet > payment.addr
./cardano-address address delegation $(cat stake.xvk) < payment.addr > payment-delegated.addr


Is there a metadata standard for native assets (talking about fungible tokens first) in Cardano? I've already made preliminary research about the standard.  The below link seem to describe it very well:
https://docs.cardano.org/en/latest/native-tokens/using-the-token-registry/token-registry.html
However, I'd like to ask whether or not is it safe to follow the instructions in the above link when creating my own native assets in Cardano Mainnet? Has anyone have tried to create tokens according to this standard procedure?

As of now, there is no metadata standard/CIP defined for native tokens. But you can follow this CIP PR to know a bit of how the community is trying to define a standard for the same (your inputs are welcome).
Also, you can follow the metadata of some of the NFTs currently live to follow the schematics in case you are going to build a project.

cardanoKnitties
cardanoBits


How would a 51% Attack on the Cardano blockchain be started and overcome? What exactly is the 51% Attack?

How hard would it be to accomplish this attack?

How easy is it to overcome the attack should it actually occur?

The 51% attack is used by an attacker to take over the blockchain. Usually, the community of a blockchain has to reach consensus, which means that once someone mints a new block, other nodes validate it. The majority has to agree that the new block is valid and thus the blockchain has grown one block. All other nodes accept the new block and all it's content (transactions) as valid and "follow" it, as in using is as a starting point to calculate the next block.
For a proof of work blockchain like Bitcoin, this would mean to have more hashing power than anyone else on the blockchain. This would even allow to you overwrite existing blocks. To regain control, the "honest minority" had to increase their hashing power.
For a proof of stake blockchain like cardano, an attacker would require more than half of all staked ada. An attacker would have to buy 22.5 billion ada of the currently circulating supply of ~33bn ada or control enough pools to which this amount of ada had to be delegated to. Buying ada would drive the price up, depending on how fast he wants to buy and how much he agrees to pay per ada and would be very difficult, same goes for running enough pools that attract enough delegators as well.
The attacker could then dictate the content of the minted blocks. To regain control in a scenario where the adversary bought the ada, the "honest minority" would have to buy his coins, which the attacker would have to agree to. In theory, this could be very difficult. However, it is almost impossible for an attacker to obtain that many ada in the first place.
If the attacker controls enough pools thus has enough control over more than half of all staked ada, the honest owners of the coins could simply switch to honest pools.
As for all 51%: with a growing number of honest users participating in a healthy network, an attacker will have a harder time to take it over, until it becomes basically impossible.


Probability of Minting a Block Assume a Stakepool with a delegated amount of x Ada. How can one calculate the probability of minting a block and what factors does it depend on?

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.


How can a developer access the Cardano network? As a developer building an application, what are different way to access the Cardano network?

If you use Nix or NixOs, it is rather straightforward: Build the code for a cardano node using nix (link to current documentation)
Duplicating the official documentation:
git clone https://github.com/input-output-hk/cardano-node
cd cardano-node
nix-build -A scripts.mainnet.node -o mainnet-node-local
./mainnet-node-local

This will run a cardano node on the mainnet.
Then you can also build and use the CLI tool to interact with the cardano network.

In the provided solution above, if you don't want to compile GHC which can take a long time, IOHK provides many binaries that are pre-compiled for you: lots of time gained ! So don't hesitate to use their nix binary cache
In NixOS, I currently set it this way:
# 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=" ];
  };
}


How to derive addresses from a key exported from Yoroi I’d like to code a small crypto portfolio app using python. So to track my ADA, I need to scan the addresses of my wallet.
I found Yorois feature to export a “key” and conveniently, it also states the derivation path. Unfortunately, I’m a noob with regard to key derivation and I’m a little confused by the encoding of the key, since it does not seem to come in a base58 format like BTC extended public keys.
So to have a common testing ground, I created a test wallet and this is the "key" that Yoroi gives me, when I go to Options=>Wallet=>Export Wallet=>Export:
95e74df114717de17ebfb24c05f9fd1c8019bb6f1de117eec10a43670a692866b837a4a5f51d62f3dc3d630d075c8e39e5294323ba146c386c48123aeef5438a
So how would I go about generating addresses from this key using python libraries or the cardano-addresses tool?
I already watched Cardano: NerdOut - Key Derivation by Andrew Westberg. Unfortunately, the public key used by Andrew was exported using Daedalus and not Yoroi and uses a different encoding.
So there are a two more specific questions, that may help with the solution of this problem:

Did I grasp it correctly, that the key given by Yoroi just needs to be converted using bech32 and a xpub prefix, to generate a “standard” xpub key (e.g. bech32 xpub <<< yoroikey using the bech32 tool)?
Reading further info, I learned that Cardano does not use standard BIP-44, but BIP-44-Ed25519. But is this even relevant for the address derivation using a xpub key? At least, looking at an example for Byron addresses, it does not look that way, since the ed25519 library is just used at the very beginning of the derivation.

Thanks.
EDIT: Added key for testing purposes.

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.


Why do Daedalus Rewards Report Epoch End Dates differ from other sources? So I exported my latest rewards report to CSV, as Daedalus allows. The date on the report is April 30, 2021.
If I query the blockchain for my rewards history, the latest rewards I have received are from epoch 261 (Daedalus says we're currently on epoch 263).
Epoch 261 ended on April 25. Why does the report say April 30?
When I check my rewards history on adastat.net, the date on the latest rewards, labeled as from epoch 261, is April 30.
What am I missing?

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.


How secure is Ouroboros Proof of Stake compared to Bitcoin Proof of Work? It is generally thought of that Proof of Work is more secure than competing consensus algorithms.
What security guarantees does using a Bitcoin PoW provide, and how does Ouroboros Praos compare? Will future versions of Ouroboros improve the security of the network?

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.


How can smart contracts interact each other? If the "context" of a smart contract can see only the transaction where it sits and its inputs-outputs, how can a smart contract interact with other smart contracts living in different transactions?

It can't.
But that doesn't mean different smart contracts can't interact. The interaction must simply happen in the same transaction.
As an example, imagine you have some Uniswap-like liquidity pool as one UTxO and another UTxO belonging to an auction contract. Then you can use the pool to swap tokens and then use the swapped tokens to bid in the auction, all in one transaction. That transaction will have both UTxO's as inputs (plus additional inputs for the funds that you swap) and updated UTxO's for both the liquidity pool and the auction as outputs.
You have to think differently when working with the EUTxO-model, but that model is at least as powerful as the accounting model used by Ethereum.


Staying secure for every day users: What recommendations do security experts have for wallet management, safety, maintenance? What's the safest way to store BIP39 seed words?
What hardware wallet backup options exist?
How can I share details on wallet maintenance with family?

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...


Signs for the trustworthiness of the Sundaeswap project? I would like to know, what is known about the trustworthiness of the project subdaeswap?
Is it a project that is connected with Cardano?

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.


How do nodes access the validator code? As far as I know, script address is the hash of the validator script. (Or has the hash of the validator script. I don't know which). So when a node wants to validate that address, It needs to run the validator script. So how does the node access the script?

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.


Ways to burn tokens? What are all the ways to burn tokens, including ADA and other tokens? By burning, I mean to remove it from the sum balance of all addresses. E.g. one way is to mint a negative amount of a token. Are there other ways? (Sending tokens to an address that nobody controls doesn't count; I want the token to be completely gone.)
I'm also specifically looking for a way to burn a token after the 'before' slot of the minting policy has passed.

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.


How can smart-contract disputes be addressed? How will you disputes in a smart-contract obligation be managed? How is fraud prevented if a party does not fulfil an obligation?. When there are various jurisdictions, there may be different governing bodies.

Obligations that are written into the contract, can't be disputed. For example, if a contract allows money to be withdrawn from the contract address, only if the party leaves their money inside for some period of time, then it can be made impossible for a withdrawal to occur before the time is up, using the programming language of the contract.
For things that can't be made impossible through code, then in some cases we can rely on penalties and rewards to enforce the desired running of the contract. One could code in a reward to any entities who provide a proof that a party was trying to cheat the contract, and penalise those parties who are caught. But for this to work, we need ways of providing proofs about the real world that our contracts can understand, which is why oracles will be an essential part of such systems.
For any obligations that are not written in the code of the contract, they will rely on the same things that are in place today, court systems and public reputation. Legal systems may choose to recognise smart contracts as legally binding, and provide some pathway for dispute resolution when a smart contract has failed to do what was intended or otherwise.


How will Cardano address the ledger growth problem? Once the ledger size grows beyond the terabyte magnitude, how will Cardano address this issue?
Storing and querying anything that large seems impractical to me.

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.


How is inflation offsetting staking rewards? I'm wondering how much staking rewards offset the circulating supply inflation rate right now.
We know that annual staking rewards are around 5.5%, but the only metrics I could find about annual inflation rate are here:
https://datastudio.google.com/u/0/reporting/3136c55b-635e-4f46-8e4b-b8ab54f2d460/page/azvBC
So it's around 2% per year.
Which means that people who don't stake actually lose 2% (if we're ignoring coin price appreciation) per year, while people who do stake gain 5.5% - 2% = 3.5% per year.
Does anyone have more information about this?
Edit: I also found this but I'm not sure if it is valid data: https://pastebin.com/raw/a7x2Gu2g

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.)


do you need to know Haskell to code in marlowe I'm interested to play with Marlowe in a textual way.
when I read this tutorial or read some code examples here, it seems to me that I have to be knowledgeable about Haskell's basics, mainly variables and functions, to be able to write Marlowe code.
is my assumption right?
ps: I'm not interested by blocky or js

Yes, you would need to know some Haskell basics to edit your Marlowe contracts if you don't want to use Blockly or JS.


A summary on the goal of Cardano On the website it's mentioned that:

Cardano is a blockchain platform for changemakers, innovators, and visionaries, with the tools and technologies required to create possibility for the many, as well as the few, and bring about positive global change.

We've estabilished that one of the focal points of Cardano is innovation. It's about durability and there's a chain of (peer-)research, specification and integration. A sustainable future, a global society that is secure, transparent and fair., a world without intermediaries but controlled by the empowered many. It provides the template and toolset to a new age of innovation.
For an outsider though, that's all a lot of buzzwords. I've read some of the research, but what I'm missing is a concise overview of the goals of the project. There must've been a need that wasn't met, a goal that was unattainable because there were no tools or anything remotely like that.
All the use-cases listed mention Atala and seem to go across several disciplines. They seem to share the theme of proving things. Credentials, authenticity, origin tracing and auditability. Is that basically what all the buzzwords boil down to?
By the buzzwords alone, you'd almost think their goal is world peace and power to the people. My guess is such a target is a bit broad, so there must be a smaller one. Right?

The phrase I like to use often is that Cardano is "An operating system for the decentralized web".


Problem starting a plutus devcontainer in windows After I upgraded my container to the commit from plutus pioneer programm lecture 3 the VsCode server won't spawn anymore in the dev container.
VSCode tells
could not fetch remote environment

Failed to connect to the remote extension host server (Error: WebSocket close with status code 1006)

The console tells something about getaddrinfo ENOTFOUND localhost:
*
* Visual Studio Code Server
*
* Reminder: You may only use this software with Visual Studio family products,
* as described in the license https://aka.ms/vscode-remote/license
*

Extension host agent listening on 38293

[4406 ms] Start: Run in container: echo 38293 >/root/.vscode-server/data/Machine/.devport
[4408 ms]
[4409 ms]
[4409 ms] Port forwarding for container port 38293 starts listening on local port.
[4410 ms] Port forwarding local port 38293 to container port 38293
[4421 ms] Port forwarding connection from 65417 > 38293 > 38293 in the container.
[4421 ms] Start: Run: wsl -d Ubuntu -e /bin/sh -c cd '/home/wutze/workspace/plutus-pioneer-program' && DISPLAY='1' ELECTRON_RUN_AS_NODE='1' SSH_ASKPASS='c:\Users\wutze\.vscode\extensions\ms-vscode-remote.remote-containers-0.177.0\scripts\ssh-askpass.bat' VSCODE_SSH_ASKPASS_NODE='C:\Users\wutze\AppData\Local\Programs\Microsoft VS Code\Code.exe' VSCODE_SSH_ASKPASS_MAIN='c:\Users\wutze\.vscode\extensions\ms-vscode-remote.remote-containers-0.177.0\dist\common\sshAskpass.js' VSCODE_SSH_ASKPASS_HANDLE='\\.\pipe\ssh-askpass-32ff11722b3a35f061eaff56993e1deab5d0eea2-sock' DOCKER_CONTEXT='default' VSCODE_SSH_ASKPASS_COUNTER='14' docker 'exec' '-i' '-u' 'root' '-e' 'VSCODE_REMOTE_CONTAINERS_SESSION=c2909e18-9ccb-4e7f-9ffc-a2aed511465e1620332517761' '73ba0ca7a6a532509c5d66df05fbfd39d8174e93661432cdbb28933efd49c768' '/root/.vscode-server/bin/cfa2e218100323074ac1948c885448fdf4de2a7f/node' '-e' '
[4554 ms] [20:22:02] Extension host agent started.
[4580 ms] Installing extensions...
[4750 ms] Start: Run in container: command -v git >/dev/null 2>&1 && git config --global credential.helper '!f() { /root/.vscode-server/bin/cfa2e218100323074ac1948c885448fdf4de2a7f/node /tmp/vscode-remote-containers-b989d5aac79afe5555725461b56f804a3d10bef0.js $*; }; f' || true
[4755 ms]
[4756 ms]
[4931 ms] Port forwarding 65417 > 38293 > 38293 stderr: Error: getaddrinfo ENOTFOUND localhost
    at GetAddrInfoReqWrap.onlookup [as oncomplete] (dns.js:67:26)
[4932 ms] Port forwarding 65417 > 38293 > 38293 stderr: Remote close with error
[4955 ms] Port forwarding 65417 > 38293 > 38293: Local close
[4956 ms] Port forwarding 65417 > 38293 > 38293 terminated by extension with code 1 and signal null.

Any ideas what's gooing wrong? The commit from lecture 1 worked.
I already checked all hosts files from windows, wsl and the dev-container, all contain the localhost 127.0.0.1 entry.
I also opened a cli in the dev container and startded node with /root/.vscode-server/bin/cfa2e218100323074ac1948c885448fdf4de2a7f/node and it also fails
> dns.lookup('localhost', {hints: dns.ADDRCONFIG|dns.V4MAPPED}, console.log)
GetAddrInfoReqWrap {
  callback: [Function: log],
  family: 0,
  hostname: 'localhost',
  oncomplete: [Function: onlookup]
}
> Error: getaddrinfo ENOTFOUND localhost
    at GetAddrInfoReqWrap.onlookup [as oncomplete] (dns.js:67:26)
    at GetAddrInfoReqWrap.callbackTrampoline (internal/async_hooks.js:131:14) {
  errno: -3007,
  code: 'ENOTFOUND',
  syscall: 'getaddrinfo',
  hostname: 'localhost'

for another hostname it works:
> dns.lookup('www.google.de', {hints: dns.ADDRCONFIG|dns.V4MAPPED}, console.log)
GetAddrInfoReqWrap {
  callback: [Function: log],
  family: 0,
  hostname: 'www.google.de',
  oncomplete: [Function: onlookup]
}
> null 142.250.184.227 4

It is definitly this commit in plutus because if I checkout the one before it suddenly works again:
SHA-1: 5dbd3b833b40217cb1a63d4f52351ae8876ba86c

* adds a non-root user for use in the devcontainer (#2956)

* adds a non-root user for use in the devcontainer

* remove un-needed files

* .cabal folder permissions for volume mapping

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


cardano-cli calculate-min-fee expects Shelley era transaction body When using cardano-cli version 1.27.0 I want to calculate the min fee for the transaction. The procedure is to create a dummy transaction and using that to calculate the fee.
When creating the dummy transaction using:
cardano-cli transaction build-raw  --tx-in 1...x#2 --tx-out addr1...a+0 --tx-out addr1...b+0 --invalid-hereafter 30458092 --fee 0 --out-file tx-1622014393N.dummy
The transaction file then contains the correct era indicator:
"type":"TxBodyMary"
However, when I then calculate min fee on this transaction, an error occurs:
cardano-cli transaction calculate-min-fee --tx-body-file /tmp/tx.dummy --protocol-params-file /tmp/protocol.json --tx-in-count 1 --tx-out-count 1 --witness-count 2 --byron-witness-count 0 --mainnet
Response:
Command failed: transaction calculate-min-fee  Error: /tmp/tx.dummy: TextEnvelope decode error: DecoderErrorDeserialiseFailure "Shelley TxBody" (DeserialiseFailure 1 "expected list of length 3")

Looks like the transaction is created with a different version of cardano-cli.
Can you please confirm the file /tmp/tx.dummy is the same as tx-1622014393N.dummy?


Can I restore my Yoroi account with only 12 phrases? Yoroi wants 15 phrases from me, but I only wrote down 12. I know it was a Shelley wallet, and can see all details about my Cardano.
Can I restore my account without phrases?

Yoroi uses 15 words for its seed phrase. You did probably used Daedalus to generate it. I recommend you to try to use Daedalus to restore it.


Can Babel fees be extended to be a protocol level DEX? With Babel fees one can pay for transactions in native tokens. Could this be extended to where someone could pay for the ADA part of the transaction fee and also provide a swap with a different native asset the of the swap requestors choice? This would mean the ledger itself could act as a DEX with the lowest possible overhead.

I think you may want to consider reversing the order here. The intent behind babel fees from my understanding is to leverage future conversion guarantees, DEXes, and other avenues for guaranteeing liquidity/conversion to ADA rather than to provide it's own mechanism.
We know these mechanisms will exist on chain from third parties so there is little reason for the foundational infrastructure itself to attempt to solve the problem as well. Instead it can leverage the existing solutions (once smart contracts are live) and allow competition and market forces to push for improvements and drive down prices.
It may be possible depending on how the negative values in EUTxO are implemented. The main issue is that as described in the blog post it currently relies on the assumption that transactions are only filled if the block producers can find a way to fill them. This would still likely be relying on conversion guarantees, DEXes, and other avenues for guaranteeing liquidity/conversion. Essentially this means if the block producers can't or won't exchange the tokens themselves, they'll have to use an on chain solution or the protocol will have to be extended so that non block producers can fill the requests. While this change can be done it would be very much non-trivial as it would likely require running an entire second network for negotiating order filling in between block production.
The issues with using this for running a DEX or liquidity system outside of just implementing it so that using it for DEXes would be feasible are that it'd create a lot of unnecessary transactions on-chain (which is inherent to on-chain DEXes) and depending how the system is implemented, it may put significant unnecessary load on the block producers. You'd probably want to run it on a state channel or side chain however both introduce new problems. The state channels would pose issues as joining may end up too expensive and side chains have significantly weaker security guarantees which would place using such a DEX somewhere in-between on chain and using a CEX in terms of security guarantees.
Additionally note that babel fees are in the paper phase at the moment. This means we won't see them on-chain for at least a year or two and the ecosystem may look vastly different than it does now so our assumptions as to how exchanges and liquidity systems operate may have changed significantly (based on the change we've seen in the last year or so).
TLDR: Maybe. We do not know remotely enough about how the system is implemented to know whether it would be feasible or even possible yet. When a paper on the topic is published, we should know enough to reason about the potential however as it stands it could be anywhere between completely feasible and impossible.

I may be off-base here. If so, I'd appreciate someone chiming in to correct me.


How to restore a wallet with 24 words and passphrase? The BIP39 standard supports an optional passphrase.
Cold wallets such as Ledger wallet support this feature, so you can have your private key additionally to 24 words secured with passphrase.
At this moment there is no option to restore such wallets neither through Yoroi or Deadalus wallets.
How to software recover such a wallet?

The wallets support "hidden" wallets on hardware devices with passphrases but you can't restore the wallet directly into Daedalus or Yoroi. Instead, you need to restore the wallet to a new Ledger device and then connect it to the software
wallet.


How would Cardano applications function with intermittent internet connection? With Cardano's ambition of bringing self-sovereign digital identity and finance to billions of people, it is important to consider that many people do not have constant electricity or stable internet.
Right now, running a Daedalus full wallet takes several GBs of storage and will take quite a few minutes to hours to synchronize the blockchain even with a decent internet connection, so this probably won't be an option in that situation. But even with a light wallet like Yoroi for Android, it takes a while to check your balance.
In a situation where you have two people with a smartphone with a Cardano wallet on it that want to transact together, what is the minimal internet traffic and time needed to send funds from one phone, and get final confirmation on the other? Would it matter if the phones are on the same local network?

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).


Plutus Pioneer Program - Problem with plutus playground client I'm setting up my environment to run the example from lecture #1 (Week01 auction)
All compilations went well but when I try the evaluate in the simulator I always receive:
interpreter Errors
ConnectionError (HttpExceptionRequest Request { host = "localhost" port = 8080 secure = False requestHeaders = [("Accept","application/json;charset=utf-8,application/json"),("Content-Type","application/json;charset=utf-8")] path = "/runghc" queryString = "" method = "POST" proxy = Nothing rawBody = False redirectCount = 10 responseTimeout = ResponseTimeoutDefault requestVersion = HTTP/1.1 } ResponseTimeout)
Please try again or contact support for assistance.

The plutus-playground-server log has the smartcontract and the datum so I think that the call for evaluation was correctly sent but somehow it doesn't come back to the client. In my opinion it's more an issue related to the npm but I don't know how to debug it.
I'm using Ubuntu, all the work done through nix-shell. Plutus tag: 3746610e53654a1167aeb4c6294c6096d16b0502
UPDATE
Further analysis brings me to the conclusion that my system is too slow for the client-server interaction. I saw that the issue is related only to the Auction contract (that's heavier than the demo ones) and watching the trace of the HTTP calls i notice that the /runghc POST takes 34 seconds to give back an answer.
Is there any way i can configure the playground server to consider a timeout higher than 30 secs?

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?