What prevents flash loans attacks from occurring on the Cardano network? Flash loans attacks are current in DeFi space and we saw several ones these last weeks on the Binance smart chain. (Pancake Bunny and Burger swaps)
Mr. Hoskinson said numerous times that if it took years for Cardano to implement smart contracts and DeFi, it was to avoid such attacks and to have a more secure plateform.
My question would therefore be :
Will projects on Cardano be flash-loans-attacksless? If yes how? If not, can we find a way to secure it?
Thanks in advance

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.


Where can I find design and documentation resources for Cardano Smart Contracts? I’d like to better understand the design and features of the upcoming Cardano smart contracts.
Where is the design guidance & documentation posted for them, including their planned functionality, and how we’ll be able to create and use them?
Can community members comment on this / assist with the UX?

I am not a techie. Lars has been posting Plutus videos on YouTube. Plutus is the main language for smart contracts on Cardano. I think it if searchable as Plutus pioneers program. That should get you to the trailhead. I'm not a techie but that is where I would start.


Blockchain Simulator Chokes on Validation Error I'm working through Plutus pioneer homework week 2 file Homework1.hs. I believe I've setup the script correctly, but I find that when running the simulator with a transaction that's expected to fail, the simulator sort of breaks after encountering the validation error. As a reminder, the scripts basically acts like a faucet with "Give" and "Grab" functions, and the validation function is to take two bools and return false if they're not equal to each other. Here's my sequence of transactions:
0: Wallet1 Give 5
1: Wait 1
2: Wallet2 Grab (True, False) // this should fail validation
3: Wait 1
4: Wallet2 Grab (False, False) // should pass
5: Wait 1
6: Wallet1 Give 5
7: Wait 1
8: Wallet2 Grab (True, True) // should pass
9: Wait 1

I'd expect the balances on each step to be:
Genesis: Wallet1 10 Wallet2 10 Script 0
0: Wallet1 5 Wallet2 10 Script 5
2: Wallet1 5 Wallet2 10 Script 5 // Wallet2 fails to Grab
4: Wallet1 5 Wallet2 15 Script 0 // Wallet2 Grabs
6: Wallet1 0 Wallet2 15 Script 5 // Wallet1 Gives
8: Wallet1 0 Wallet2 20 Script 0 // Wallet2 Grabs

But when running in the simulator, it stops at Slot 4, Tx 0 at the top. The Logs however seem to continue to slot 6.
Validating transaction: 4c1f4f09fbfcf30b38e33dcb8759a4c56c7fc1958ccc7f816608fbf49a2fe0a1
Add slot 1
Contract instance for wallet 1: (ReceiveEndpointCall (RawJson "{\"value\":{\"unEndpointValue\":5},\"tag\":\"give\"}"))
Validating transaction: b3e4aae77f5fd3e0a6e2d2b38e80e5971b3a010ae432aa2bf8f576a3ac6c8f1e
Add slot 2
Contract instance for wallet 1: (ContractLog (RawJson "made a gift of 5 lovelace"))
Contract instance for wallet 2: (ReceiveEndpointCall (RawJson "{\"value\":{\"unEndpointValue\":[true,false]},\"tag\":\"grab\"}"))
Validation failed: 033c6c4ae71e507fe66149eb1860cafdebbd7f8eafcd560bed41c400bd275b84
 (ScriptFailure (EvaluationError []))
Add slot 3
Contract instance for wallet 2: (ReceiveEndpointCall (RawJson "{\"value\":{\"unEndpointValue\":[false,false]},\"tag\":\"grab\"}"))
Add slot 4
Contract instance for wallet 1: (ReceiveEndpointCall (RawJson "{\"value\":{\"unEndpointValue\":5},\"tag\":\"give\"}"))
Validating transaction: 217d02eb52b162569b40d20de7f8135ea7ba11f0fab08fd0a80e4f23d6df179e
Add slot 5
Contract instance for wallet 1: (ContractLog (RawJson "made a gift of 5 lovelace"))
Contract instance for wallet 2: (ReceiveEndpointCall (RawJson "{\"value\":{\"unEndpointValue\":[true,true]},\"tag\":\"grab\"}"))
Add slot 6

The other odd thing is that the Balances Carried Forward on Slot 4, Tx 0 (this is as far as the top section runs) shows:
Wallet1 Balance 0
Wallet2 Balance 10
Script Balance 10

Here's a screenshot of the final state of the simulation:

It's as if the top part of the simulation ignores function calls from any wallet that had a validation error result, and only represents wallets that never had a validation error. I wouldn't expect the Script balance to ever reach 10, as Wallet2 should be able to take 5 lovelace after its first failed Grab.
Is this just a bug in the simulator or do I misunderstand how the simulator / blockchain should work?
Thanks!

The problem is that in the off-chain wallet code, after submitting the transaction, there is a line of code that waits for the transaction to be confirmed. Seeing as the transaction is invalid, it will never be confirmed, so the wallet contract blocks on that line forever.
There would be workarounds, but in the final version of Plutus, it will be possible to check the status of validation from the wallet and for example detect if the transaction was invalid.
This means handling this and similar situations will be much easier in future.


Plutus Contracts Delegation Is there or will there be such a thing where delegators can stake to a smart contract itself, rather than a pool?

No, as the smart contract cannot produce blocks.
However, funds within a smart contact can be delegated to a pool.


Is there a Ganache-like in Cardano? Currently, I have been playing around with the Cardano Playground and I was wondering if there is an existing tool already present where I can personally run a Cardano blockchain like Ganache of Ethereum blockchain?
Regards,
Ivan

Yes?
In the lecture #4 of the current Plutus Pioneer program, there's a way to run a faux blockchain with Plutus contracts.  The first 90 minutes are a Haskell tutorial, but then it goes into how to use the EmulatorTrace.
It's not a full testnet, so it might not be a full replacement for Ganache (which I haven't used), so maybe No.


How does Cardano compare with other blockchains in terms of being eco-friendly? It is pretty common knowledge now that Bitcoin is extremely energy intensive to mine, and that Cardano is several orders of magnitude less intensive. However, there are other cryptocurrencies that are marketed as eco-friendly, like Nano, but they are not necessarily blockchains. How does Cardano compare to other blockchains and cryptocurrencies in terms of being eco-friendly?
Also, how will this change in the future if Cardano gains the same popularity as Ethereum or Bitcoin? Will this cause Cardano to become more energy intensive to mine, thus making it less 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


How long does it take to sync a node or a Daedalus wallet? What factors does it depend on? How long does it take to sync (download the blockchain) to a Daedalus Wallet or node. What factors does this depend on (download bandwidth, size of blockchain, upload bandwidth of the source (node))?

It all depends on your hardware, mostly CPU and network connection (yours and your peers), but on most newer hardware you should be able to sync it within a day right now.


What is the difference between "Voltaire" and "Project Catalyst"? Voltaire is described as the governance phase of Cardano.
Catalyst is also about voting for the current and future proposals and themes for Cardano.
Will one be merged into the other?

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/


Stake pool leader logs What is the earliest point to check the leader log for the next epoch using tools like cncli? I though it was 60 hours in to the current epoch, but keep getting the "Query returned no rows" error.

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.


Could the Daedalus wallet use less space on laptops? I use my laptop to store some of my ADA. Unfortunately, running low on disk space, I cannot afford to store the whole ADA blockchain locally.
What are the options for people like me that need to run the Daedalus wallet on low disk space?

Do you need to run the full Daedalus wallet? On low-storage system I'd suggest looking at Yoroi which is a 'light wallet' that doesn't require its own local node.


When do rewards transfer to a wallet in Daedalus? Under rewards one can view your returns for particular wallets. Is this already reflected in the wallet total as utxo? Are any actions required to have the rewards transferred to a given wallet?

The rewards are automatically deposited by the protocol in the stake (rewards) address associated with the wallet. They are included in your wallet total balance. In order to spend these funds, they must be moved to a spending address within the wallet (become an UTxO) which costs a transaction fee. Daedalus automatically does this for you the next time you send ADA out of the wallet (combining transaction fees). There is not really a need to move the funds from your rewards account to your spending account unless you need to spend them. They earn compound rewards whether they sit in your rewards account or spending account.


Where can I find Cardano's academic research papers? Where can I find the academic research papers related to Cardano?  I tried Google Scholar with no success.

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


How can an oracle guarantee certain update rates respectively uptime? After reading the question General approach for allowing multiple smart contract transactions per block I'm wondering how an oracle can guarantee update rates respectively uptime.
If too many transactions want to consume the oracle eUTxO, wouldn't this prevent the oracle provider itself from calling its update endpoint because the eUTxO will often be consumed before he can do it?

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.


is it possible to build a cardano multicurrency dApp wallet? Will there be a cardano dapp built for multicurrency wallet, like Exodus and Guarda, that's desktop based, but built on cardano?

From my understanding Exodus and Guarda are not dapps, which makes your question tricky to answer. I'm going to try and answer some questions that may be related to what you are asking and hope it helps.
First, Cardano is available on many of these multicurrency wallets so if your question related to have ADA or and Cardano tokens added to these wallets then it already is in place. ADA is supported on Exodus for example and I assume they will integrate support for other Cardano-based tokens once they are released.
Next, if your question relates to the dapp support that Exodus has, in particular compound, then I think this is certainly possible down the line. I can certainly see Exodus integrating support for a Cardano-based DeFi dapp given it has enough community support and usage.


Is there a browser-based wallet like Metamask planned for Cardano? Will we have a Cardano Browser Wallet?
Something like Metamask on Ethereum

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


How can I write unit tests for Plutus contracts? I'm a member of Plutus Pioneer Program. I already know about the Plutus Playground and like it very much. However, clicking all the blockchain action scenarios each time is very time-consuming, especially that after changes in the source code the test scenario often gets wiped out.
It would be much better to have a framework to define and run unit tests, as well as not having to edit the code in the browser.
Although I'm new to Haskell, I'm pretty sure there is some unit test environment. Is it also possible to write scenarios in a file and put assertions on blockchain state, instead of clicking them in the Playground?

You can use the EmulatorTrace monad introduced in Lecture #4 for unit testing. You find examples of such tests in https://github.com/input-output-hk/plutus/tree/master/plutus-use-cases/test/Spec .


Hash MisMatch Error on Plutus and Nix I keep getting the Hash Mismatch Error, anyway I can resolve it or get around it?
hash mismatch in fixed-output derivation '/nix/store/7y3jr1jvzkj2146h7sivw0sfr2bhap3j-ghc-8.4.4-x86_64-deb8-linux.tar.xz':
wanted: sha256:06mb0l3y3gbs8znafxskzrkvgf2wbl0m22xsxhs3wzvbyxbqhajc
got:    sha256:0nx6459adisd4p5mjb03yp5jbaxplkjvwzfgkyw3bmwb3g9fgi9j
cannot build derivation '/nix/store/p68295cg7f09il07dsjpyskkmw9ms22f-ghc-8.4.4.drv': 1 dependencies couldn't be built

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=" ];
  };
}


Is it possible to reuse the blockchain for both relay and block producing nodes? While setting up Cardano Stake Pool, we need to have at least 2 nodes: one for Relay, another for Block Producing (BP).
This Relay node downloads the whole blockchain, and the BP Node will connect only to Relay node and it will sync the blockchain from the Relay node.
My question is, since both of these nodes are in same network, I feel like it's duplicate information downloaded twice. Is there any way by which we can share the same blockchain database for both of these 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.


Are there guides for Router Contracts available (now or in the near future)? Will IOHK be publishing best practice guides or common architectures?  For example, in solidity it's common to have a set of "Router" contracts, to assist in upgrading the protocol in the future?

Seeing as Plutus is brand new and that our Pioneers are the very first people who every write Plutus contracts, there are no best practices yet - and we hope our pioneers will help us discover and document some.
Of course, as soon as people have gathered experience with Plutus, we will be happy to publish such best practices.


What advantages does Cardano have over other "fast" blockchains? I'm a developer looking into starting my first dApp project. I've been waiting for Cardano to release smart contracts due to Ethereum's insane gas fees and low transaction throughput.
I recently discovered another blockchain (Solana) that already supports smart contracts and has even cheaper transaction fees and very high transaction throughput. Since it's not even possible for me to build my project on Cardano at this moment, and my original reasons for considering Cardano were low fees and high TPS, I'm beginning to consider building on the Solana platform instead.
I'd like to get your insights on what unique advantages Cardano offers over other platforms before making my decision.

I recently discovered Solana too and found that it has awesome speed. Here are my thoughts from a little review:

Decentralized limit: Hardware recommended requirements for Solana nodes are pretty advanced which limits the amount of nodes that can be run.
Speed: Project Hydra from Cardano has a theoretical limit of 1M TPS acheiving 1/10 of that will still be significant.
Adoption: Its not always just about technology, I like IOG approach to get adoption with deals. Even if the Africa deal falls through they are still pursuing other opportunities.
Transparency: I honestly couldnt find any way to actually connect with the people behind Solara. It just looks like they are popping out high performance tools. I do wonder if there is a tradeoff being done for speed.

Finally, I really like the goal of Cardano which is about making the world a better place by building for the globe.
Most of the crypto ecosystem is mainly in first world countries.


ERC-20 converter - eth native vs ada native tokens When ERC-20 tokens are are converted from Ethereum to Cardano, is it incumbent on the token holder to know that which wallet they can be deposited into?
What happens if say someone holding Eth native AGI tokens tries to deposit unconverted tokens into a Daedalus address or vice versa? How will it be possible for someone holding AGI tokens on an exchange to know whether they have ERC-20 AGI or Cardano Native AGI?

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 does the hardfork combinator work? Naïvely one would think it's a mere version tag on the block. However, most other chains do not include a combinator. How does it work at the low level and why only Cardano has it?

You can get the inside view by Edsko de Vries, creator of the hardfork combinator, here: https://youtu.be/D8OTZULEsaI


What is the maximum number of contracts Cardano can store? I see Ethereum (ETH) can store 2256 smart contracts, so is there any description about this for Cardano, i.e. how many contracts can Cardano 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.


Ideal computer specifications for own staking? I'm very new to Cardano and staking and would like to run my own vs delegating:

what PC specifications would be ideal to run my own pool for ADA 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


Can I run a stakepool on a home router without a fixed IP address? My ISP assigns an IP address to my internet modem -- it's not a permanently assigned static IP address but stays the same for months or years. Can I use the NAT service on my router to channel the ports to an internal node running on my home network?

You could but it is not recommended. You could use DynDNS service, associate the address with an actual DNS entry from your domain. But, from years of experience managing infrastructures, you will run into problems.


Does pool pledge amount impact odds of getting a block? Two scenarios:
Stakepool owner #1 pledges 10k, stakes 10k and total stake from others is 100k = 110k staked total
Stakepool owner #2 pledges 100k, stakes 10k and total stake from others is 100k = 110k staked total
Do they both have the same odds to generate a block, as long as the pledge amount is maintained -or- does Stakepool owner #2 have better odds because more is pledged?
---and can a stakepool owner pledge far more than they can personally stake knowing the pledge will be maintained by others?

A high pledge does not increase the chance for the stakepool to get a block, but it does give a higher reward for the stakepool with a larger pledge than the other one. A estimation of assigned blocks per epoch for a pool can be calculated like this:
[stakepool total stake]/[total stake] x 21600
The pledge can only be linked to the wallet address belonging to the stakepool, meaning that you cannot take others stake in your stakepool and put it up as pledge, if you tried this the pledge would not meet, and the stakepool would not be able to mint the blocks it get assigned, losing potential rewards all together.
PS - I do believe someone in the community has found out how to have multiple people pledging to a stakepool, but this is out of my scope.


What encoding is used for Yorois Wallet export? Yoroi has a feature to export a wallet as a “key” (Options=>Wallet=>Export Wallet=>Export). I guess that it is the public root key, since the description says:

The below you can find your wallet's public key information.
Public keys allow seeing the wallet history for the wallet, but does not allow to spend or move the funds in any way (private key is not included)

For testing purposes I created a test wallet and this is the "key" that Yoroi gives me:
95e74df114717de17ebfb24c05f9fd1c8019bb6f1de117eec10a43670a692866b837a4a5f51d62f3dc3d630d075c8e39e5294323ba146c386c48123aeef5438a
So my question is: How is this key encoded? It does not have any default prefix and seems to be quite long.
I guess that, e.g. for use with the cardano-addresses tool, the key maybe just needs to be converted using the bech32 tool, correct? If so, then what prefix must be used?
Thanks.
PS: This question is part of a bigger question, which I split up into sub-questions, as recommended in the original question.

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.


How do I make a payment from a node address to a wallet using cardano-cli on mainnet? I followed the documentation for building a Relay and Block node.
Part of that involved sending some ADA to the block producing node's address, to be used as a stake pool deposit.
However, the documentation showed the deposit as 2,000,000 lovelace. In fact it's 500,000,000 according to mainnet-shelley-genesis.json, and that's too rich for me to play with tutorials. So I'd like to return the ADA from the Block node to my wallet.
I found this document showing how to make a payment.
I calculated the amount to be the total holding balance of the Block address, less the fee.
The transaction failed. Here's the error:
Command failed: transaction submit  Error: Error while submitting tx: ShelleyTxValidationError ShelleyBasedEraMary (ApplyTxError [LedgerFailure (UtxowFailure (UtxoFailure (OutputTooSmallUTxO [(Addr Mainnet (KeyHashObj (KeyHash "f1a1639d8012278565242d449223c7d40e6e87c81021b99f3bac4749")) (StakeRefBase (KeyHashObj (KeyHash "a9f00a2910b88d5aacd9ef1c8ef4d06ebf7faf1618876a60ed088cc1"))),Value 1 (fromList []))])))])

I don't understand the error, and I'm wondering if the documentation is outdated (given the stake deposit was wrong).
Is there a more current document showing how to submit a payment, using cardano-cli and keys?

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 is there a 45 Billion coin cap for ADA? Really... nobody in more than a year was able to explain me this is a rational way.
Please... I beg you, why 45B and not 45M or 21M or 45.8B ? What's the reasoning behind that?
PS: Engineer, nerd, Studio TD in a video game company, I cannot have a proper life if things doesn't make proper sense xD
Best,
Álvaro.

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.


Calculate timestamp from slot Is it possible to calculate a timestamp from a slot no? Since one slot is one second it should be pretty easy. But...
The current slot now (Tue 18 May 2021 05:46:04 PM CEST) is 29786450.
In mainnet-shelley-genesis.json i can see systemStart  "2017-09-23T21:44:51Z"
Which is acually 1506203091 as unix timestamp.
If i calculate 1506203091 + 29786450 i get 1535989541 which is Sep 3, 2018, 5:45:41 PM something in 2018.
Is there a simple formular? It seems that the actual start date must be something like June 7, 2020 but i cannot find anything abount this date.

You did not account for Byron, where one slot was 20 seconds.
To make it easier, take the start time of epoch 209 which is the Shelley hardfork and started at 1596491091 unix time on slot 4924800.
Therefore to calculate the time of the current slot, you might try something like: 1596491091 + (current_slot - 4924800).


How is a stakepool rewarded? Let's assume I run a stake pool, where I have pledged X ADA, have received delegations of Y ADA and have set a 1% fee.
When my pool creates a block, how much ADA is awarded to my pool and how is this amount distributed to me and the delegators, with respect to X and Y?

Let's assume your pool has the below configuration,

Cost - 340 ADA
Margin - 1%
Pledge - 5000 ADA
Delegation from all delegators - 5000 ADA

We will not discuss the reward calculation timing in this question, as it is a topic for another question.
When reward calculation happens, pool performance is calculated. Which in simple terms is how much total stake the pool controls across all pools ie. this pool controls (X+Y) note - pledge + delegation and the number of blocks it should ideally mint based on the stake it controls. Based on the performance, a pool is set to receive some ADA, for this pool let's keep that ADA to be 1000 for 1 block minted.
Now we have,
Total Rewards for the pool and delegators - 1000 ADA
Next, the protocol will calculate pool fees. Pool fees are the fixed cost + margin.
In this case, pool fees are as below
fixed cost + ((reward-cost)*0.01)
340 + 6.6 ADA
Now we have pool fees = 346.6 ADA
remaining rewards for the delegators = 1000 - 346.6 = 653.4
Next, the protocol will calculate rewards for the delegators from the remaining ADA, which is a straightforward process, each delegator gets rewards as per the share of their stake.
Considering there are 3 delegators including the owner's pledge

owner pledge - 5000 ADA (50%)
delegator 1 - 2500 ADA (25%)
delegator 2 - 2500 ADA (25%)

The reward distribution is as below,
Available Rewards to be distributed = 653.4 (note remaining after pool fees)

owners stake rewards - 326.7 ADA
delegator 1's rewards - 163.35
delegator 2's rewards - 163.35

Now, NOTE that the owner's stake rewards + pool fees are paid to the reward account itself. The owners don't get the stake rewards into their own accounts.
so the pool reward account will get = 326.7 (pledge staking reward) + 346.6 (pool fees) = 673.3
The delegator rewards are paid to the respective staking addresses.
Important to note, if the pool fee is 100%, which means all of the rewards are taken by the pool and nothing is left for the delegators.
here's an example of a pool running at 100% fees that it produces 0 rewards for the delegators. PRIVATE POOL


Is there an equivalent to the Wallet Connect protocol in the Cardano ecosystem? With the Alonzo update approaching, many teams seem to be working on DeFi projects that will go out along the Smart Contracts feature. On Ethereum, most DeFi projects use the Wallet Connect open protocol to communicate with wallet apps, but on Cardano it appears there is no such open protocol.
Is there any team working on an open Wallet communication protocol such as the ones present in the Ethereum ecosystem? If not, does it mean each Wallet App will need to come up with its own?

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.


How will dapps handle cardano inflation from staking rewards? Let's say I would like to lock up some ADA in a smart contract for about 3 months. How will this compete with ~5% APR from staking rewards? Do all dApps need to provide a minimum ~5% APR just to keep up with inflation?

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.


Where and when do I get a chance to review and contest community advisor (CA) assessments of my proposal? My proposal is now in the "assess QA" phase.
I am expecting to see the assessments, so that I can propose rejection of any that do not meet the guidelines.
Will they appear in Catalyst or be listed elsewhere?

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


What prevents a bad user to provide a wrong signature to a transaction? What prevents a bad user to provide a wrong PubKeyHash and sign it with a different signature in the Signed.hs example from the Plutus Pioneer Program NFT lecture?
Policy:
Policy:mkPolicy :: PubKeyHash -> ScriptContext -> Bool
mkPolicy pkh ctx = txSignedBy (scriptContextTxInfo ctx) pkh

Wallet-Code:
pkh <- pubKeyHash <$> Contract.ownPubKey
...
lookups = Constraints.monetaryPolicy $ policy pkh

Couldn't he just use a different pkh and change the transaction signature to mint the token?
What prevents that?
Update:
My question seems to lead people in the wrong directions, so to clarify:
I'm wondering how a transaction is actually signed and why that can't be manipulated.

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.


"min-ada" bottleneck to Cardano analogous to "gas fee congestion" for Ethereum? In reference to Min-Ada-Value
Imagine the following scenario:

Alonzo's long anticipated smart contracts finally arrive to the main net
The ERC20 converter is a massive success and ports hundreds of ERC20 tokens over to Cardano
There are a lot of "WhateverSwap" (e.g. SundaeSwap, YaySwap, Minswap, ...) platforms each running a massive amount of swaps
There are a lot of new smart contracts now being used for the former ERC20 tokens
People are sending ADA, native tokens and former ERC20 tokens around like crazy
In Ethiopia, after Cardano + Atala PRISM turned out to be a huge success for the students, the government decided to replace its currency by using Cardano, now every person is paying stuff in ADA
In Tansania, after seing the success in Ethiopia, the government decided to start a pilot project with also thousands of people using Cardano
<your imagination here>...

All this would result in the price of ADA going up, up and up. Now imagine the price of ADA sitting at $14 (conservative estimate). For every transaction, some portion of ADA (currently 1) needs to be sent with it. $14 may still be affordable for most people in the developed countries, but might be a small fortune for some unbanked. So these people would probably become cut off from using Cardano. And even for the developed countries it is not sure if everyone would be happy to pay these fees.
=> My question is: Could Min-Ada ever become a bottleneck for Cardano the same way the present gas fee congestion is a bottleneck for Ethereum?
I know that Min-Ada can and probably will be dynamically adjusted according to the corresponding situation. However, how well thought out is this solution? Could someone explain the mechanics on how this would work?

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.


How will DApps work on Cardano? This may been too broad of a question but I was hoping to ask a few specific questions here rather than over multiple questions. I don't think DApps are available yet but I'm sure people have started preparing for them.
Will we need to learn Plutus to make DApps and how easily can you transition from Solidity to Plutus programming? I'm also wondering what incentive there is to create and launch a DApp on Cardano over Ethereum?
If anyone could answer these question and perhaps point me in the direction of places to find more resources that would be great.

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.


How can a node verify a transaction with a script address without the script? How can a node verify a transaction with a script address without the script?
I mean when i start a node months after the transaction has been minted into a block. How can my node verify that the script conditions were met since only the hash is persisted in the chain?

By inspecting the current ledger CDDL specifications, you can see that each block contains a transaction_witness_sets field, where each transaction_witness_set is defined as:
transaction_witness_set =
  { ? 0: [* vkeywitness ]
  , ? 1: [* native_script ]
  , ? 2: [* bootstrap_witness ]
  }

Here, native_script, if present, contains some rules that need to be respected in order for the transaction to be valid (for instance, some minting policy):
native_script =
  [ script_pubkey
  // script_all
  // script_any
  // script_n_of_k
  // invalid_before
     ; Timelock validity intervals are half-open intervals [a, b).
     ; This field specifies the left (included) endpoint a.
  // invalid_hereafter
     ; Timelock validity intervals are half-open intervals [a, b).
     ; This field specifies the right (excluded) endpoint b.
  ]

So not only the script hash is included in the chain, but also the actual rules it contains.


How does Atala Prism work? I mean how does it work technically, in terms of its use of the Cardano blockchain?
What blockchain features support it?
Does the use of prism entail the expenditure of ADA by any of the involved parties?
What should I read to understand this more fully?

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.


How does one create receive addresses for a wallet programatically? We wish to generate large numbers of receive addresses for a single wallet. These addresses will let us identify who is sending us Cardano, or other native assets. Can someone explain how one goes about generating such addresses?

Multi address wallets are usually called Hierarchically Deterministic (HD) wallets and are defined by the BIP44 standard.
In Cardano, we do extend BIP44 in CIP1852 by adding staking key capabilities, but this is not your use case.
To derive wallet addresses for a single wallet, it is easiest to use an existing library that can do this for you, as for example the cardano-seralization-lib by Emurgo.
Have a look at their documentation, but this easy snippet you will show you how to derivate the 10th address of your wallet:
function harden(num: number): number {
  return 0x80000000 + num;
}

const rootKey = CardanoWasm.BIP32PrivateKey.from_bech32("xprv17qx9vxm6060qjn5fgazfue9nwyf448w7upk60c3epln82vumg9r9kxzsud9uv5rfscxp382j2aku254zj3qfx9fx39t6hjwtmwq85uunsd8x0st3j66lzf5yn30hwq5n75zeuplepx8vxc502txx09ygjgx06n0p");
const accountKey = rootKey
  .derive(harden(1852)) // purpose
  .derive(harden(1815)) // coin type
  .derive(harden(0)); // account #0

const utxoPubKey = accountKey
  .derive(0) // external
  .derive(9) // <- here is the index of your address, cycle thought this number to generate more of it
  .to_public();


Using cardano-cli with a Daedalus wallet I want to be able to use a wallet that I have on Daedalus, but to mint some tokens. The README on cardano-cli is outdated, and obviously not working and couldn't find an up-to-date instructions to import mnemonic seed using cardano-cli.
From https://github.com/input-output-hk/cardano-cli/blob/master/USAGE.md:

Recovering a Daedalus wallet
For various reasons the CLI does not allow to create Daedalus
compatible wallet. But it is possible to recover a wallet created on
the Daedalus application.
cardano-cli wallet recover --daedalus-seed --derivation-scheme=v1
--mnemonics-length=12 --wallet-scheme=random_index_2levels MyDaedalusWallet
And that's it, you will your daedalus wallet recovered here. No need to transfer the funds to another address yet (and therefor save some transaction fees).

cardano-wallet doesn't seem to have any of those options, or at least, a resemblance of those steps

You can use the cardano-address cli tool


Will I receive rewards for all epochs when I switch my stake pool? I am currently delegating my ADA to stake pool A. I want to switch to stake pool B. What exactly happens with my rewards when I do this?
Will there be an interruption in the reward payout or will I still get rewards for every epoch?

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 one decide what is the best stake pool to delegate to? I'm ready to delegate to a pool. I know the easiest options are to do so using either Daedalus or Yoroi. But, how do I choose which pool to stake to and does it really matter?
I found this post on reddit which does a good job of describing saturation and pledge. It also discusses what the fees mean. What I'm really asking here is that I don't understand why it might matter which pool to delegate to when it seems that any one will give me about 4-6% apy over the whole year. If I'm going to get that APY no matter which pool I delegate to, why does it matter which one I 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.


Will there be a web-based Daedalus wallet? Will there be a web version of the official Daedalus wallet? It is possible to build one for the Cardano community?

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/


Long Term Micro-Transaction Plans I've seen the broader implications of throughput that layer 2 solutions like Hydra will provide for the ecosystem. But I'm curious about how the Cardano ecosystem will provide cost effective solutions for users when Cardano's value starts to increase. For instance, when Cardano reaches $20 (which I am quite sure it will easily do in the not so distant future) if transaction fees remain in the ballpark of .16-.17 ADA we are looking at ~$3.4 for even smaller transactions on the base Cardano chain. How is the community planning on dealing with the "micro-transactionality" that will inevitably come out of Cardano's increasing adoption especially within the rapidly developing community of friends we have in Africa? Would this be a layer 1 solution, or a layer 2 development utilizing a new infrastructure? Cheers!

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.


is it possible in future to buy ADA directly? out of curiosity, is it possible to buy/Withdraw fiat ADA directly from ADA wallet, stack,lend and bypass any existing exchanges to avoid expensive fees ?

LocalBitcoin.com might have some options.


Re-Implementing Policy Hashing in Python As the title says, I want to to reimplement the hashing part of a policy script in Python 3.
I have already made a post over at forums.cardano.org, and someone has pointed me to the right direction of serializing to CBOR according to the CDDL specs.
Here's the relevant part of the CDDL specifications:
native_script =
  [ script_pubkey
  // script_all
  // script_any
  // script_n_of_k
  // invalid_before
     ; Timelock validity intervals are half-open intervals [a, b).
     ; This field specifies the left (included) endpoint a.
  // invalid_hereafter
     ; Timelock validity intervals are half-open intervals [a, b).
     ; This field specifies the right (excluded) endpoint b.
  ]

script_pubkey = (0, addr_keyhash)
script_all = (1, [ * native_script ])
script_any = (2, [ * native_script ])
script_n_of_k = (3, n: uint, [ * native_script ])
invalid_before = (4, uint)
invalid_hereafter = (5, uint)

CBOR and CDDL are both new to me, so I'm not sure if I am doing it right.
According to the above specification, my script
{
   "type":"all",
   "scripts":[
      {
         "keyHash":"37c19eca0d623d804bfeb8951bf1eb0f7fe193deeb71793985dbd25e",
         "type":"sig"
      },
      {
         "type":"before",
         "slot":32241869
      }
   ]
}

would evaluate to:
native_script = [1, [[0, $hash28], [5, uint]]]
Is this correct? Do I need to use any cbor tags for serializing?
Here is my attempt so far (I've tried many variations already, but this feels like the most correct one):
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, value.hash.encode()], [5, value.slot]]])

obj=Sig("37c19eca0d623d804bfeb8951bf1eb0f7fe193deeb71793985dbd25e", 32241869)

serialized = dumps(obj, default=default_encoder, value_sharing=False)
print(serialized.hex())
m=hashlib.blake2b(digest_size=28)
m.update(serialized)
print(m.digest().hex())

result = loads(serialized)
print(result)

Needless to say, the code does not calculate me the same policy id as
cardano-cli transaction policyid --script-file test.script does.
I am using the library cbor2, which seems the best maintained one for python. Also, I use blake2b with digest_size set to 28 bytes since the ledger specs say blake2b_224 is used for multisig scripts. I am however also not sure if the other parameters in the hash function need to be set or not. My haskell skills are also not the best, so trying to look up in the original source code didn't get me very far, and I've tried so now for several hours :-)
If anyone could help me, it'd be very appreciated.

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 are oracle services going to look like on Cardano? Can we expect an effort from IOHK to implement oracle services? Or should this be community driven?

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.


What companies and institutions accept ADA as payment? It would be good to have a central database of all known merchants that accept ADA for transactions.
I've seen a few small businesses posted on r/Cardano that I went 'good for them', and made me wonder of a place where you could check for people and businesses accepting ADA as a method of payment.
Note: IIRC, Shopify allows for ADA payments, not natively, but through an app in Shopify's marketplace.

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.


Can I change the challenge my insight or proposal is located in? I have created a proposal in a challenge and realized that there is a more suitable challenge for my proposal.
When I edit the proposal, the drop-down choice for challenge is greyed-out.
How can I change the challenge my proposal is in?

Sadly, this is not possible right now. You have to recreate it and delete the other one.
:(


When is Hydra going to be completed? I’m impressed with all the work that you have done. I’ve been amazed by Hydra, and everything you continue to do with Cardano.

We will see some form of Hydra in action by end of 2021 or the first quarter of 2022. Charles mentioned a couple of times that a separate team is always working on it and will try to release it sooner than previously planned.


What decisions are left to the slot leader? Is the order of transactions deterministic, or is it decided by the slot leader when creating the block?  Are DEX front-running attacks a possibility?
Can the slot leader censor specific transactions or computations (delay them for that 20-second slot)?  If there is congestion, how are the slot's resources rationed?

These are a couple examples I came up with, but I'm generally wondering what kinds of choices the slot leader is empowered to make. (in order to consider how those opportunities might be abused in subtle ways)

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.


Building and Signing Transactions I'm learning about Cardano. In reading how to set up a node for staking, I came across Building and Signing Transactions. Would someone kindly provide more context when building and signing should take place and by whom? The document showed manual CLI commands for those two procedures. Does that mean if you are administering a staking pool, someone has to build and sign the transactions manually? I don't believe that to be the case as it would take too long.

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.


Does ADA have any credit features built into it? Are there any feature of Cardano ADA or its ecosystem that make borrowing against ADA held easier or better than other cryptocurrencies?
Will all credit require that an application be developed to support 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.


How to access the current slot in a Plutus validator script? At the time the Plutus validator script runs, the transaction is not yet part of the blockchain. But the targeted slot of a transaction is known when a node processes the script. Is it possible to access the target slot inside the validator script?

The context of a validator script Plutus.V1.Ledger.Contexts.ScriptContext gives access to the transaction where txInfoValidRange may provide upper/lower bounds of the slot. This, however, requires that a Ledger.Constraints.mustValidateIn constraint has been specified when the transaction was submitted (as done in this example).

I understand that it is considered to be bad practice for a Plutus validator script to depend on the state of the whole blockchain or unpredictable input such as the target slot because it limits verification/testing possibilities.

Nevertheless, there might be plenty of good use cases for using the current slot; for example, an oracle might check if its data is expired and does not want to enforce its users to provide an upper limit in the mustValidateIn constraint.

Accessing any runtime information (including current slot) should not be possible in the validator by design. The reason is that transaction validity needs to be deterministic on construction. The only reason a transaction cannot be executed afterwards would be, if a UTXO was already consumed or the slot is outside of txInfoValidRange (as explained in this Youtube video).
There might be other use cases, but making sure expired oracle data isn't consumed anymore could also be achieved by deactivating an oracle (which would require the oracle contract to support it). And also it is in the best interest of the party creating a transaction to make sure only trustworthy oracle data is consumed.


Native Token Names: How may I prevent other Projects from using my Project's Cardano Native Token Ticker/Name (fungible) on any blockchain network? I am starting a new blockchain project.  I think I want to deploy the project on Cardano.  When I select a fungible Token Name for my Native Token on Cardano,  how do I prevent another project from using the exact same Token Name as I have used?    I have not found a global registry, like that used for IP addresses/names on TCPIP.   What if a project on another blockchain, say, Ethereum tries to use my exact same Token name, are they blocked somehow?
Also, if another project is not blocked from using my exact same Token Name, how can the fungible tokens be traded on an exchange?
Thanks!

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


Cardano-graphql: Hasura migration failing for me I am having trouble setting up cardano-graphql service. It occurs when Hasura run the migration script to create a bunch a views on top of tables in cardan-db-sync. There error is:
42703] FatalError: column block.merkle_root does not exist
Sure enough I go login to postgres and see that merkle_root is not a column in the block table.
I am running testnet cardano node and testnet db-sync.
I have a multinode setup using nix-build:
Node1: cardano-node, cardano-db-sync-extended (v 9.0)
Node2: cardano-node, cardano-graphql (v 4.0)
Process that runs migration:
cardano-graphql/nix-build/hasura-cli/bin/hasura --skip-update-check --project /nix/store/is2s0kbvbxz04ih2ixzsg7kkyrmhizib-cardano-graphql-4.0.0/packages/api-cardano-db-hasura/hasura/project --endpoint http://localhost:8090 migrate apply --up all

My Hasura start stript:
export CARDANO_NODE_CONFIG_PATH="/home/ubuntu/cardano-my-node/testnet-config.json"
export HASURA_CLI_PATH=${PWD}/nix-build/hasura-cli/bin/hasura
export HASURA_URI=http://localhost:8090
export GENESIS_FILE_BYRON=${PWD}/config/network/testnet/genesis/byron.json
export GENESIS_FILE_SHELLEY=${PWD}/config/network/testnet/genesis/shelley.json
export POSTGRES_DB=testnet
export POSTGRES_HOST=*****
export POSTGRES_PASSWORD****
export POSTGRES_PORT=*****
export POSTGRES_USER=****
./nix-build/cardano-graphql/bin/cardano-graphql

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.


Are there safeguards preventing big centralised exchanges like Binance and Kraken from having too much power in projects like Catalyst? Kraken recently announced it would let its users stake Ada on their account.
However, since Kraken owns this ADA, I understand this means it could have the voting power of all its users combined on platforms like Project Catalyst.
Are there safeguards that would prevent one party from accumulating too much voting power? Or is this a non-issue altogether?

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.


How to make your own coin on the ADA Cardano Network? Is there way to start your own coin in ADA Cardano Network?
Research Effort :

I just googled idea but no suggestions about Cardano?

Any Advice?

You'll need to use the Cardano CLI. It's technical and a programming background is helpful but not required. Here is a walk through video.


How Cardano is different from Ethereum (2.0)? As far as I know, the Cardano project was started to cover issues/problems with Ethereum blockchain. Proof-of-work and governance are some of them.
However, Ethereum 2.0 is promising to cover those issues.
So in this context, how is Cardano 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.


Stuck at Creating Keys for Token - cardano-cli address key-gen I feel like an idiot but I am stuck at creating the keys for a token.
Here is the code:

cardano@transmission:/home/transmission/Documents$ sudo mkdir policy && cd policy

cardano@transmission:/home/transmission/Documents/policy$ cardano-cli address key-gen
--verification-key-file policy.vkey
--signing-key-file policy.skey

Command failed: address key-gen  Error: policy.skey: policy.skey: openBinaryFile: permission denied (Permission denied)

Do you have any idea why I am being denied permission for this command?
Thank you very much!

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.


Will ADA always be deflationary? Considering ADA has a max circulating supply, and productivity of goods and services always tends to grow, does that mean ADA will always be deflationary in the long run? Couldn't that lead to recurring recession environments which discourage people to spend/borrow?

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 to mint a token on Cardano? I need help on how can I mint a token on the cardano blockchain for example an image as an NFT.

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.


How much entropy does BIP39 have? How much entropy does BIP39 have?
How long would brute forcing take?
Can a 2nd factor be included on a wallet, to lock, unlock it?

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


How to delegate ada to several staking pools using only one wallet? At the moment if you want to delegate different amount of ada to more than one staking pool you should have two or more wallets. Is there a way to delegate a portion of the coins to one staking pool and another portion to other staking pools?

In Yoroi, it is possible to delegate to multiple pools using a single wallet, but not in Daedalus. To delegate to multiple pools in Daedalus, you will need to create separate wallets. The stake associated with each wallet can then be delegated to a specific stake pool.
It is worth noting that multiple-pool delegation using a single wallet will not be supported on the mainnet.
Source : https://cardano.org/stake-pool-delegation/ (At the bottom, "Can i delegate to multiple stake pools ?")


Is there a minimum amount of ADA I can send in a transaction? Can I send 1 lovelace (0.000001 ADA) to another address or is there a minimum amount I need to send?
Of course there will also be the transaction fee of (currently) ~0.16 ADA, so such a transaction would not make much sense in most cases. Still I'm curious if it would work.

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


How can I find the Haskell source code for the sqrt function? I am starting to learn Haskell and need to learn how to look things up.
Since I am studying a function that uses sqrt, I want to see how that was made in Haskell.
This is as much an exercise in using reference material as it is in seeing how the sqrt function works under the hood in Haskell. Any advice would be appreciated.

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


How can I tell if I have successfully registered for voting on Catalyst proposals? My PC crashed while registering for voting in Daedalus.
How can I check to confirm that I have already registered to vote.  Must I just go through the process again?

Try to re-register.
However, at the moment of writing this post, there are no current Catalyst project registrations, are you sure you are just not using an older version of Daedalus?


What has happened to the KEVM? One of the big selling points of Cardano was EVM compatibility out of the box through the KEVM project.
It now has disappeared as a talking point: Has its development stopped?

Development is alive and kicking.
Alongside our native smart contract language Plutus, we are still on track with the KEVM and its support for languages like Solidity and Glow.


Will small stake pools find it hard to cover running costs? "Stake pool operators are rewarded for running the protocol in the form of incentives that come from the transaction fees and from inflation of the circulating supply of ada", as mentioned at this docs
In case a small stake pool does not get elected for block creation, how much of the running costs would be covered assuming that minimal hardware confguration is employed on the stake pool?

If the stake pool does not create a single block in the epoch, it receives no rewards.
If it is elected and is able to create at least one block, it receives the fix pool fee, which is right now minimum of 340 ADA plus the margin fee.
Minimal hardware configuration is debatable, but you can run a pool as low as 1 EUR (about 1ADA with today prices) per epoch.


Can we expect to see already existing stablecoins on Cardano? I know there is a new stablecoin (AgeUSD) that is supposed to be released on the Cardano blockchain, but I haven't heard anything about having other stablecoins, like Tether (USDT), be added to the Cardano blockchain. Is this something we can hope to see, or is the creation of AgeUSD going to make the addition of Tether not necessary?

As far as I know, the Liquity team is interested to have their protocol deployed on Cardano too. But it is too early to tell.


Is there a maximum amount of ADA I can send in one transaction? This question is related to one of my previous questions: Is there a minimum amount of ADA I can send in a transaction?
I wonder, if there is a minimum amount of ADA I can send in one transaction, is there a maximum amount too? Or would it theoretically be possible to send all 45B ADA in one transaction (if someone would own all ADA there is)?

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.


Where can I get the Bip39 file? I would like to leave a copy of the Bip39 words with a person of my trust. Where is the safest place I can download the Bip39 file?

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.


Will Cardano's transaction fees be expensive (similar to ETH gas) in the future? I found this cost formula:

As you can see, the larger the transaction, the more resources are needed to store and process it.
So, my question is: Will Cardano's transaction fees be expensive(similar to ETH gas) in the future?

My answer is no. And there are two reasons.

Cardano is a PoS protocol. Therefore, users don't pay for electricity cost. In a PoW system, miners need to solve computational questions to be able to produce blocks which consumes electricity. This price is covered by users when users make transactions.

Cardano will have more TPS compares to Ethereum currently which also contributes to a lower transaction fee.

However, on-chain solutions have limitations. Blockchains need to implement off-chain solutions to increase TPS and lower transaction to be able to make microtransactions. Cardano has given their solution which is called Ouroboros Hydra.


Where can I learn to make Cardano NFTs that have varying rarity levels when they are purchased for the first time? I’ve seen some really cool projects like cryptoknitties and crypties with rarity levels and they usually come in like 5-10k. I have some great ideas but I can’t find anywhere to learn how to do this on the internet or Cardano website. Are there any resources available to learn how to do Cardano NFTs like that?

You can use this tool to create native tokens or NFTs: https://cardano-native-token.com
This is the easiest userfriendly way at the moment.
It's required to have more technical skills if you want to make more complicate NFT setup.


Are there any API's I can integrate with to accept Cardano as a merchant? I run a small tourism startup and I'm looking for an API I can integrate with to accept Cardano on our website. Does anything like this exist? Sadly, neither Coinbase Commerce nor Bitpay are currently supporting Cardano.

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.


What's the point of new incoming addresses with the Daedelus wallet? Daedalus seems to create a new set of incoming addresses, is this epoch based, or a privacy measure?

While it's intended to be a privacy-enhancing measure, it's currently somewhat negated by the fact that any Cardano wallet that's currently registered for staking has every address easily linked to the staking address (e.g. see Addresses tab of https://adastat.net/accounts/7e8e16462417aaf4d82249228050eb66b16a143c0433b08de794675f). So you might want to create a separate wallet that's not involved in staking for any intermediate transactions where the new address re-use will actually have the desired effect (not sure if legacy Byron wallets are still create-able anywhere, they would also do the job!).


Are there web3.js-like in Cardano? With the Cardano's Alonzo Hard fork coming, the Cardano testnet will be coming in. I assumed that there is a frontend library for interacting with the Cardano testnet, however I couldn't find anywhere. I wonder if there are libraries that are being developed?
Regards,
Ivan

There isn't currently a Javascript library, but it looks like the Cardanoscan folks are building one for interfacing with the Cardano blockchain (link to article).
The current pioneer's testnet for writing smart contracts uses Plutus. You can read more about this here.


Could the d-factor still be changed, to revert to more centralized block production by IOG? Nothing is mentioned anywhere if, and according to which policy, IOG can move the d-“slider” in the other direction, to again start producing more centralized blocks whenever they deem this necessary. Probably a question only Charles or Duncan can answer.

Cardano has three different pillars of decentralization:
The first pillar: block production. Once d hit 0, this pillar was fully decentralized.
The second pillar: networking. It means how nodes find each other and pass on this information. Currently, this is a topology file and it will be replaced by P2P discovery.
The third pillar: governance. The way to vote on all protocol parameters (like d) and updates and access fundings of the treasury.
So to answer your question: yes, theoretically, it would currently be possible to increase the d-parameter again. But should IO do so, it would certainly be a disastrous signal.


How does the ERC20 converter actually work? Since Ethereum & Cardano are distinct networks, when the ERC20 converter moves tokens between them in either direction ensuring conservation of token (the process does not destroy or create tokens), what is actually happening? Is the ERC20 converter a centralized process that operates on both networks or something more decentralized and trustless? If it's not a centralized process, I would be very interested to know how conservation of tokens is maintained considering that the two networks do not directly interact with each other.

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.


How are unused/outdated smart contracts handled on Cardano? How will unused, outdated smart contracts be handled? Or say a developer makes a mistake in the contract and needs to redeploy it, what happens to that old contract? Would a lot of Unused contracts cause a lot problems for storage?

For one thing, the validator script associated with a smart contract is not stored on the blockchain; the blockchain only stores the hash just like for a lot of other things. When the code of the validator script changes, the script address also changes, but because the script is not stored on the blockchain, the cost of abandoning a smart contract is like that of abandoning a regular address.
So, there will be no blockchain storage problems with having a lot of unused smart contracts, no more than with having a lot of abandoned regular addresses, and the requirement that each UTXO contains at least a certain amount of ADA limits the number of addresses with non-zero balance.
To avoid losing assets, the developer should move the balance from the old script address to the new script address when he updates the validator script though that may not always be securely feasible without giving the developer/maintainer too much centralized power over the smart contract's operations.
However, someone may build an off-chain metadata service that allows registering validator scripts to facilitate lookups by hash and such a service may accumulate junk and get storage problems unless they address the issue.


Stake pool - Failed to start all required subscriptions Description
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. Interestingly the producer node just minted a block that I take that will be lost on network write sync up.
Setup

Relay node: 192.168.0.12
Producer node: 192.168.0.10
IP: 82.44.254.62
Adapools: see here
Pooltool: see here
Pool.vet: see here

Topology
a) Relay
  1 {
  2   "Producers": [
  3     {
  4       "addr": "192.168.0.10",
  5       "port": 6000,
  6       "valency": 1
  7     },
  8     {
  9       "addr": "relays-new.cardano-mainnet.iohk.io",
 10       "port": 3001,
 11       "valency": 50
 12     }
 13   ]
 14 }

b) Producer
  1 {
  2   "Producers": [
  3     {
  4       "addr": "192.168.0.12",
  5       "port": 6000,
  6       "valency": 1
  7     }
  8   ]
  9 }

Exceptions (might be related as well as might not):
a) Relay
20844 Apr 27 18:52:38 jolanta bash[677]: [jolanta:cardano.node.ChainDB:Notice:108] [2021-04-27 17:52:38.20 UTC] Chain extended, new tip: 1e774042b9adf5e4d4677dac54069ecce09926af382f5979e3db3200bfae31f2 at slot 2      7979667
20845 Apr 27 18:52:51 jolanta bash[677]: [jolanta:cardano.node.DnsSubscription:Error:2319] [2021-04-27 17:52:51.67 UTC] Domain: "relays-new.cardano-mainnet.iohk.io" Application Exception: 204.236.187.238:3001 Mu      xError MuxBearerClosed "<socket: 45> closed when reading data, waiting on next header True"
20846 Apr 27 18:52:51 jolanta bash[677]: [jolanta:cardano.node.ErrorPolicy:Warning:127] [2021-04-27 17:52:51.67 UTC] IP 204.236.187.238:3001 ErrorPolicySuspendPeer (Just (ApplicationExceptionTrace (MuxError MuxB      earerClosed "<socket: 45> closed when reading data, waiting on next header True"))) 20s 20s
20847 Apr 27 18:52:52 jolanta bash[677]: [jolanta:cardano.node.DnsSubscription:Notice:4453] [2021-04-27 17:52:52.72 UTC] Domain: "relays-new.cardano-mainnet.iohk.io" Connection Attempt Start, destination 3.9.116      .228:3001

Netstat
a) Relay
maciej@jolanta:~/cardano-node$ netstat -pant | grep 6000
(Not all processes could be identified, non-owned process info
 will not be shown, you would have to be root to see it all.)
tcp        0      0 192.168.0.12:6000       0.0.0.0:*               LISTEN      677/cardano-node
tcp        0      0 192.168.0.12:6000       192.168.0.10:45311      ESTABLISHED 677/cardano-node
tcp        0      0 192.168.0.12:37851      192.168.0.10:6000       ESTABLISHED 677/cardano-node

b) Producer
maciej@wladyslawa:~/cardano-node$ netstat -pant | grep 6000
(Not all processes could be identified, non-owned process info
 will not be shown, you would have to be root to see it all.)
tcp        0      0 192.168.0.10:6000       0.0.0.0:*               LISTEN      718/cardano-node
tcp        0      0 192.168.0.10:6000       192.168.0.12:37851      ESTABLISHED 718/cardano-node
tcp        0      0 192.168.0.10:45311      192.168.0.12:6000       ESTABLISHED 718/cardano-node

UPDATE:
Logs
Relay:
Download
Producer:
Download

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


How do I prevent text in Catalyst proposals and insights from losing formatting? Whenever I edit text in Catalyst proposals and Insights, new-lines are dropped, text that follows bullet points gets indented and previously established formatting is disturbed.
Is there a way to prevent this?  e.g. use a specific browser.

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.


How many receive addresses per wallet? We are curious how many receive addresses can possibly be generated for a given wallet?

While there's definitely some limit determined by the encryption scheme used to generate the public keys associated with the master private key, their is no practical limit that I'm aware of.
Apparently the most recent wallet addresses (Shelley era) are in BECH32 format, which support 2^160 number of addresses. So, practically unlimited.


Hardware requirments for running a stake pool? I want to run a stake pool for fun and learning purposes and not for profit. What are the minimum hardware requirement for that?
I have an old laptop with 2Gig RAM and 256Gig storage.

As per this documentation,
https://docs.cardano.org/en/latest/getting-started/stake-pool-operators/creating-a-stake-pool.html,
in terms of hardware, you should ensure you have the following:

8 GB of RAM

24 GB of hard disk space

a good network connection and about 1 GB of bandwidth per hour

a public IP4 address

Note that processor speed is not a significant factor for running a stake pool.


Haskell IDE INLINABLE error help Have you encountered this error? IDE complains that the validator is not INLINABLE, while it actually is:
Program error: GHC Core to PLC plugin: E043:Error: Reference to a name which is not a local, a builtin, or an external INLINABLE function: Variable GHC.Base..
            No unfolding
Context: Compiling expr: GHC.Base..
Context: Compiling expr: GHC.Base..
                           @ (Plutus.V1.Ledger.Contexts.ScriptContext -> GHC.Types.Bool)
Context: Compiling expr: GHC.Base..
                           @ (Plutus.V1.Ledger.Contexts.ScriptContext -> GHC.Types.Bool)
                           @ Ledger.Typed.Scripts.Validators.WrappedMonetaryPolicyType
Context: Compiling expr: GHC.Base..
                           @ (Plutus.V1.Ledger.Contexts.ScriptContext -> GHC.Types.Bool)
                           @ Ledger.Typed.Scripts.Validators.WrappedMonetaryPolicyType
                           @ Plutus.V1.Ledger.Value.TokenName
Context: Compiling expr: GHC.Base..
                           @ (Plutus.V1.Ledger.Contexts.ScriptContext -> GHC.Types.Bool)
                           @ Ledger.Typed.Scripts.Validators.WrappedMonetaryPolicyType
                           @ Plutus.V1.Ledger.Value.TokenName
                           Ledger.Typed.Scripts.Validators.wrapMonetaryPolicy
Context: Compiling expr: GHC.Base..
                           @ (Plutus.V1.Ledger.Contexts.ScriptContext -> GHC.Types.Bool)
                           @ Ledger.Typed.Scripts.Validators.WrappedMonetaryPolicyType
                           @ Plutus.V1.Ledger.Value.TokenName
                           Ledger.Typed.Scripts.Validators.wrapMonetaryPolicy
                           Plutus.Contracts.FungibleToken.validator
Context: Compiling expr at "main:Plutus.Contracts.FungibleToken:(19,6)-(19,69)"

Module I'm trying to use IDE in:
{-# LANGUAGE DataKinds       #-}
{-# LANGUAGE TemplateHaskell #-}

module Plutus.Contracts.FungibleToken where

import           Ledger.Typed.Scripts      (MonetaryPolicy)
import qualified Ledger.Typed.Scripts      as Scripts
import           Plutus.V1.Ledger.Contexts (ScriptContext)
import qualified Plutus.V1.Ledger.Scripts  as Scripts
import           Plutus.V1.Ledger.Value    (TokenName, Value)
import qualified PlutusTx

{-# INLINABLE validator #-}
validator :: TokenName -> ScriptContext -> Bool
validator _ _ = True

makeLiquidityPolicy :: TokenName -> MonetaryPolicy
makeLiquidityPolicy tokenName = Scripts.mkMonetaryPolicyScript $
  $$(PlutusTx.compile [|| Scripts.wrapMonetaryPolicy . validator ||])
    `PlutusTx.applyCode`
        PlutusTx.liftCode tokenName

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.


Referencing onchain contract as 3rd party In solidity and EVM, it is possible to reference external contracts by providing the address and interface to the contract:
  address ckAddress =  0x06012c8cf97BEaD5deAe237070F9587f8E7A266d;
  KittyInterface kittyContract = KittyInterface(ckAddress);

In Plutus, however, the onchain code are referenced with
    ledgerTx <- submitTxConstraints inst tx

where inst is the ScriptInstance of the validator code. Is there some example that shows how to reference a 3rd party smart contract with exposed API? Or is the original source code always necessary to reference the correct instance?

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.


NFT Royalties before smart contracts I want to receive royalties every time my NFT is sold. Since there is still no smart contract yet, is it pointless to mint my NFT right now?
Is it possible to add the royalty functionality after minting the NFT? Or must it be during the minting process?

If by NFT you mean a locked native token, it is not possible to add smart contact functionalities to it later, unless you somehow remint a new one under a smart contact and somehow burn the old NFT (which might not be possible as its policy is locked).