text:
Problem when starting a nix-shell in the plututs repo
I was doing the plutus pioneer program and ran into an error when starting a nix-shell at the top-level directory of the plutus-repository.
I ran into the same error on Ubuntu  20.04.2 LTS (GNU/Linux 4.4.0-19041-Microsoft x86_64)  and NixOS (20.09.4029.4a154d47623 (Nightingale) on VirtualBox).
I also did set up the IOHK binary caches on both systems.
I got the following error when running nix-shell:
error: build of '/nix/store/z6w41a6dv151g2q95v91yywid7s8mkn5-Agda-plan-to-nix-pkgs.drv' failed
(use '--show-trace' to show detailed location information)

The nix-shell --show-trace command shows the following error:
error: while evaluating the attribute 'nativeBuildInputs' of the derivation 'ghc-shell-for-packages' at /nix/store/przi4l85b1yd1irwss0qnhg1lsw2925k-haskell.nix-src/builder/shell-for.nix:115:5:
while evaluating 'chooseDevOutputs' at /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/lib/attrsets.nix:475:22, called from undefined position:
while evaluating 'mergeInputs' at /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/pkgs/build-support/mkshell/default.nix:14:17, called from /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/pkgs/build-support/mkshell/default.nix:32:23:
while evaluating anonymous function at /nix/store/przi4l85b1yd1irwss0qnhg1lsw2925k-haskell.nix-src/builder/shell-for.nix:57:20, called from undefined position:
while evaluating the attribute 'name' at /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/pkgs/build-support/trivial-builders.nix:7:7:
while evaluating 'sanitizeDerivationName' at /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/lib/strings.nix:746:28, called from /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/pkgs/build-support/trivial-builders.nix:7:14:
while evaluating 'pipe' at /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/lib/trivial.nix:61:15, called from /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/lib/strings.nix:746:36:
while evaluating 'reverseApply' at /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/lib/trivial.nix:62:27, called from /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/lib/trivial.nix:63:8:
while evaluating the attribute 'version' at /home/demo/plutus/nix/pkgs/default.nix:68:15:
while evaluating the attribute 'extraPackages.Agda' at /home/demo/plutus/nix/pkgs/haskell/extra.nix:98:31:
while evaluating the attribute 'hsPkgs' at /nix/store/przi4l85b1yd1irwss0qnhg1lsw2925k-haskell.nix-src/overlays/haskell.nix:546:15:
while evaluating the attribute 'hsPkgs' at /nix/store/przi4l85b1yd1irwss0qnhg1lsw2925k-haskell.nix-src/overlays/haskell.nix:526:43:
while evaluating anonymous function at /nix/store/przi4l85b1yd1irwss0qnhg1lsw2925k-haskell.nix-src/lib/import-and-filter-project.nix:5:1, called from /nix/store/przi4l85b1yd1irwss0qnhg1lsw2925k-haskell.nix-src/overlays/haskell.nix:504:27:
build of '/nix/store/z6w41a6dv151g2q95v91yywid7s8mkn5-Agda-plan-to-nix-pkgs.drv' failed

Does anyone have an idea how to fix this? I couldn't find anything online or in the cardano forum.
EDIT: running nix-shell --show-trace I have the additional error:
error: while evaluating the attribute 'buildInputs' of the derivation 'ghc-shell-for-packages' at /nix/store/cf4ksa58yibwkmx2z83y7qd9zwpyjwmy-haskell.nix-src/builder/shell-for.nix:117:5:
while evaluating 'chooseDevOutputs' at /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/lib/attrsets.nix:475:22, called from undefined position:
while evaluating 'mergeInputs' at /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/pkgs/build-support/mkshell/default.nix:14:17, called from /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/pkgs/build-support/mkshell/default.nix:31:17:
while evaluating anonymous function at /nix/store/cf4ksa58yibwkmx2z83y7qd9zwpyjwmy-haskell.nix-src/builder/shell-for.nix:61:20, called from undefined position:
while evaluating the attribute 'nativeBuildInputs' of the derivation 'plutus-metatheory-lib-plutus-metatheory-0.1.0.0' at /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/pkgs/stdenv/generic/make-derivation.nix:192:11:
while evaluating the derivation attribute 'name' at /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/pkgs/build-support/trivial-builders.nix:7:7:
while evaluating 'sanitizeDerivationName' at /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/lib/strings.nix:746:28, called from /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/pkgs/build-support/trivial-builders.nix:7:14:
while evaluating 'pipe' at /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/lib/trivial.nix:61:15, called from /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/lib/strings.nix:746:36:
while evaluating 'reverseApply' at /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/lib/trivial.nix:62:27, called from /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/lib/trivial.nix:63:8:
while evaluating the attribute 'version' at /cloud/cloud-lite/training/plutus-pioneer-program/plutus-other-repo/plutus/nix/pkgs/default.nix:67:15:
while evaluating the attribute 'extraPackages.Agda' at /cloud/cloud-lite/training/plutus-pioneer-program/plutus-other-repo/plutus/nix/pkgs/haskell/extra.nix:18:3:
while evaluating 'hackage-package' at /nix/store/cf4ksa58yibwkmx2z83y7qd9zwpyjwmy-haskell.nix-src/overlays/haskell.nix:456:11, called from /cloud/cloud-lite/training/plutus-pioneer-program/plutus-other-repo/plutus/nix/pkgs/haskell/extra.nix:18:10:
while evaluating the attribute 'hsPkgs.Agda' at /nix/store/cf4ksa58yibwkmx2z83y7qd9zwpyjwmy-haskell.nix-src/overlays/haskell.nix:536:15:
while evaluating the attribute 'hsPkgs' at /nix/store/cf4ksa58yibwkmx2z83y7qd9zwpyjwmy-haskell.nix-src/overlays/haskell.nix:516:43:
while evaluating 'mkCabalProjectPkgSet' at /nix/store/cf4ksa58yibwkmx2z83y7qd9zwpyjwmy-haskell.nix-src/overlays/haskell.nix:152:13, called from /nix/store/cf4ksa58yibwkmx2z83y7qd9zwpyjwmy-haskell.nix-src/overlays/haskell.nix:501:30:
while evaluating the attribute 'buildPackages.haskell-nix.compiler."${(((plan-pkgs).pkgs  hackage)).compiler.nix-name}".version' at /nix/store/qrbp0y6mfscqhfhzivnhc91hvby45nv7-nixpkgs-src/lib/attrsets.nix:344:7:
while evaluating anonymous function at /nix/store/cf4ksa58yibwkmx2z83y7qd9zwpyjwmy-haskell.nix-src/lib/import-and-filter-project.nix:5:1, called from /nix/store/cf4ksa58yibwkmx2z83y7qd9zwpyjwmy-haskell.nix-src/overlays/haskell.nix:503:31:
build of '/nix/store/42ml953fywhg2i2fi4mqkq64v4fy512d-Agda-plan-to-nix-pkgs.drv' failed

On what revision of the plutus repository were you seeing this error?

Latest release, i just cloned it yesterday.

Yes it looks like it's the same error,I'm still trying to fix it with no success so far.
Which discord community are you referring to ?

Dunno if the link will work for you, for me it's a IOHK discord channel: https://discord.com/channels/826816523368005654/826822689427554365 moreover I have opened a github issue for Haskell.Nix in case they can help find the problem which seems to occur in the nix derivation of this library: https://github.com/input-output-hk/haskell.nix/issues/1109

I have suggested this question as a dupplicate, because if you look at the entire log it contains the same error warning: hash mismatch in fixed-output derivation '/nix/store/7y3jr1jvzkj2146h7sivw0sfr2bhap3j-ghc-8.4.4-x86_64-deb8-linux.tar.xz  like in the question Hash MisMatch Error on Plutus and Nix https://cardano.stackexchange.com/questions/367/hash-mismatch-error-on-plutus-and-nix . It is much more focussed on the real issue according to me. I gave the same answer: setting up the IOHK binary cache for nix

This question is indeed a dupplicate of Hash MisMatch Error on Plutus and Nix
If you look more closer at the entire error log, there is a mismatch in the sha256 singature of the derivation of ghc:
hash mismatch in fixed-output derivation '/nix/store/7y3jr1jvzkj2146h7sivw0sfr2bhap3j-ghc-8.4.4-x86_64-deb8-linux.tar.xz
Same answer, same workaround: the problem disappears when using the IOHK bianry cache for nix.
And there's is indeed an "IMPORTANT" mention at the begining of plutus REAME file asking to do this.

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

Ubuntu and other Linuxes
Nix has a configuration in /etc/nix/nix.conf. So as to use the IOHK binary cache you have to modify this file:
In the documentation it is said
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


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

The question was about the development of the EVM compatibility with Cardano out of box - can you please reference some development on this side? Looking at the code https://github.com/input-output-hk/mantis-cardano it looks pretty dead.

The KEVM testnet has been down for more than a month, but it is back up.
I never heard about it being compatible out of the box, there are plans to have it as a side-chain in the future, but there is still a lot of work before that can happen and is probably not in the short-term future.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


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

Are you looking for the actual or theoretical TPS of the Cardano Network?

@gRebel not yet, I am new to Cardano :)

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

There's a chart here, published on April 14th, which claims it's about 30-40k per day (so roughly 1 per 2-3 seconds), but I don't know how accurate it is.

(Note that the last five data points (on the website, I've cropped them from the image above) are misplaced; they're March dates instead of April.)

Is there any way to verify the accuracy of this screenshot? Is there no link to the source of this info?

@EGMSSE there's a 'show source' link at the bottom right, but it costs $60 a month ...

You could find the average tps over an Epoch by looking at the transactions over an epoch through the official Cardano explorer [0]. Epoch 260 had 216117 transactions which equates to ~2 tps. This isn't the networks limit of course, there are many empty blocks and you can easily see blocks with > 15 transactions on the explorers homepage.
Saying this, I'd argue a far more interesting value is the bytes/sec because transactions can vary in size. You could find the current theoretical limit with max_size_of_block / min_size_of_tx. I don't remember these numbers off the top of my head though!
[0] https://explorer.cardano.org/en

You can also check out ADApools, lots of good statistics there

go  there https://cardanoscan.io
in search epoch bar search last epoch .
you can see Transactions  . this is total Transactions in this epoch . you can division on current slot number .

The realtime page at adatools shows a live count of transactions/hour. A hands-on way to get more detailed data is to run a cardano-node with Grafana monitoring, as described at docs.cardano.org

There's also the epoch statistics in adastat.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
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?

Why would you want to run your own vs. delegating? This is only advisable if you have millions of ADA or are going to start a stake pool business.

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


text:
I am looking for a practical example of a smart contract with three parties
I would like to know if the following scenario involving three parties could make sense in the context of a smart contract.
I am new to blockchain and smart contracts, I have come across some standard two party contracts and one-to-many like crowd funding but I could not find any mention of a three party contract along the following lines:
Let's say Alice and Bob share a boundary between their gardens and Bob is responsible for paying for a fence and Alice has some requirements.
So Bob cannot put up the fence unless Alice says the conditions are met.
Bob is also at the mercy of the weather and his workman,
and the workman is at the mercy of the weather and issues on other jobs.
So in one sense:
Bob has agreement (a) with the workman, John
and a separate agreement (b) with Alice.
However, there could be an interesting interdependency created by Alice's requirements.
She has the option of setting a requirement with a twenty four hours notice or no notice required.
However, since she wants a fence up as soon as possible, if she drops the the 24H notice requirement then John has a option to come at an earlier date if he is stalled on his other job.
With two separate contracts the 24 hour notice/ no notice option could accidentally be different.
I don't know if this is a good example, but I am trying to understand if a single smart contract is ever used in order to hold three parties into an agreement, or should interdependent agreements like this be split into multiple two party contracts?
Or can a parent contract hold two child contracts with an interdependency?
Thanks in advance
Brian

The mediator is a good example of a three party contract. Is there a white paper or explanation giving more detail of scenarios when it would be more effective or less effective. For example, are we talking about resolving non-smart-contract disputes via a mediator using a smart contract to manage the distribution of funds after a decision? Should a mediator have some qualifications, experience and reputation? Can a mediator be a group using voting to make majority verdicts?

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

The mediator is a good example of a three party contract.


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

Recommended videos

The philosophy of Cardano short version

The philosophy of Cardano longer version

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

How does bitcoin actually work, the best explanation


text:
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

Did you ever solve this problem?

Running into a similar problem with a very basic validator script. This GitHub issue seems to be related: https://github.com/input-output-hk/plutus/issues/3454

The way HLS is enabled without plugin errors is discussed here:

https://github.com/input-output-hk/plutus-starter/pull/23
https://github.com/input-output-hk/plutus-starter/pull/29
https://github.com/input-output-hk/plutus/issues/3454

Basically, you need to enable defer-plugin-errors flag.
You can do this with following command:
cabal configure -f defer-plugin-errors
Remember to turn it off when you actually need to check if validators are compiled properly. This resets configuration:
cabal configure

It works! Thank you

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.

That could have worked, but I tried and the error is still the same. The validator inside module Plutus.Contracts.FungibleToken did not use any functions from Prelude, so that's expectable.


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

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

If my understanding is right, this works only for sidechains. Please correct me if I'm wrong.

I'm not sure. Maybe someone else can confirm.

The choice of Haskell based Plutus was deliberate to create a "Formally verifiable Secure" smart contract.
A smart contract becomes useless once bugs are discovered in some layer every year. To be recognised as a dependable platform with a larger scope and mainstream adaptation Formal methods supported by math were a critical requirement.
Therefore, there is a school of thought that developers who can learn and write "Secure Contract" will be more valuable and dependable. However, for fun applications where security is not a major constraint wrapper are also being developed. As it can be appreciated I guess Plutus is being prioritised to bring in "Secure" Contract.

Project catalyst has a few guys building a Ouroborus Networking package for JavaScript.. it’s coming.
https://twitter.com/cardanomint/status/1397223641222369285?s=21

Theoretically, you could develop a new compiler that compiles from a different language into Plutus Core (see Plutus Tx: compiling Haskell into Plutus Core).
Additionally, you would need a different (not Haskell-based) client that could create transactions and publish them to the blockchain. But also a simple wrapper that is still based on Haskell but would wrap foreign Plutus Core code could also work.


text:
Best practice when building a private Cardano testnet?
I am using scripts provided by IOHK to help build a private testnet. I have been told (during discussions in the white/blue/purple testnet development) that best practice is to start the network in byron and move through the era's until Alonzo is reached. This is what IOHK seems to do when they launch a new testnet (from part of their new purple testnet announcement, "Please allow ten hours for the network to be ready to test against. This will mean we have made the network move through all the eras to Alonzo correctly".
I have tried to reach out to IOHK for an answer to this but have not received a response back yet - I understand that they are pretty busy right now so i figured I would ask here...
The reason I would like to know is because I am working with one of the IOHK partners and we are trying to create an in-house, automatic, private blockchain tool - similiar to Ganache for Ethereum. We CAN currently start a private network in Alonzo which would make this task relatively simple but with the current best practice to start from Byron and progress to Alonzo, I would like to know what exactly we are giving up in functionality (or anything else) by directly starting in Alonzo instead?

Please clarify your specific problem or provide additional details to highlight exactly what you need. As it's currently written, it's hard to tell exactly what you're asking.

Simply, What functionality do you loose by starting a private network in the Alonzo era vs starting a private network in the Byron era and updating to Alonzo through update proposals?

I received a message from Samuel Leathers about this issue. I am re-posting his response but if anyone would like to add additional information, please feel free to expand on the idiosyncrasies that Sam is talking about:

2 things:
db-sync doesn't work with the shortcut fork all eras in epoch 0 (yet, there's an
open PR adding this finally)
The protocol version will still be 2 if you fork everything at once.
This is something we've reported to the devs to get fixed later, but
essentially, even if you do have the config fork all eras (in 0 or sequentially)
you still need to submit update proposals every epoch to get it updated to 5.
There are some weird idiosyncrasies that can happen if era is Alonzo but
protocol version is less than 5.


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

Theoretically, you could mint some NFTs now and lock them later in a smart contract that tracks which wallet has the rights to which NFTs.This is a classical account-based model implemented on a smart contract.
To lock the NFTs in a contract you have to be able to access them. So if you distribute them now, you have to convince the receivers to hand them back to you or to lock them in the contract by themselves. Otherwise, they could bypass your fees.
Maybe you can also just declare that all NFTs not locked in the contract after a specific date will lose their value. But it depends on your implementation if that is possible and you will probably lose reputation.

It’s not pointless to mint Native Assets(a.k.a. NFTs) even in the absence of smart contract backed royalties. I think keeping the asset policy unlocked for the future should be able to let you attribute future traits/capabilities to existing Native Assets even without having to have holders to return them for burning/reminting. Like an OTA update. This all theory of course. Hopefully the other brilliant developers will be able to figure out how.

Currently there is a CIP open that proposes how the royalties should be done on Cardano.


text:
What is the exact implementation of proof of stake in Cardano?
I have a rough idea of what proof of stake does. However, I'd like the exact implementation (not the code) but a high-level description with hopefully some actual number, e.g. how many pools verify the transactions for each block, how is the consensus achieved, etc. If anyone knows or can send a resource with that information, it would be appreciated.

You might want start by checking out the documentation library. Go here and search on page for "Ouroboros".


text:
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

Thanks for your response. It makes sense. One final question, how does the pledge affect the reward per block. E.g. all other things being equal, how does the block reward changes, if I pledge X ADA as compared to if I pledge 10*X ADA?

@Cryptovios pledge has an influence on the total rewards a pool is set to receive. In the above scenario, more pledge ADA will increase 1000 ADA to be 1010 ADA JUST an example. How much influence the pledge has is based on the protocol param a0. There are more details about the formula but I think it is a topic out of the scope of this question.

what APY would someone typically get who decides to run the whole pool themselves and just stake the full 64mm?

Is the fixed cost of 340 Ada for each block mined during an epoch, or lump sum at the end of the epoch subtracted once from the total rewards?


text:
What happens to fees when Cardano's chain reaches 1509GB data?
We can see the current Ethereum size is greater than 1509GB, and Ethereum's gas fee is too expensive. My question is what happens to fees when Cardano's chain reaches 1509GB data?

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

Based on Official Cardano website: Fee is based on "How much does it cost to run a full node?" => you means storage does not affect when running a full node?

Oh, right, but that is different. You are talking about the fixed fee that a stake pool received upon a block creation, which is not set to 340 ADA per epoch. This is related to staking rewards, not the transactions.

The transaction fee for Ethereum does not rely on the size of the blockchain, but how many transactions there are in a given time. Like I understand it Ethereum uses an auction model for transaction fees, meaning that more transactions (more demand) equals higher fees.
Cardano's fees are constant and do not rely on either the size of the blockchain or the transaction demand, but can be calculated like this:
Transaction fees (in ADA) =  0.155381 + 0.000043946 x [size of transaction, in bytes]
The average transaction fees is currently at ~0.22 ADA per transaction (more details here).

@StephaneRolland deleted, thank you!

@RongNguyen you're welcome :-)


text:
What is the Cardano Stiftung?
I have seen this mentioned a few times and have no idea what it is.
I get the impression that it is referring to the combination of the Cardano Foundation, IO Global and Emurgo.

These are synonyms. Stiftung is German for foundation. The Cardano Foundation is located in Zug, Switzerland - a German-speaking part of the country.
The twitter handle of the (now verified) Cardano Foundation is CardanoStiftung: https://twitter.com/CardanoStiftung.


text:
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?

You can't share the underlying data folder so will need a copy for each node. However, you can pre-seed them by syncing one, then duplicating its db folder into the others, so that when they start up they do not need to re-sync and validate the entire chain.
If you can get a copy of the db folder form a trusted source, you could potentially speed up the very first sync too (since downloading a compressed version of that will be much faster than syncing and validating the whole chain).

This answer is correct.
Furthermore, first sync the node to the network, then stop the node and copy the db to the BP, before starting the BP.
As in your (and most cases), the BP is on the same network as one node, and the BP only ever gets data from it's own nodes, the transfer of data from the node to the BP during normal operation is local, and therefore quick, and possibly free, depending on where it's hosted.

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.

This does not answer the question asked.

Can you please elaborate? The answer is that it is not possible and then I expand on why it is not possible.

You have answered as if the question was asked about two nodes. The question relates to a node and a BP. The BP only ever sees it's own nodes, so saying that they have may have different views of the blockchain is incorrect, as the BP will have the view provided by the node.

I disagree, it is not incorrect. It is possible and actually happens quite often, that the block producer is on a different fork than a specific relay, because in fact, they are two different blockchain nodes. In a multi relay setup, you often have differently forked chains coming from one relay (and not others) to the block producer and it takes time until these are resolved. Please note, by "view" I do not mean what the node sees as in network topology, but what the node sees as the blockchain (series of blocks and transactions inside these blocks)

You have misunderstood the question. The question relates to a node and it's BP.

Can you please elaborate on your comment to point out the misunderstanding? The question is about a staking pool (block producer) and its relay. Both which are block chain nodes.

You stated "... as both nodes are two different blockchain nodes and might have different views of the network ...".
This is incorrect. Why? The BP is only ever connected to it's relays and nothing else, ever. When you have one relay, the BP view of the network is the view of it's relay.

When a new block reaches a relay and within a very short period of time another for the same slot, the relay might be on a fork for a short time that is never seen by the BP ever. This happens often.

It's impossible to share the same state directory. But if your concern is primarily disk space, you can use filesystem deduplication. For example I have a dedicated zfs volume with dedup setup I use to limit disk usage for multiple nodes ran on same machine for test networks. I wouldn't recommend doing this on mainnet though as running a bunch of nodes on the same host defeats the purpose.

Thanks for the info.


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

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


text:
Is Yoroi secure as a primary wallet?
I received an IOHK support ticket response this week that recommended I install the Yoroi wallet:

The Daedalus wallet is a full-node wallet, so it can take time to
install and can be difficult to use depending on your machine and your
network connection. We have a light wallet that is a chrome extension,
which is easy to install and use. You can find more info at
https://yoroi-wallet.com/#/.

This statement appears to be in direct conflict with their article on Cybersecurity Guidelines for Cardano Users. Of course, that article is about Daedalus, but for the end user, it seems confusing. Honestly, I was a bit baffled by the contradiction. I thought Yoroi was primarily an iOS app. Even in Apple's locked down ecosystem, I was having doubts about installing and using it. But as a browser extension? How is that safe enough for them to recommend?

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

I'm not too sure about this. iOS has a ton of control around it, whereas the user can install any browser extension and the browser is exposed to much more than a standard app.
All code in the iOS app/browser extension being equal. iOS apps are probably closest to a hardware wallet you can get (assuming the device is not rooted).
I'm not an iOS or Apple user myself.

My argument was mostly around the fact, that the browser extension is sandboxed. If he is using the Yoroi official website, the user should be fine, which cannot be said about the official iOS app store, that has recently officially approved and listed a scam Trezor application and someone lost $1M+ of BTC to it. https://coingeek.com/man-loses-btc-worth-1m-to-fake-trezor-app/

You make interesting points about browser extension sandboxing. Thanks for the useful info. It still seems there is a contradiction between the cybersecurity guidelines page for Cardano (and general safety recommendations I see around the web), and the recommendation to install a wallet via a browser extension.

@a-fro oh, actually that page is only about Daedalus, which is a specific wallet software and is a full-node wallet. On the other hand, Yoroi is a light-weight wallet.

@MarekMahut-StakeNuts I understand that the page is about Daedalus, but that's part of what's confusing. It's called "Cybersecurity Guidelines for Cardano Users", is written by IOHK, only discusses Daedalus, and recommends "If possible, have a dedicated machine for your cryptocurrency activities...Ideally, you won’t use that machine to surf the web, read emails, download software, etc." If I'm not a security expert, but trying to understand how to be safe with my Ada, this page and its advice confuses me in relationship to the support recommendation to install Yoroi in a browser.

actually, iOS apps are sandboxed too https://support.apple.com/en-gb/guide/security/sec15bfe098e/web#:~:text=All%20third%2Dparty%20apps%20are,making%20changes%20to%20the%20device.&text=Most%20iOS%20and%20iPadOS%20system,is%20mounted%20as%20read%2Donly.

Keep in mind that in the future IOG is planning to have lightweight version of Daedalus. For now Yoroi is very convinient and in terms of security is in the same level as Daedalus.
In fact Charles Hoskinson discussed that is debatable if they did a mistake by going in the current direction with Daedalus instead of implementing mobile lightweight solution as Yoroi.
IOG is planning to have not only browser and lighweight desktop client but also Daedalus mobile version for Android and iOS.
For many of my friends is very hard to use the current version of Daedalus and from usability point of view Yoroi is the only option.


text:
Will Quantum Computing Make Mining More Efficient Then Staking?
We all hear about cracking codes with quantum computing and who encryption standard will have to change to protect blockchains, but what about quantum mining?
Will mining on quantum computers make the energy consumption of protocols like Bitcoin lessen? If so then to what extent? Will it stop being an advantage Cardano has over Bitcoin or not?

No, PoW mining is still far more energy intensive than PoS.
PoW is always an arms race. If someone came up with a new more efficient BTC mining ASIC (completely ignoring the quantum computing part of the question) that was widely available, the same amount of energy would be used by the BTC network because that is the amount of energy available. The BTC network hash rate would however increase.

Proof of Work is built to be inefficient, in the sense that the protocol increases the "difficulty"  of mining if technology get's better. Its security properties depend on it being difficult to mine.
If it were the case that quantum computing made mining much more efficient, than either Bitcoin would have to change the way "mining" works (making it quantum-resistant) or it would become unsafe and lose its value.


text:
How does Ouroboros disincentivize bad behavior?
How does Ouroboros disincentivize bad behavior? For example, in ETH 2, poorly behaving nodes have their stake slashed. Does Ouroboros have a similar mechanism?

Here are three great videos on Ouroboros and Ouroboros Genesis that go into detail. They all give high-level dive into The Base Protocol and some of its upgrades.
Basically, they use game theory and math-based models on ensuring that honest SPOs flourish while dishonest ones have no incentive to be so.
When it comes to delegating on Cardano, A non-custodial form of delegation, ADA doesn't leave the delegator's wallet. They register a stake key with the network for ₳2 and the fee of the tx. Then they can pick any pool, usually a high performer to delegate.
This way no ADA is ever at risk of anything, even if the pool goes down. They can just delegate elsewhere without needing to reregister the staking key.
With that delegation system, Pools that are bad actors/performers can be abandoned and good pools can be chosen by ADA holders while never being at the mercy of stake pool operators.
This is why Education in the Cardano community is critical since informed delegators will pick the best pools as it's in their financial interest to do so.
As for ETH 2.0, Slashing isn't the only risk. Locking your ETH in for an indefinite period till the system is up is a risk.  If an admin of an ETH pool goes rouge or loses the private keys to the node, all ETH holders lose their coins.

How will a user be able to tell when a pool is misbehaving? I'd guess that the rewards for the delegators to that pool will lower which lowers the rewards of the users, is that right? If so, how does the system decide which pools are "bad" and thus should have their rewards lowered?

With a tool like https://pooltool.io/ A user would be looking out for performance more so behavior since the protocol accounts for the behavior of would-be attackers.
The less stake a pool has, the less they are likely to be selected to mint a block. So to be viable, a pool wants as much ADA as possible, and to attract it they need good fees and a pledge to the pool.

Pledge is an amount of ADA the SPO themselves decided on staking with the Pool and leaving it there so they also have skin in the game.
Pools with pledges are financially incentivized to maintain the pools uptime and its security, or they could lose their own ADA by losing their private keys. The Delegators are never at risk of this.
Pools that underperform just don't get picked to mint blocks at often or at all.

Great question! Ada is given as a reward to those nodes that dutifully complete their job as slot leaders.
Two epochs in advance, slot leaders are selected for a given epoch. The probability that a given stake pool will be selected is related to that pool's stake minus the difference between 1 and f, where f is a value determined by how good that node's behavior has been.
Every time a pool validates a transaction, it sends a verifiable random function (VRF) that takes as inputs its current state to the rest of the network. Each time this happens, the FVRF functionality is utilized. If a stake pool's node's VRF output is incorrect, the f parameter above is set to 1 for that round. Thus, if a node is adversarial, it will have no chance to participate as a slot leader and produce a block for the network. Failing to validate or "missing" blocks will have the same effect, and they will decreases the probability that a node will be selected to be the next slot leader. Thus, adversaries are unable to gain control over the network, and adversarial stake pools are punished because they will receive no rewards from staking.
Source: Ouroboros Praos

In Cardano, you cannot lose your stake. Instead, bad behavior is disincentivized by opportunity costs: if you misbehave (or if your delegated pool does), you will get lower rewards or none at all. It's better as it makes staking more secure from the viewpoint of the user, as the worst thing that could happen is that you get no reward.

How does the system "know" when a pool is misbehaving and thus lower it's rewards?

@PaymahnMaghadasian It depends how the SPO is misbehaving. For example, if it is just producing invalid blocks, those blocks are rejected as they are invalid, and thus the SPO gets no reward.


text:
Syntax error in script when generating policyid
On Windows I'm trying to mint some NFTs on Cardano testnet using this guide.
The problem is that when I'm trying to generate policyID I'm getting this error even though the JSON is valid:
cardano-cli transaction policyid --script-file policy.script >> policyID
Command failed: transaction policyid  Error: policy.script: Syntax error in script: Error in $: Failed reading: not a valid json value

Script is here:
{
  "scripts": [
    {
      "type": "before",
      "slot": 37102595
    },
    {
      "type": "sig",
      "keyHash": "5d4b345b91acf751d7d591f327c10c731024f25db6daed4cabdXXXXX"
    }
  ],
  "type": "all"
}

At first I thought it was some Windows distro bug, but after rebuilding 1.29 version from source on Ubuntu 20.04 LTS (ran over wsl 2) I get the same error.
Out of desperation I also tried removing all spaces like I read in some other answers to similar error when using cardano-cli, that didn't help.

Were you able to resolve it. if yes what was the issue

If you put a correct key hash it works.

Just in case this might be useful for you or for others Typhon Wallet Dapp Connector supports Minting tokens/NFTs using NativeScript using a simple method. ```js
const receivingAddress = "addr_test1qz2qzz8d4unvpkes7nt7tjkwx0sff3cfkrvl528mgkdzt5kmt68vuzvz4nzgs00x0shrgywvy674v6r2zcs8fxvvq27qqycj9a"; const decoded = typhonjs.utils.decodeBech32(receivingAddress);
const pubKeyHash = decoded.value.slice(2, 56 + 2); const nativeScript = { pubKeyHash: pubKeyHash,
};
const nativeScriptFactory = new typhonjs.NativeScriptFactory(nativeScript);
const policyId = nativeScriptFactory.policyId().toString("hex

The error message you are getting is basically telling you that the keyHash value specified (5d4b345b91acf751d7d591f327c10c731024f25db6daed4cabdXXXXX) is not valid.
If you replace that with a valid hash, it works. For example:
{
  "scripts": [
    {
      "type": "before",
      "slot": 37102595
    },
    {
      "type": "sig",
      "keyHash": "50de79c63d672319e20be59c620eb57ed1de8b7cc7fa489d8f22e353"
    }
  ],
  "type": "all"
}


text:
Cardano db sync sender and receiver address confusion
I am needing help with this. I queried the rows whose tx_id = 133903 from tx_out table from postgres.
select * from tx_out where tx_id = 133903;

and I got two rows having two different indices 0 and 1. The result is below in JSON format.
[
  {
    "id": 240155,
    "tx_id": 133903,
    "index": 0,
    "address": "DdzFFzCqrhskf5Bho1HFpjzFGcVG3avzBMBkP4DUHMJMuqaNmPrt5Cnf1GUxQ3gFxFrbZUHsrxgqUf3fkn5NxjHSDh67SfuKHGLcYYuV",
    "address_raw": "E'\\\\x82D818584283581C3490095835CC47B0D182A0DC054D49816D9782FA42D3D26EFF4F613EA101581E581C740E27451628BDD32329FC359C8FC1C1A48FE25B94908AB8ABB577A1001A7E3A51E8'",
    "payment_cred": null,
    "stake_address_id": null,
    "value": 2936699288244,
    "address_has_script": false,
    "data_hash": null
  },
  {
    "id": 240156,
    "tx_id": 133903,
    "index": 1,
    "address": "DdzFFzCqrht3JYLq1Cc9Y3EeyZvTwzwuu5QZCJqbmjFVMj23miQeSMESfJoSb4f1NNJL9ti1nJryGSB1VK7yFbzkRtcEjamaSvj6LP8k",
    "address_raw": "E'\\\\x82D818584283581CB3CC4806AB502B2EC4FFD82CDA50BF4E5465769B6BCB6C0692C6F797A101581E581CCA3E553C9C63C562EE05D443E8D3D451372D66B450379B9002540A9B001A88AF5021'",
    "payment_cred": null,
    "stake_address_id": null,
    "value": 100000000000,
    "address_has_script": false,
    "data_hash": null
  }
]

Correct me if I am wrong but the address field in the tx_out table basically is the receiver right? I want to get the sender's address. How do I find out the sender of this transaction? I am having some hard time figuring this out. Basically I want to create a table that contains the address of sender and receiver and amount for all the transaction ever recorded in the postgres table.

I am  not 100 % sure of this answer;
The input is stored in tx_in table and the corresponding inputs addresses can be found by
select * from tx_out where tx_id in ( select tx_in_id from tx_in where tx_out_id =133903);
you are getting the address which are inputs to the transaction.

Query:
select prev_tx_out.address sender
     , this_tx_out.address receiver
     , this_tx_out.value

  from tx this_tx

 inner join tx_out this_tx_out
    on this_tx_out.tx_id = this_tx.id

 inner join tx_in this_tx_in
    on this_tx_in.tx_in_id = this_tx.id

 inner join tx_out prev_tx_out
    on prev_tx_out.tx_id = this_tx_in.tx_out_id
   and prev_tx_out.index = this_tx_in.tx_out_index

 where this_tx.id = 133903
;

Result:
                                                  sender                                                  |                                                 receiver                                                 |     value
----------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------+---------------
 DdzFFzCqrhsycjyjN1UGhehYVs7ZcCfoUR8PNF7QaXgYtNcEci68gLuFrbioBTyvDPW6ztiEDYPZC3jXH9DqjEgXhzLLGUL5hdENMVF4 | DdzFFzCqrhskf5Bho1HFpjzFGcVG3avzBMBkP4DUHMJMuqaNmPrt5Cnf1GUxQ3gFxFrbZUHsrxgqUf3fkn5NxjHSDh67SfuKHGLcYYuV | 2936699288244
 DdzFFzCqrhsycjyjN1UGhehYVs7ZcCfoUR8PNF7QaXgYtNcEci68gLuFrbioBTyvDPW6ztiEDYPZC3jXH9DqjEgXhzLLGUL5hdENMVF4 | DdzFFzCqrht3JYLq1Cc9Y3EeyZvTwzwuu5QZCJqbmjFVMj23miQeSMESfJoSb4f1NNJL9ti1nJryGSB1VK7yFbzkRtcEjamaSvj6LP8k |  100000000000

Remember that a transaction always spends all the transaction input.
Unless the total (tx_out.value) + fee == tx_in.value there will be two tx_out entries, one for the recipient and the other is the change output that goes back to the sending wallet.

Using the code of @grim_i_am

for transaction 34369121, I have the following.
Am I right to understand that in this transaction, 1 sender send to multiple receiver with different amount? If so, why at the receiver, the receiver's address are duplicated?

For transaction id 34368652,

the sender and receiver are multiple. this is normal?
How can 2 sender can send at the same time? I am not quite understand.

Check the  code used by Koios for getting tx inputs and outputs here

a cardano transaction can have multiple inputs and multiple outputs. In the same way that the multiple outputs can go to different addresses, the multiple inputs can come from different addresses too. As long as the transaction is signed by all the private keys of all the input addresses, the transaction is valid.
Also, a single wallet can have multiple derived addresses. So what you are seeing as multiple senders might actually be the same sender. You can confirm this by checking whether the staking_address_id values of all of the sender addresses are the same.


text:
Compatible Plutonomy cabal.project for plutus-apps
I want to use Plutonomy , but it only (currently) works with two Plutus versions as per https://github.com/well-typed/plutonomy#flags.
How can I get a compatible cabal.project -- especially one that also works with plutus-apps ?


text:
Cardano GraphQL stuck Establish connection to cardano-node
I'm trying to run graphql following these instructions.
I do already have dbsync & cnode running for the preprod network, but I get this error:

{"name":"cardano-graphql","hostname":"DESKTOP-I38CEOE","pid":4332,"level":20,"msg":"Establishing connection to cardano-node: Attempt 3 of 101, retrying...","time":"2022-09-25T12:09:20.800Z","v":0}

Any idea what could be the issue? Maybe I need to edit/add some env var for the CNODE?

Well I don't know for sure what is going on and would require more information to practically help.
But I would investigate how graphQL is getting the node's params from.
Then check that those are correct, then make sure the host where graphQL is running from can connect to the node's host.
If both node and gQL run on the same host it is likely a parameter issue (port, socket).

thank you for your answer, actually yes i tried to look if there is anything regarding how it connect to the node ... but found nothing .. im new to this.

no worries, I'll try to find some time today to follow the instructions above, I'll revert back with my findings, although I'm not using cnode it will probably help me understand where gQL is getting the node's details from.
Actually could you print out your ${CNODE_HOME}/files/config.json file please?

hello this is the config file : https://justpaste.it/7nwn6


text:
Error with installing cardano-wallet on Ubuntu
I'm using Ubuntu 20.04 and trying to install cardano-wallet with this guide.
I tried a few times and every time I got this error:
ouroboros-consensus-byron        > Registering library for ouroboros-consensus-byron-0.1.0.0..
Progress 461/475

--  While building package plutus-tx-0.1.0.0 (scroll up to its section to see the error) using:
      /root/.stack/setup-exe-cache/x86_64-linux-tinfo6/Cabal-simple_mPHDZzAJ_3.2.1.0_ghc-8.10.7 --builddir=.stack-work/dist/x86_64-linux-tinfo6/Cabal-3.2.1.0 configure --with-ghc=/root/.stack/programs/x86_64-linux/ghc-tinfo6-8.10.7/bin/ghc-8.10.7 --with-ghc-pkg=/root/.stack/programs/x86_64-linux/ghc-tinfo6-8.10.7/bin/ghc-pkg-8.10.7 --user --package-db=clear --package-db=global --package-db=/root/.stack/snapshots/x86_64-linux-tinfo6/7d9a5133e73e69eafb80db950076b4ec70696c4137ef4c6e05d111373f4a3891/8.10.7/pkgdb --libdir=/root/.stack/snapshots/x86_64-linux-tinfo6/7d9a5133e73e69eafb80db950076b4ec70696c4137ef4c6e05d111373f4a3891/8.10.7/lib --bindir=/root/.stack/snapshots/x86_64-linux-tinfo6/7d9a5133e73e69eafb80db950076b4ec70696c4137ef4c6e05d111373f4a3891/8.10.7/bin --datadir=/root/.stack/snapshots/x86_64-linux-tinfo6/7d9a5133e73e69eafb80db950076b4ec70696c4137ef4c6e05d111373f4a3891/8.10.7/share --libexecdir=/root/.stack/snapshots/x86_64-linux-tinfo6/7d9a5133e73e69eafb80db950076b4ec70696c4137ef4c6e05d111373f4a3891/8.10.7/libexec --sysconfdir=/root/.stack/snapshots/x86_64-linux-tinfo6/7d9a5133e73e69eafb80db950076b4ec70696c4137ef4c6e05d111373f4a3891/8.10.7/etc --docdir=/root/.stack/snapshots/x86_64-linux-tinfo6/7d9a5133e73e69eafb80db950076b4ec70696c4137ef4c6e05d111373f4a3891/8.10.7/doc/plutus-tx-0.1.0.0 --htmldir=/root/.stack/snapshots/x86_64-linux-tinfo6/7d9a5133e73e69eafb80db950076b4ec70696c4137ef4c6e05d111373f4a3891/8.10.7/doc/plutus-tx-0.1.0.0 --haddockdir=/root/.stack/snapshots/x86_64-linux-tinfo6/7d9a5133e73e69eafb80db950076b4ec70696c4137ef4c6e05d111373f4a3891/8.10.7/doc/plutus-tx-0.1.0.0 --dependency=aeson=aeson-1.5.6.0-63wWHA3GHE0Isomy9OHMEw --dependency=base=base-4.14.3.0 --dependency=bytestring=bytestring-0.10.12.0 --dependency=containers=containers-0.6.4.1-D3v2li2ijuF82lK0hW01Nr --dependency=deepseq=deepseq-1.4.4.0 --dependency=filepath=filepath-1.4.2.1 --dependency=flat=flat-0.4.5-4g0HMvnhh6wwWCZXBuoYZ --dependency=ghc-prim=ghc-prim-0.6.1 --dependency=hashable=hashable-1.3.0.0-IsmIrOikObW5VAtLT8nz0o --dependency=lens=lens-4.19.2-jJTa5AeuDm5NTBTeWMq3U --dependency=memory=memory-0.15.0-12G9mJuoNajBX4ohDjVYqb --dependency=mtl=mtl-2.2.2 --dependency=plutus-core=plutus-core-0.1.0.0-HQxTtycJGU52DKsUbNhuCn --dependency=prettyprinter=prettyprinter-1.7.1-89YQ13YwDjX8F1jciVrjTL --dependency=serialise=serialise-0.2.4.0-DiNk09iYdO3InRp0kGWlZg --dependency=tagged=tagged-0.8.6.1-HAjNeIkiYpIE28bnkAmrHX --dependency=tasty=tasty-1.4.2.1-B5isyoZJH1FIanpsobqwTE --dependency=template-haskell=template-haskell-2.16.0.0 --dependency=text=text-1.2.4.0-8O4eYxmKONuI5wWkW4xxj2 --dependency=th-abstraction=th-abstraction-0.4.3.0-EPNdba1m5DICfgheXpc0BJ --dependency=th-compat=th-compat-0.1.3-5V8hDdHCkmaDnfC7yeUenV --exact-configuration --ghc-option=-fhide-source-paths
    Process exited with code: ExitFailure 1

How can I fix it?

Are there any more useful messages above what you have posted?

You might be on an old version of Cabal, I noticed 'Cabal-3.2.1.0' in your error message. cardano-node wants version 3.6.2.0, wallet might be similar.
Did you also build cardano-node as per the wallet guide suggestion? If so that will confirm that cabal etc is ok.
cardano-node setup link (if needed): https://developers.cardano.org/docs/get-started/installing-cardano-node/

@MC_Brisbane Thank you for replying. Sure I built cardano-node and have needed versions.
cardano-node 1.34.1 - linux-x86_64 - ghc-8.10,
git rev 73f9a746362695dc2cb63ba757fbcabb81733d23,
cabal-install version 3.6.2.0,
compiled using version 3.6.2.0 of the Cabal library

Scroll up a few lines from the error message to get more details relating to 'plutus-tx'. Also, are you running as the same user that built the cardano-node? Could be some shared objects. PlanB - if you're in a hurry you could grab the binary instead of building it.

Working only under root, here is the full error.

I was able to reproduce your error on my Ubuntu 20.04.4 LTS (with 8GB RAM, no other Cardano code was on this machine).
Initially it failed at a different spot 'Progress 445/475' and re-running the build ended up like your situation eg:
plutus-tx                      > Configuring plutus-tx-0.1.0.0...
plutus-tx                      > Cabal-simple_mPHDZzAJ_3.2.1.0_ghc-8.10.7: Encountered missing or private     [<--- NOTE]
plutus-tx                      > dependencies:
plutus-tx                      > plutus-core:{plutus-core, plutus-core-testlib} ==0.1.0.0
plutus-tx                      >
Progress 7/21

--  While building package plutus-tx-0.1.0.0 (scroll up to its section to see the error) using:
    ...
    Process exited with code: ExitFailure 1

Note the missing dependencies lines.
I decided to use the previous wallet version (not the latest), in case it was more stable ie v2022-01-18.
The below is what worked for me to get it to build ok:

Stop some other processes to free up RAM if you only have 8GB like me.

I installed libsodium, you probably won't need this step if you have built cardano-node successfully

Start the whole download/build process over again in a new directory but this time use the previous stable code release eg git checkout v2022-01-18

Run the build, it should complete eg stack build --test --no-run-tests

I don't have cardano-node on this machine so can not run the wallet as intended but cardano-wallet version looks ok:

cardano-wallet version
v2022-01-18 (git revision: a5085acbd2670c24251cf8d76a4e83c77a2679ba)

git checkout v2022-01-18 is really working for me. Great thanx!

Great, am pleased to hear it. I'm not sure of the actual root cause, but we might find that as other code in the repo gets updated over then next few days/weeks that it all comes right and plays together nicely again.


text:
How can I allow users to update a public array of data based on whether they own a token or not?
I want to construct public lists that can be altered by people who own a specific token.
Is there a way I can group data together into an array like structure and allow users to append to it?
I understand metadata will play a fundamental role here, and I guess it will have something to do with the wallet updating the arrays digital signature.

How large is this array going to be and what shall it contain ?

It will contain IPFS hashes of files, the size could vary but possibly up to 500 entries

What function does the array serve? Does it only serve information or do you want to use it with some logic?

purely as an immutable information log that can be queried using blockfrost for example

Do you want it to be an append only list?

The transaction size is limited. So your list cannot grow too large. But assuming you stay within these constraints, you can achieve what you want by (i) parametrising your validator with a type that contains the currency symbol of the needed token and then (ii) checking in your validator if the token with this currency symbol is in the inputs. Additionally you would check that the list of hashes (which you would store in the datum) is only appended and not altered.
With the Vasil hard fork in June, you can have another approach to (ii). You could add the UTxO that contains the token as a reference input and check in the validator that (a) the reference input contains the token and (b) that the transaction is signed by the holder of this reference UTxO.
Edit:
If you want a solution without smart contracts you could indeed use the metadata but it would also mean that the list update is controlled by a central party (which would be you). A possible design would be the following one:

The location of the list is the metadata of the most recent transaction containing a specific token that you own. Let's call this token the list-NFT.
The users that want to append the list make a transaction to your wallet address. This transaction contains in its metadata the entry to be appended. The transaction would also contain a specific token that proves that the user has the right to append the list.
You have a service running that regularly filters the payments to your wallet address, verifies the presence of the token, and makes a transaction containing the list-NFT and the appended list.

thank you for information on this, i appreciate it. I was thinking users could all add entries to the same metadata key and true entries could be found by querying the blockchain with some off chain logic to confirm the person owned the nft at that time. Smart contracts seem like a better option though.

Ok, I understand. I edited the answer.

I think there are two kinds of solutions. The first is the most cost efficient and is focused on offchain indexing of the database, anybody can do it but there is no logic onchain. The second one is where you use plutus (and especially version 2, hard fork will be 29 of june and plutus will be fully available 1 epoch later).
For the former you can just let holders of a token create metadata transaction that contain atleast x tokens y. Then with a DB-sync instance anyone can index the latest state of the database. You even can introduce some overriding rules.
The second solution could be to use the reference capabilities of plutus V2. With the upcoming hard fork referencing outputs will be possible. With this you could make a database sitting on an script address where each UTxO is an entry. You could use this database in the future if needed. To prevent false entries you could create a minting policy which created some validity token if x amount of token are present. The cool thing about this solution is that the data is pretty localized and the present state is well defined and easy to obtain.
Hope this helps and I would love to see you make one of these!


text:
Facing Issue while sending utxo from one address to another
I need your help regarding Demeter different Era's problem.
I'm running my Node and Workload on demeter.run in preproduction but while sending transaction from one address to another i'm having error like node is running on convay era and workload is running on babbage era. I'm attaching error below thank you:
abc@parallel-broccoli-kwr2o9-0:~/workspace/repo$ ./01-simple-send.sh
Command failed: transaction build  Error: Transactions can only be produced in the same era as the node. Requested era: Babbage, node era: Conway.
Error building transaction


text:
Why does my test of Plutus contract crash?
I tried to equip the EnglishAuction.hs contract from Plutus Pioneer Program week 01 with test routine designed according to what Lars presented in later lectures:
doTest :: IO()
doTest = runEmulatorTraceIO $ do
    let startParams = StartParams{spDeadline = 10, spMinBid = 5, spCurrency = "Token", spToken = myTokenName}
    h1 <- activateContractWallet (Wallet 1) endpoints
--    h2 <- activateContractWallet (Wallet 2) endpoints
    callEndpoint @"start" h1 startParams
    void $ Emulator.waitNSlots 1

Then, however, I get a strange error which is caused by a line calling activateContractWallet. The message is mysterious and to me it carries no information:
Prelude Week01.EnglishAuction> Week01.EnglishAuction.doTest
*** Exception: not a hexit: 'T'
CallStack (from HasCallStack):
  error, called at src/Data/Either/Extras.hs:6:34 in plutus-ledger-api-0.1.0.0-307e91a82e48dc52f16a2602ae259f767995000a894e765e9c2a3c51ae53abfc:Data.Either.Extras

The full source of my modifications is here: https://gist.github.com/emesik/82f185dad3ecec6ec811530db4c51ff1
edit: I see the error is caused by "Token" used as spCurrency. Haskell expects hexadecimal there, perhaps the ID of minting policy? How can I fix it?

Plutus is still in development. So while the Plutus Pioneer Program is taking place, things were expected to break. I think the first three weeks or so will not run with the updated Plutus Playground. There may be community contributions that modify the source to work with the current Plutus implementation.

Currency symbols can't be arbitrary byte strings, they must consist of hexadecimal digits. So you can't use Token, and the error message is complaining about the T. Use something like ff instead.


text:
How to obtain signature from the cborhex? If i have simple-tx.signed
{
    "type": "Witnessed Tx BabbageEra",
    "description": "Ledger Cddl Format",
    "cborHex": "84a3008182582088921ae2626e"
}

This is just an example

Is that the output from an actual file? The hex is not valid CBOR.

First off, when analyzing CBOR data, cbor.me is your friend. Paste in the CBOR hex string and let it show you the structure.
In the witness files that I've worked with, the structure is as follows:
82                           # array(2)
  00                         # unsigned(0)
  82                         # array(2)
    58 20                    # bytes(32)
      71...60                # <- This is the vkey bytes
    58 40                    # bytes(64)
      6C...0F                # <- This is the signature bytes


text:
Is "nothing at stake" still a problem?
I read somewhere that there is no risk of forks because ADA has a built in way of deciding who gets to propose the next block if multiple stakers get selected in 1 round:
The one who rolls the lowest number that satisfies the requirement gets to propose a block.
But if you control a lot of stake, couldn't it happen that you get selected twice? In that case you can first publish the first VRF, purchase a product in that block, then reveal your lower VRF and make a fork where you keep your funds (ie a double spend).
Anything that stops this?

Nothing at stake usually means, a block producer may produce multiple blocks simultaneously and either send those to different nodes, or keep some for later in order to perform a long-range attack.
Now in Ouroboros PoS the slot leaders are pre-compiled and determined by VRF mechanism. Each participating node can easily verify if the produced block was actually built by a valid slot leader.
Also in Cardano's PoS the node does not submit/broadcast his new block, but just announce his current block-height. The remote node then decides if he want/need to fetch this block or not (i.e. a pull mechanism instead of a broadcast/push mechanism)
Also micro forks based on multiple valid blocks for the same slot - which can even happen naturally without bad intentions, based on the random slot leader election - are quickly solved by always choosing the block with the lowest VRF dice result.

just noted I forgot to answer your last question:
I'm not sure what you exactly mean by "selected twice" because of the huge stake.
Every pool will have exactly one VRF dice result for every slot.
So I guess you mean a pool operator controlling two or more large pools, who may are elected for the exact same slot.
It effectively seems possible in very rare random cases: limited to who actually has multiple huge amounts of stake on his pools, and a non-enforceable point in time when these pools dice for the exact same slot.

There are 86400 slots per day and 432000 each 5-day lasting epoch.
Due to the saturation limit (total staked supply / k pools) it is almost impossible to attract  delegations going above the saturation point, especially for a long time (currently with k=500 and ~72% active stake it is ~65M ADA)

A fully saturated (large) pool will be elected for ~55 slots each epoch, out of the 432000
The probability that your second large pool is elected for the exact same slot is very low.
And in the case it will happen, the block including the double-spend TX will be quickly removed from chain, even before the first following confirmation/block. some degree of confirmed blocks on top is always recommended

"And in the case it will happen, the block including the double-spend TX will be quickly removed from chain, even before the first following confirmation/block."

This doesn't make sense to me. You cannot "remove" a block, all you can do is not build on it. If the double spend block was already confirmed and built upon, and the attacker only then (after some blocks built on the other block) releases the lower VRF, aren't the nodes bound by the rules to build on that new block instead?

sorry, with removed I meant "solving the micro-fork by discarding the higher VRF block, choosing the lower-VRF one, and then wait for and build on the next block."
a lower-VRF block released some blocks later does not kick the whole chain of already build blocks. lower-VRF decision only plays out when two concurrent blocks are available to become th new tip.

It's not.
The Ourobouros protocol takes care of "Nothing at Stake" using game theory with mathematically verified algorithms that Prof. Aggelos Kiayias explains by laying out the parts of Ouroboros.
This is part of why Staking on Cardano is the best, no lock-up, 100% liquid, and your ADA never leaves your wallet.  ETH 2.0 needs slashing to cover for this and to stake, you need to SEND your ETH to the node and hope it doesn't do something to get slashed, or worse, the node is compromised by a dishonest admin or poor security.
https://www.youtube.com/watch?v=ur1lttBXAGM
Ouroboros has multiple papers that explain each of the parts. When putting it together nothing tops it.
Just type in Ourobouros in the search for Library.
https://iohk.io/en/research/library/

What about https://github.com/input-output-hk/cardano-node/issues/1132? This seems to be a nothing at stake issue.


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

Exactly what I was looking for, thank you!

In your scenario, each pool will have the same chances of getting block and should average to the same amount over time. The pledge amount affects the rewards; however, it is currently only a small amount. The plan from IOG is the update this later in the year to have more of an effect.
Pledge can only be applied from wallets that are registered as pledge wallets in the pool's registration certificate on-chain. There is nothing that requires pledge to only be from a single wallet or owned by a specific person. However, for a wallet to be included, it must sign the pool registration transaction and therefore can only be done by consenting parties. Often pool operators partner with investors or other community members to increase the amount of pledge in a pool. This will be essential as the parameters change and pledge has a higher effect on earned rewards.

See https://docs.cardano.org/en/latest/explore-cardano/understanding-pledging-and-rewards.html for a more detailed description of the effect/purpose of pledge.
A pool can be configured to have multiple owners, providing all owner accounts are delegating to the pool the combined total of their balances counts towards the pledge amount. Obviously this comes with certain risks/responsibilities/trust, since if you add some people you're not very familiar with as owners and set the configured pledge level sufficiently high you're relying on other people to make sure none of their transactions push the overall active pledge total below the level configured in the pool certificate. If that were to occur (and currently there are some warnings on a few sites like pooltool.io but nothing in major wallets like Yoroi or Daedalus to alert you to the fact that you've just caused pledge to be dishonoured), if an epoch boundary snapshot is taken the pool will not be receiving any rewards at all a few epochs later while the block production will still continue as per normal (proportional to the total active pool stake).


text:
How can I make an item traceable on the Cardano blockchain?
We would like to be able to identify an item on the blockchain for traceability and assign specific transactions against it to maintain a chain of custody.
Can anyone lead me in the direction I need to research this type of application?
Many thanks

Can you please elaborate a bit more on what are you trying to achieve? Maybe provide an example.

We want to trace a number of phone devices based on the IMEI or some other fixed identifier on the device and then assign metadata to these devices like if any internal components were added during repair for example. We would also like to assign ownership to them so they can “belong” to an entity. Just wondering how something like this can be achieved

You could make an NFT for each phone. You can attach metadata about the phone when you mint the NFTs. Whoever has the wallet that owns the NFT owns the phone. How you enforce the state of the ownership expressed on the blockchain in the real world is another story. If you need to modify the metadata, you could mint a new token with new metadata and burn the old token.

Hi Joshua, thanks for your comment. I’m fairly new to this and I’m looking for do a proof of concept on this soon and this is an interesting way to do it. Ownership of the token is the area I’m interested in and how that is generally done.
I need to dig into the development on this so any pointers to docs etc would be interesting at this point.
Thank you for your input.

Note that on a blockchain everything is traceable by default, excepted when counter-measures are taken.

When I hear the word "traceability" with respect to Plutus, a StateMachine comes to mind.
With a StateMachine, one address is maintained all through the lifetime of one instance of the state machine.
Each State can contain an arbitrary amount/type of elements as state data; and you can make use of the transition function to perform operations in each state

Thanks. I hope to lean more about this soon

I think what you're driving at is a native app that can be installed on the device. Internally it would create its own, private "wallet" (which really is nothing more than a private key). The app itself would present a UI where you can record maintenance tickets. "Saving" a ticket would be a Cardano blockchain transaction, with metadata, and signed with the private key.
There could also be a management app that holds the private-key-device pairs and additionally could work with device maintenance history.
One of the more difficult problems is securely managing the keys. If you loose a key then it's the end of the road for its transaction thread. If you leak a key then misdeeds could ensue.

Yea, that's exactly what I think I need to do but not hold the details on the device itself. And yes, the holding of the wallet and the private keys would be the issue here.
Is there a way to look at this by using a digital identity of some sort that would be tied to the transactions on the blockchain as repairs etc are done. But would that be a single wallet or do I need a separate wallet for each device?
I've signed up for the Emurgo developer course in August so hopefully I'll be able to convey my thoughts more clearly then.

Basically, I need a controlling actor to have the devices all tied together via transactions and for those transactions to be details about changes to the device. Would need to give control to other actors to query these devices on demand but without giving access to all the devices.

Anyone can query the blockchain at any time; it's public record. You don't need anything particularly special to simply following the chain of transactions. Perhaps what you're also getting at is you want to encrypt the attached metadata; the onus of which is upon your implementation.


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

I’m voting to close this question because the questions about the future of Cardano can't be effectively addressed on this site and would be better addressed directly to the Cardano Team on their forum. This site is not operated by the Cardano organization.

I am developing a conflict resolution platform on Cardano right now.

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


text:
Are there any negative effects of having too many stake pools run by central exchanges?
I was browsing through the adapools.org groups section to see how decentralized the stake pools were and I noticed that a lot of the central exchanges have a ton of ADA staked and lot of stake pools.

Are there any concerns to the network if central exchanges like Binance, etoro, etc gain more stake/create more stake pools that would affect the overall security of the network? Anything from a governance perspective where they would have more voting power for changes to the network in the future?

TL;DR: Centralization in the network is definitely a concern, but I don't think these numbers are scary.
Of course, the goal with staking pools is that they'll decentralize the network and encourage many stake pool adopters. Actually, Cardano has a formula used to determine block rewards and you'll notice that it reduces rewarding blocks to stake pool operators (SPOs) drastically after a critical value, determined by the number of ADA that will saturate a pool (currently that's ~63.6M ADA). So, there's not a lot of benefit for wallets/users to delegate their stake to a node which is over-saturated since the block rewards will have to be divided among a greater number of people.
However, the stake pool operators have almost no control in the governance/control of the protocol and are only responsible for providing trust/decentralization to the network.
Theoretically, if any single miner controls >51% stake then the security of the blockchain is lost. Practically, though, analysis has determined that with >50% probability a one-block attack can succeed with only 35% control of the network (see page 11). So, centralization is definitely a concern.
Now, if you treat all organizations as "independent stake pool operators" and don't denominate based on corporate structure/private ownership then you'll notice that the largest stake is Binance with 12.36%. I've read the details regarding the provenance regarding that chart, I'm not sure how accurate it is. To be sure, there's some uncertainty in these numbers.
However, my guess is that you'll see this distribution swing over 12-month periods as people seek higher returns from smaller SPOs and move funds to/from different exchanges who compete on rates.

"So, there's not a lot of benefit for wallets/users to delegate their stake to a node which is over-saturated since the block rewards will have to be divided among a greater number of people.", which is why Binance run multiple (64+) pools, each at the "optimal" (100%) saturation, so they aren't "penalized" by that network formula.

Yeah, and if these nodes all work in concern to achieve some end for Binance then it poses a threat to decentralization given sufficient stake across all pools. One solution is for delegators to select pools from a variety of different SPOs to ensure decentralization. This isn't too hard, since most SPOs have pretty strong branding/online presence.


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

You're right. You can exclude just the big chain subdirectory.
For mac users unfamiliar with the procedure: open System Preferences, click Spotlight, Privacy tab, +, browse to and select the  ~/Library/Application Support/Daedalus Mainnet/chain directory, click Choose.
This will exclude just the downloaded blockchain data from Spotlight search and Time Machine backups. (If you run other versions of Daedalus, like Daedalus Flight, exclude their chain directory too.) This will improve your system's performance and reduce space usage on your backup drive. If you have to restore from such a backup, Daedalus will re-download that chain data, which takes a loong time, but is automatic.
Related: it might be a good idea to make sure all your Time Machine backups are encrypted (requiring a password to restore from), to reduce the risk of an unauthorized person restoring your wallets.
If you can't do that, then excluding all of the Daedalus directory from backups, and relying only on your wallet recovery phrases to restore wallets, might indeed be best. In this case Daedalus settings, wallet names, spending passwords would not be backed up, but you can recreate those manually. (Unless you have a lot of wallet names, in which case it might be worth writing those down somewhere. You might be tempted to write down their balances as well; think twice, that information is more sensitive.)

The only thing required to restore wallets is the recovery phrase.
Therefore it is safe and efficient to exclude all Daedalus directories from time-machine if you have your recovery phrase stored safely elsewhere.
It also means that you can be less concerned with any changes to the disk structure and usage that may cause your time-machine backups to experience similar problems in future.

The OP asks about time machine backups, not recovery seed backups (which it is assumed are already being done). The question is how to achieve an effective time machine backup. Or perhaps the argument here is that it is safest not to create a backup of wallets at all? (= of daedalus at all). And safest to rely only on the seed? If so, more articulation of this position would help.


text:
How does Cardano protect against DoS attacks against stake pools?
I was reading about Algorand’s core technology, and in their section on delegated proof of stake, they argue that DoS attacks are a key weakness of this, and hence Cardano‘s, model.
I was wondering what is Cardano‘s approach to address that challenge.
A related question, also comparison to Algorand; Algorand trumpets that the slot leader (in Cardano terms) picks itself via a VRF. Who picks the slot leader in Ouroboros?

I think you should consider whether this post should be edited to be more specific (detail the attack referred to) or more general (remove references to Algorand) and the title updated accordingly.  The [help] guidelines for quoting external sources should also be followed.

There are around 3000 pools in Cardano network(they call them delegates in that link what you shared). I would expect at least 2 relays per pool, some pools have even more and I doubt that any pool run with just one relay. To take down whole network you will need to DoS(by the way currently nobody use DoS, but mostly DDoS, because DoS is attack from one location and it is ineffective, because you can just block that IP/location with FW and etc) 6000 servers in different locations and different hosting like AWS, OVH and etc. This will be defiantly not an easy task and not cheap, I can assure you. Additionally most hosting like AWS, OVH and etc has quite sophisticated anti-DDOS mechanism:
https://www.ovh.com/world/anti-ddos/
https://aws.amazon.com/shield/?whats-new-cards.sort-by=item.additionalFields.postDateTime&whats-new-cards.sort-order=desc
And if your pool is using other hosting it probably has some similar mechanism to prevent this.
Additionally if your pool will become target of such attacks, you can try to use hidden relays, just allow well known peers to connect to your relays and etc.
To summarize I would like to add that any service connected to internet can be target for DDoS and in theory can be taken down, even bitcoin network, but I personally think this is definitely not an issue for Cardano and in most cases if you follow best practices for system administrating, you should mitigate most of the risks.
Additionally I strongly disagree that you can easily and cheap DoS 1000 people[probably he meant servers/devices, people do not have yet IP connection, I'm still waiting for neuralink :)]

There are plenty of pools with 1 relay node.

Hi, not sure how that affects my answer... There are more then 6k known relays(and much more hidden) - https://adapools.org/relays. So to take down 6000 single relays or 3000 with double relays, seems for me quite a similar task... In any case, thank you for your comment.

While the above answers are both correct, they focus on the practical of how an SPO protects themselves from a DoS and the large number of nodes that would need to be attacked to be successful. The real key is the leadership schedule isn't public. An attacker cannot know when a pool will make a block until that block producer has forged and sent the block on to a relay the attacker is monitoring. At this point, it's too late to DoS the node. There's a bunch of really cool cryptography that if you want to dig into, IOG (formerly IOHK) has written many papers on, but the key point is you need to control the VRF secret key to know a block producers leadership schedule. As long as the operator doesn't share that schedule, they can't be targeted when it's their time to make a block.

Commentary on other answers is a bad idea.  They may be edited in future and their position is dependent on the number of votes they get.  Better to focus on answering the question to the best of your ability.  This comment will need to be deleted if the answer is edited appropriately.

It will take a lot more than 1 system (DoS) to take down Cardano!
But we're also protected well from DDoS attacks, here are a few reasons why:

In terms of the network, the a parameter "collateral" in the transaction fee structure helps prevent someone from flooding the network with useless transactions that can cause congestion etc. They must send along some fixed ADA so that makes a DDoS attack this way very expensive.
Stake pools don't expose their BP (block producer) node to the open Internet. They interface through Relay nodes so identifying and attacking the BP is difficult.
Stake pools often have >1 Relays and to successfully stop block production you would need to attack all Relays registered to that pool. Not to mention private Relays that are not registered for peer discovery.
Stake pool operators can take additional DDoS protection measures. Some include: stricter firewall configurations, private subnets, VPN, ets
The attacker can't know who will be the next pool to produce a block. This is due to the VRF (Verifiable Random Function). It's a really interesting concept, definitely consider a read.

To add to this (and answer OPs question in latest edit):
Basically, the SPO (or owner of the VRF private key) is the only person who can determine the random slot number generated by the VRF and therefore only they know when a block is expected.

This is just a strategy I've been using, feel free to poke holes in it.

Keep your block producer on a private subnet (it does not need to be on the public IP space).
Give it a relay that is not advertised.

In the event that an attacker decides to slow your pool down, the BP still has the unadvertised relay to propagate in a timely manner.


text:
Staking native assets (to stake pools)?
Is there support built in to Cardano for stake pools to receive staking of native assets?
For example, the Meld Protocol plans to include staking of Meld tokens.
Are they likely to / able to use (their own?) Cardano native stake pool(s) to achieve this?
Note that in Eth/Bsc, when we talk about staking, it means a transaction in which you loose custody of your assets because they are transferred to another wallet, the wallet of the smart contract.  Cardano is clearly different because staking (at least, of Ada) does not need or require this to happen.
This seems a pretty significant difference - hence, does this difference also extend to native assets and future dapp designs, and to what extent is this clear at this point?
Will stake pools take on further functionality down the road?
(I read  that hydra means a subset of stake pools will handle a channel, as a layer 2/ lightning style thing, this being a different additional role, down the road).
Of course, with Plutus, you can undoubtedly implement a staking mechanism for native assets, but I wondered whether it has been planned that the already existing stake pools can take on an additional role like this or any other.

I suppose the raison d'etre for what we currently call stake pools is (entirely) to provide the consensus layer.
Whereas, the same word, "staking", is also used in defi, when the goal is other things, completely unrelated to achieving consensus (e.g., a project wants to provide rewards for locking up tokens to decrease volatility in early stages of a project).
There seems to be a terminology challenge here - in PoW chains, the  double meaning doesn't arise. So, how are we going to handle this?
The term SPO is clearly established, so...  can't think of a good term right now...!

You are definitely right. As a developer lot's of people ask me about staking native tokens. They get confused with staking ada (cardano stake pool), providing liquidity (like to a dex), or just simply a smart contract to vest a native token.
I still don't think native tokens should be added to stake pools at the consensus layer. I think staking through smart contracts is the best possible route and the native token creators can figure out how rewards should be generated and rewards can even be other tokens or ada.