text:
Why is there a minimum amount of ADA required to vote for Project Catalyst proposals?
Voting on Project Catalyst proposals currently requires a wallet with 500 ADA or more.
It has been stated in Catalyst Town hall meetings that it is unlikely to be lowered significantly below that figure.
What are the barriers to lowering it further?
At what point does the cost of registering to vote exceed the voting rewards?

As Dor Garbash mentioned there are several reasons:

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


text:
Burning tokens after the 'before' time slot?
For a minting policy that specifies a 'before' slot requirement, it is impossible to mint new tokens after the specified time slot. Is it also impossible to burn existing tokens after the specified time slot?

Not right now, but IOG is working for a way to burn these, so for now, keep them around!

source: Stack Exchange

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

sort: votes


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

Under what circumstances and for what purpose do you wish to burn tokens?

@gRebel As mentioned in the last paragraph, the specific situation that motivated the question is that I'm trying to burn tokens after the 'before' slot of the minting policy has passed.

That's what you want to do.  I am interested in why.

As long as you do not burn a token, it is not clear that the token can still be owned by someone. Burning is final and undebatable. Burning also has the advantage of garbage collection for the information that nodes have to remember to process future transactions.

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

There is no such thing as a "private key for the tokens". The only thing that matters is the policy.

@LarsBrünjes I think he meant the private key for the verification key associated with keyHash used in the policy, so if you don't have that private key, you can neither mint nor burn tokens.

That is correct Joshua, edited the answer for clarity.

Yes, but the point is: The policy does not need to require a key. You can have a policy that only has a deadline, for example.

@LarsBrünjes, is it still not possible to destroy tokens locked by time slot ?
Eager to know more, i want to 'unmint' a minted token for which the time slot has passed ...

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


text:
How to emulate a multi-sig transaction?
I'm working on a Plutus contract that requires multiple signatures to unlock. To do so, I've been referencing the MultiSig.hs sample contract. Now, I'm looking to create traces for testing purposes, however, these tests are commented out in Spec.hs with the comment "disable temporarily, because we need to adopt the signing API," but I'm not really sure what this means.
Is it currently possible to sign a transaction with multiple Wallets or PubKeyHash's? If so, how?

People complain about banks, but I can open up a joint account at a bank. I can't do that with any Cardano wallet. I'm glad you're working on this. If you receive any responses to your question, I'll be interested in seeing them. Have you put your idea(s) out on Catalyst?

Hello Richard, welcome to this community. While your contribution is valued, it might be more suitable as a comment and not an answer.

Hello Richard, I am in agreement with Matthias and will do the conversion.  Welcome aboard.

These would be witnesses on the transaction itself. The script states I need these hashes signed on the transaction and the transaction either has those witnesses and the script passes or it doesn't and it fails.

I found this link quite useful for multi-sign scenario. https://github.com/input-output-hk/cardano-node/blob/master/doc/reference/simple-scripts.md#multi-signature-scripts
I wonder if anyone has tested the MultiSign.hs on testnet/mainnet yet? It seems the "txSignedBy" is not working as I got my fund locked.

yes, there's at least a few of these on mainnet. On testnet, I personally along with 4-5 SPOs tested multisig after allegra hard fork back in December of last year. Note that multisig via simple scripts is not a plutus script, so is probably not exactly what the OP is asking about.


text:
Where can I find recordings of previous Catalyst town halls?
I wish to view a recent Catalyst town hall broadcast.

The user page of IOHK on Crowdcast has all the recent town halls in chronological order.  The recordings have their presentation slides and the questions (asked and answered) included in the player.
The recordings on IOHK's YouTube playlist only has the video stream available.


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

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


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

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


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

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


text:
Validator getting access to delegator?
Is it possible for a validator to get access to delegator information? For example, is it possible to lock a token to be redeemable only by someone who is delegating to a specific stake pool?
Additionally, where can we find documentation about translating a staking address to a receive address off-chain, if we wanted to do airdrops manually until the Gougen release?

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


text:
How would a 51% Attack on the Cardano blockchain be started and overcome?

What exactly is the 51% Attack?

How hard would it be to accomplish this attack?

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

I gave you +1 but your question body is almost exactly the same as the question title. If you don't have anything else to write, maybe you could tell us what research you've done on the topic so far and where you've tried to look? The question body is usually meant to have more than just a repeat of the title!

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

I'd like to add, that the attacker only needs control of the majority of ada; this means he doesn't have to buy it, but could simply offer other incentives for delegators. (think of exchanges or big pools).

Thank you! I added this to my answer as well. He has to control the staked ada, it does not has to be his own.

The 51% number would imply the attacker controlled 51% of the STAKED ADA.  Not necessarily 51% of all ADA. Of course the closer we get to 100% of all ADA staked the closer those two numbers get to each other.


text:
Plutus Pioneer Program - Lecture #4 Homework - Best practice for logging errors
Below is my attempt to implement the homework assignment.
Is the way I call the endpoint twice in payTrace with minor differences appropriate?
Since payTest2 would not execute properly without modifying the original payContract, is the way I handle the contract error appropriate?
payContract :: Contract () PaySchema Text ()
payContract = do
    pp <- endpoint @"pay"
    let tx = mustPayToPubKey (ppRecipient pp) $ lovelaceValueOf $ ppLovelace pp
    Contract.handleError (\err -> Contract.logError $ "Caught error: " ++ unpack err) $ (void $ submitTx tx)
    payContract

-- A trace that invokes the pay endpoint of payContract on Wallet 1 twice, each time with Wallet 2 as
-- recipient, but with amounts given by the two arguments. There should be a delay of one slot
-- after each endpoint call.
payTrace :: Integer -> Integer -> EmulatorTrace ()
payTrace x y = do
    h1 <- activateContractWallet (Wallet 1) payContract
    callEndpoint @"pay" h1 $ PayParams
        { ppRecipient = pubKeyHash $ walletPubKey $ Wallet 2
        , ppLovelace  = x
        }
    void $ Emulator.waitNSlots 1
    xs <- observableState h1
    Extras.logInfo $ show xs

    callEndpoint @"pay" h1 $ PayParams
        { ppRecipient = pubKeyHash $ walletPubKey $ Wallet 2
        , ppLovelace  = y
        }
    void $ Emulator.waitNSlots 1
    ys <- observableState h1
    Extras.logInfo $ show ys

I retracted the surrounding code that has not been modified.
The start code can be found here.

The exception handler does not cover the first payment contract run. I've created a separate function for this that handles this error:
payContract' :: Contract () PaySchema Void ()
payContract' = Contract.handleError
    (\err -> Contract.logError $ "Caught error: " ++ unpack err)
    payContract

Then of course you have to call the payContract' in your emulator tracer as follows:
h1 <- activateContractWallet (Wallet 1) payContract'

You can also combine everything together like this:
payContract :: Contract () PaySchema Text ()
payContract = Contract.handleError
    (\err -> Contract.logError $ "Caught error: " ++ unpack err) $ do
    pp <- endpoint @"pay"
    let tx = mustPayToPubKey (ppRecipient pp) $ lovelaceValueOf $ ppLovelace pp
    void $ submitTx tx
    payContract

Again, thanks for the code. Interesting enough, the now posted solution in the github repo implements the error handling in the same way: https://raw.githubusercontent.com/input-output-hk/plutus-pioneer-program/solutions/code/week04/src/Week04/Solution.hs

I did a similar solution as @Mankeh - I added a second function to catch the error on the first transaction. Theirs is cleaner than mine.
And after checking the solution, I see that I got the order of submitTx and Contract.handleError mixed up in the payContract function. If I had put them in the solution's order, then the first error would be caught and the second 'wrapper' function wouldn't have been needed.
-- my solution
payContract :: Contract () PaySchema Text ()
payContract = do
    pp <- endpoint @"pay"
    let tx = mustPayToPubKey (ppRecipient pp) $ lovelaceValueOf $ ppLovelace pp
    void $ submitTx tx
    Contract.handleError (\err -> Contract.logError $ "Caught error inner1: " ++ unpack err)
        payContract

payContractErrHandler :: Contract () PaySchema Text ()
payContractErrHandler = do
    Contract.handleError (\err -> Contract.logError $ "Caught error: " ++ unpack err)
        payContract
    payContractErrHandler


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

I believe that the admins (Marek B.  @marklar) can change the challenge it is in if you ping him in telegram.

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

authors: Τάσος Αναστασίου


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

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

cardanoKnitties
cardanoBits

A direct link to the markup file is easier to follow than the git conversation. Also worth noting the original Cardano forums discussion of the CIP

Thank you for providing information.  As I look on the links provided, the focus is really on NFTs.  I wish some other thread dicusses fungible token standards, as I can see a number of native assets floating around that aren't well defined (Ex.  token's icon/logo image not existing).  But it's good to see how standards for NFT are being discussed by a number of Cardano contributors at least.

Cardano Improvement Proposal called CIP25 defines NFT Metadata Standard.


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

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

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

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

Not at the moment, as the fund rounds are still small.
But in the very near future, in order to vote in Catalyst, you would have to freeze your funds for the period of voting. This will prevent larger regulated entities such as binance, eToro or Kraken to participate, as it is against their regulation to prevent customer's liquidity.

Wouldn’t that reduce Ada’s liquidity too much? Meaning regular users would have less incentive to vote on proposals?

Any references to where this has been stated?

Yes, for example here: https://www.youtube.com/watch?v=GJANeEkj408&t=1495s

I found another answer in this article about Cardano (from 2019).
This paragraph in particular:

In Cardano, exchanges will get special enterprise exchange addresses that cannot participate in network consensus and governance. Although there is no technical way to enforce exchanges to use these, social pressure by the exchanges’ customers could push them to do so.


text:
Providing metadata to `cardano-cli transaction build-raw`
What command-line options and input file content can I provide to cardano-cli transaction build-raw to specify a transaction with metadata similar to the one in this transaction? https://explorer.cardano.org/en/transaction?id=ff126032aeccf0079a02168f9810a81d9632a8ac34e50cad278771be2423aa86
I initially thought that I just needed to give --metadata-json-file a JSON file with the corresponding desired JSON content (like the JSON show under 'metadata' on the webpage), but that just gives an error message about integer keys. In the Transaction Metadata reference for cardano-node, it says that the top-level keys must be integers, but I don't understand the significance or meaning of the values of the top-level integer keys or how the whole thing relates to an actual JSON I want to appear in the explorer.cardano.org transaction webpage.

Looks like you are using the CLI correctly, and the question was really about the NFT metadata standard. The usage of "721" as the top level key is to be compatible with Etherium token metadata and 3rd party sites that showcase ETH NFTs.
Alessandro of BERRY/SpaceBudz is the one who proposed this as a CIP on the Cardano forums and it seems to have been widely adopted at this point.
Edit: See also Is there a metadata standard for native assets (talking about fungible tokens first) in Cardano?

I still do not know the meaning of the values given to top-level integer keys, but I was able to get cardano-cli transaction build-raw to work by putting my original JSON as a value of a top-level integer key of 721. On cardanoscan.io, I noticed that the metadata has a 'label', which explorer.cardano.org lacks. I surmised that the label is the top-level integer key, but I don't know of a way to confirm that.
So the short answer is that the JSON given to cardano-cli must be an object with integer keys.


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

can you post the steps you have tried and the platform in which you are tying please

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

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

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


text:
Test-Focused EvaluatorTrace Monad?
Is there infrastructure for writing unit/integration tests for our contracts, without running the full playground?  Is there a test-focused EvaluatorTrace monad, for example?

There are now test capabilities in the Plutus.Contract.Test module which uses the Tasty library.
This is explained more fully in the unit tests section of lecture 8 of iteration 1 of the Plutus Pioneer Program.
Some highlights:
checkPredicate :: String -> TracePredicate -> EmulatorTrace () -> TestTree

There are a number of functions for producing a TracePredicate. For example:
-- | Check that the funds in the wallet have changed by the given amount, exluding fees.
walletFundsChange :: Wallet -> Value -> TracePredicate

Which can then be combined into a test function:
tests :: TestTree
tests = checkPredicateOptions
   (defaultCheckOptions & emulatorConfig .~ emCfg)
"token sale trace"
   ( walletFundsChange (Wallet 1) (Ada.lovelaceValueOf   10_000_000  <> assetClassValue token (-60))
.&&. walletFundsChange (Wallet 2) (Ada.lovelaceValueOf (-20_000_000) <> assetClassValue token   20)
.&&. walletFundsChange (Wallet 3) (Ada.lovelaceValueOf (- 5_000_000) <> assetClassValue token    5)
   )
myTrace

Which can then be run like this:
Prelude Spec.Trace> import Test.Tasty
Prelude Test.Tasty Spec.Trace> defaultMain tests
token sale trace: OK (1.22s)

All 1 tests passed (1.22s)

Naturally, these tests can be configured to run as part of "cabal test".

You can use Plutus Playground to test your code and maybe in the near future we will have more options.


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

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

Thanks Lars.
Do you perhaps want to update the broken link. I found this answer while searching for a related question.

You can also use this https://github.com/mlabs-haskell/plutus-simple-model
I'd say it's better because it's more up to date than the plutus-apps repo needed (for Contract Monad) from IOG (a lot is missing from Vasil)


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

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

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

Extension host agent listening on 38293

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

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

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

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

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

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

* remove un-needed files

* .cabal folder permissions for volume mapping

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

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

hosts:     files mymachines dns myhostname
networks:  files

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

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

    "remoteUser": "plutus",

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

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

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

Now I'm back in business

Thank you so much ! I had the same problem...

does the fix work for you?

Yes ! it worked!

Thanks! When in Windows use the variable USERPROFILE instead of HOME when mounting.

Thanks! You saved my life.

This is a follow-up to the answer from wutzebaer.
The Cardano team has since patched the repository to address the issue.
They did not, however, revert the problem file to its previous working state. Instead they re-introduced the file using a different method and with different contents. Namely, the new nsswitch.conf file only contains hosts: dns file
Apparently, this seems to have solved the problem for many, but there are still some cases where it is failing.
The workaround that wutzebaer posted still works, but I have a few improvements:

The nsswitch.conf file only needs to contain.
hosts: file dns

Note that the order is file dns, not dns file
The reordering of these properties is the new fix that needs to be made officially.

The nsswitch.conf file should be stored in the project where it can be committed to the repository, not in the user's home directory. In this way, the project remains self-contained and not dependent on any user-specific environment.

The new instructions:

create <project folder>/.devcontainer/nsswitch.conf
with the contents:
hosts: file dns

Update the devcontainer.json to mount the nsswitch.conf in the container.
{
    "name": "Plutus Starter Project",
    "image": "docker.io/inputoutput/plutus-starter-devcontainer:v1.0.10",

    "remoteUser": "plutus",

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

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

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

For bonus points, note that I have also modified the other mount configuration
"source=${localEnv:HOME}${localEnv:USERPROFILE}/.cabal/packages,target=/home/plutus/.cabal/packages,type=bind,consistency=cached"
changing source=${localEnv:HOME}/.cabal/packages
to source=${localEnv:HOME}${localEnv:USERPROFILE}/.cabal/packages
This is because the HOME environment variable is not a standard variable in Windows, although many people may have it defined due to various (often 'nix-like) software installs. Microsoft's recommendation is to pair ${localEnv:HOME}${localEnv:USERPROFILE} since HOME is only valid for Linux and USERPROFILE is only valid for Windows.
In my case, the HOME variable is not defined, so spinning up the container would give me mount errors because it was looking for /.cabal/packages instead of C:\Users\FuzzyLogic/.cabal/packages

Good news, and bad news.  Bad first.
I just tried the single line of config, and sadly it doesn't work for me. No matter which way I had the files or dns.  Specifically NEITHER of these configuration lines worked:
hosts: file dns
hosts: dns file
When I used the single line nsswitch.conf configuration I just used "Rebuild Container" in VS Code and the ENOTFOUND error messages continued to appear.
The GOOD NEWS:
Upon using the larger configuration (again, thanks to wutzebaer) - this worked; well, at least I got what looks to be a working environment.
:-)

Welcome to Cardano SE! As a new user be sure to take the [Tour].


text:
Price regulation of the ADA token
What is the economics behind the value of ADA in fiat currency? Assuming that bitcoin will dominate 100% of the "store-of-value" market, and taking speculation out of the equation, I don't understand where the intrinsic value of the token will be pegged to in the future. For example, if the price of ADA jumps from 1 USD to 10 USD, what are the immediate effects in the blockchain? Does anything happen that pressures the price back down to 1 USD?
It is my understanding that ADA will be useful to fuel smart contracts by collecting transaction fees. These fees are currently fixed by the network and there is no auction dynamics such as in bitcoin, where if you want your transaction to be included in the blockchain fast enough, you need to pay more. But in Cardano, this mechanism doesn't seem to be there.

This seems to be a question asking for opinions rather than facts.  Probably better asked on reddit than here. It needs to be re-worded to be a more factual question or perhaps nominated for removal.

I’m not sure I agree. I’m asking what mechanisms are there for price/value regulation. It was probably studied in research papers but I haven’t seen it. I was hoping someone with better knowledge could point me in the right direction. In other words, is the blockchain efficiency predicted to be independent of the market value of the ADA token? In other words, if the price goes down and stake pools decide to retire, that will pose a security risk for the blockchain and therefore apps like ATALA Prism. What would be the mechanism that would encourage stake pools to stay active?

You could ask this question about any other currency, including USD, EUR, CNY and BTC. What could you reasonably expect of ADA? Central bankers to control rates like for fiat currencies? Armies and diplomats to enforce agendas like in the case of fiat? Government departments to restrict how ADA can be traded? Who gets to decide what the price should be in a way that does not breed centralization or corruption? ADA is just ADA and people do whatever they want with their fiat, which is outside the system of Cardano. I think the short answer to the question is basically a  ¯\(ツ)/¯.

You may get fewer stake pools and greater centralization, but I think the key is not to manipulate the price but to increase and sustain the usefulness of the blockchain, i.e. build up the ecosystem of builders and users. If the blockchain is useful, the price will be sustained. I think if Cardano has to worry about the negative impact of a low price, then Cardano has failed in other aspects like being useful.

I'd like to mention that IOHK just published an article discussing this issue from the perspective of infrastructure maintenance: https://iohk.io/en/blog/posts/2021/06/10/stablefees-and-the-decentralized-reserve-system/

Leaving aside the fact that ADA is exactly as hard as bitcoin, that is, it's hard capped, just happens to be a lot more of them. In a single word: utility. As all business enterprises adoption creates demand for the currency to pay for services of the chain.


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

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


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

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


text:
Randomness in a smart contract
Is it possible to get randomness in a smart contract? E.g. I would like the validator to randomly choose between two conditions to use to validate a transaction. Such a capability could be used for example to implement a lottery smart contract.
If so, what are the mechanics of the randomness?
If not, how could the lack of randomness be circumvented to implement something like a lottery smart contract?

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


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

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

For the second part of your question (what's to stop the size of the blockchain from growing indefinitely to the point where it's impractical to store on consumer hardware?), there are concepts like sharding and side chains and .... You can watch Charles Hoskinson talking about this topic here.


text:
How does the hardfork combinator work?
Naïvely one would think it's a mere version tag on the block. However, most other chains do not include a combinator. How does it work at the low level and why only Cardano has it?

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


text:
Why are proposals to solve issues discouraged during the insights phase (first week)?
The insights phase is held during the first week of a proposal round. You cannot put proposals up.  Only insights can be added.
Insights are described as ideas and submitters are encouraged not to propose solutions.  At the end of the first week.  Everybody's Insights are archived and only their author can see them.

This question seems like it may either be asking for recommendations, be opinion-based, or off-topic entirely. Can you clarify this?

Close voters: It might not be the case that the answer would be opinion based necessarily.  There may actually be a real reason for this that some people just don't yet know.

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


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

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

If you are looking for funds your own project I can only assume you are operating as a business entity, if you insist on not accepting VC money despite wanting to operate as a business entity then I would seriously suggest you check out this new funding modal, unique to and only possible using Cardano called an "Initial Stakepool Offering" or ISO.
https://sundaeswap-finance.medium.com/sundaeswaps-upcoming-initial-stake-pool-offering-iso-48fade1900a
In my humble view it radically changes the game when it comes to sourcing funds for blockchain based startups/projects because it taps into the existing innovative   staking mechanism built into Cardano, and your supporters funds are completely safe.
This is of critical importance and is the killer-feature of the ISO model because it creates a risk-free (minus fees collected approx. 5.5% APY that you would otherwise collect for staking) environment for supporters in direct opposition to the scam-ridden ICO funding model of the past. The fact that people can support you virtually risk-free creates a very rich and liquid startup environment where people are more than happy to throw some ADA around at different projects.
It also creates a much higher level of trust between the project and the supporters because once you have someone's money you lose the financial incentive to work as hard as possible to deliver. While the ISO model has built-in incentive by way of the supporters losing faith in a project that continually misses roadmap targets and will eventually undelegate their ADA, and only having to accept the loss of 5.5%~ APY that they would have otherwise earned. This is massive and simply cannot be overstated.
I am unaffiliated in any way with SundaeSwap directly, although I'm a firm believer in the funding model that they pioneered.


text:
What decisions are left to the slot leader?

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

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

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


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

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

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

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


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

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

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

You can try configuring the timeout in cardano/plutus/plutus-playground-client/webpack.config.js
devServer: {
    contentBase: path.join(__dirname, "dist"),
    compress: true,
    port: 8009,
    https: true,
    proxy: {
        "/api": {
            target: 'http://localhost:8080'
            timeout: 1000 * 60 * 10
        }
    } },

There also appears to be a proxyTimeout setting that you can try.
I can't reproduce the error on my end so I'm not sure if this will work, but it seems to make sense that the webpack server is timing out.
Here is a general question posted about webpack dev server timeouts that suggest trying the configurations I mentioned above.
https://stackoverflow.com/questions/47217090/how-can-i-let-webpack-dev-server-have-incoming-request-timeout-with-custom-value

Unfortunately, it's not a request from the browser to the client app that's timing out, it a request from the server app to a WebGHC instance to compile the code. You won't get away without modifying the source of the server, as outlined in my answer.

This is indeed due to a timeout expiring.
It is not, however, a request sent by the browser timing out, so changing the client Webpack config will not solve the problem as @Frank suggests.
The Plutus Playground server uses WebGHC, served to a different localhost port, to compile the code, and submits the file to the WebGHC instance via a HTTP request. This may take some time to run, and on a slow machine, it can exceed the 30 second timeout.
To fix this, you'll need to dig in to the Haskell source of the playground server.

In the Plutus directory, open the file plutus-playground-server/src/Playground/Server.hs in an editor.

Change these lines:

(around line 29)
import           Network.HTTP.Client.Conduit  (defaultManagerSettings)

==>
import           Network.HTTP.Client.Conduit  (defaultManagerSettings, managerResponseTimeout, responseTimeoutMicro)

(around line 114)
manager <- newManager defaultManagerSettings

==>
manager <- newManager (defaultManagerSettings { managerResponseTimeout = responseTimeoutMicro (1000 * 60 * 1000000) })

You'll then need to rebuild the server
cd /path/to/plutus
nix-build -A plutus-playground.server

and then switch back to plutus-playground-client and re-run plutus-playground-server.

This has actually been fixed in more recent versions of the playground (to take a timeout on the command line), but the Pioneer Program is pinned to a specific commit, so won't get the update.


text:
Why is PoS much faster than PoW?
My understanding of the topic is this:
Proof-of-Work

Miners compete with their hashrate for the right to publish a block.

Proof-of-Stake

Validators are randomly elected to validate a block.

Why is PoS faster then? - The only computation a PoS node needs to do is validating a set of transactions in a block.
Correct me if I'm wrong or missing something.

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

So would you say Cardano choose PoS over PoW largely because of the decreased energy costs and the ability to maintain true decentralization? Meaning that the speed of the network was almost an afterthought because of how comparable they are.

The big advantages are the scalability and low energy requirements. This includes speed, but the main advantage of PoS over PoW is the more energy requirement. I can recommend the following link for further reading: https://cardano.org/ouroboros/

To find a rare hash (for example, as in block 707750) using the brute force method is incomparably more difficult than choosing a validator according to a certain algorithm. That is why blocks in Bitcoin network are created, on average, every 10 minutes, but in Cardano, on average, every 20 seconds.
If you have Xcode you can test my Swift app to find out in what degree it's difficult to find a rare hash.


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

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

By doing it this way, Cardano saves space on the blockchain. Otherwise, after every epoch, there would be a ton of new UTXOs generated on the blockchain to hold rewards. They don't become UTXOs until they are moved out like @nalyd88 said.


text:
What known stake pool attacks exist?
Recently a stakepool (CRO) changed its costs and % fees 30 minutes before an epoch end, effectively changing the rules mid-epoch for people staking with the pool.
Are there other known stakepool attacks that affect the community and stakepool delegators at large?
Is there a service for notification on SPO rule changes mid-epoch?

IIUC it's possible to oversaturate a pool, but whether that counts as an attack is a bit dubious.

I want to point out that they released a statement explaining that this increase happened after all delegators agreed. It was a private pool and the rewards should be used as a kind of donation, the delegators were probably promised some other kind of rewards. Of course, this was just one case and a dishonest pool operator could do this without having the delegators know and agree.

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

To answer your second question about tools notifying you about pool changes, you can try PoolTool Mobile.
From there you can set up Fee Change, Pool Saturation, and New Block mined notifications.


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

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

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

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

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


text:
Where can I find formal work comparing PoS and PoW models?
For some time now I have been trying to find some clear and objective comparison of proof-of-stake (PoS) and proof-of-work-based (PoW) consensus protocols. Unfortunately, pretty much every comparison I have found has been written by a partisan of one or another coin, and has been strongly colored by the writer's opinions of each specific coin's virtues and defects (which are, more often than not, tangential to the formal properties of its consensus protocol).
What I would like to find is a formal comparison of PoS and PoW. By this I mean a comparison that models each protocol (including their possible variations) formally, in idealized forms that are independent of any real-world coin, and in such a way that it becomes possible to characterize objectively the relative strengths and weaknesses of these idealizations. Such characterizations may include, for example, expressions for cost per transaction, or the probability of success a particular type of attack, in terms of the values of various model parameters.
I realize that such work is difficult to do, and that it is rarely definitive, as there is always a gap, often a considerable one, between theory and practice. In other words, factors that cannot be adequately captured by the models may ultimately be decisive in practice.
Still, even with these caveats, such formal work can still help to identify and clarify the main structural features of the real-world problem that impinge on the comparison.
I would appreciate any pointers (to papers, books, individual researchers, etc.).

I will provide one paper as a comment as I dont believe that this question allows a "correct" reply. However, after a quick search on google scholar, I believe that this paper in part discusses what you are looking for: http://elit.lnu.edu.ua/pdf/9_10.pdf - there are many papers exploring proof of work or proof of stake. You could invest some work to create a comparison of these papers by yourself. Many blogs and articles do what you request, but I would not label them "formal".

Hey @Peter1807 , I think you should post the link to this paper with some snippet of it pulled out and an explanation of why you think it would be helpful to the asker. In my opinion that would suffice as a "correct" answer, given that the publication is in my opinion "formal". If that is not a "correct" answer to kjo's question then maybe the question needs to be closed for being unanswerable.

There are many variations on proof of work and proof of stake.  It is unlikely that there will be a formal comparison of these broad concepts.
The closest you are likely to find are informal comparisons such as Charles Hoskinson's video "Video for Jack: PoW versus PoS"

This article contains some references to more "technical" papers, although I agree with the general view that a more formal comparison is required:
Consensus Mechanisms Explained: PoW vs. PoS

I don't think this is by any means a complete answer however I know that IOG has a number of papers going into the formal properties of various consensus algorithms. Here are some papers that do formal analysis of and comparison between various consensus algorithms:

The Bitcoin Backbone Protocol with Chains of Variable Difficulty
But Why Does It Work? A Rational Protocol Design Treatment of Bitcoin
Full Analysis of Nakamoto Consensus in Bounded-Delay Networks
Comparison of Block Expectation Time for Various Consensus Algorithms

You might also want to look at the various papers for the Ouroboros protocol as those reason about the formal properties of the Ouroboros protocol specifically and compare performance and security guarantees against Proof of Work and ideal BFT consensus.

IOG Research Library (has all the Ouroboros Papers)

The some of the other Proof of Stake consensus protocols have a decent bit of academic work reasoning about the properties of their protocols. These papers (and research libraries in general) should also be considered as they have a wealth of knowledge as well.

Algorand Research Library

Polkadot Research Library

By no means is this all of the research out there on the subject, this is just what I know of off the top of my head.


text:
Confused by compilation message in plutus playground (week 5 pioneer program)
This is part of my attempt at solving the first homework assignment of week 5 in the plutus pioneer program.
The rest of the unmodified file can be found here.
{-# INLINABLE mkPolicy #-}
-- This policy should only allow minting (or burning) of tokens if the owner of the specified PubKeyHash
-- has signed the transaction and if the specified deadline has not passed.
mkPolicy :: PubKeyHash -> Slot -> ScriptContext -> Bool
mkPolicy pkh deadline ctx = traceIfFalse "Valid signature missing" signed &&
                            traceIfFalse "Deadline has passed" stillTime
  where
    info :: TxInfo
    info = scriptContextTxInfo ctx

    signed :: Bool
    signed = txSignedBy info pkh

    stillTime :: Bool
    stillTime = to deadline `contains` txInfoValidRange info

policy :: PubKeyHash -> Slot -> Scripts.MonetaryPolicy
policy pkh deadline = mkMonetaryPolicyScript $
    $$(PlutusTx.compile [|| \pkh' deadline' -> Scripts.wrapMonetaryPolicy $ mkPolicy pkh' deadline' ||])
    `PlutusTx.applyCode`
    PlutusTx.liftCode pkh
    `PlutusTx.applyCode`
    PlutusTx.liftCode deadline

curSymbol :: PubKeyHash -> Slot -> CurrencySymbol
curSymbol pkh deadline = scriptCurrencySymbol $ policy pkh deadline

I tested the code by loading the file into the repl and running the test. The output confirms that this seems to be the right solution.
However, when compiling the code in the playground, I get this message:
It looks like you have not made any functions available, use `$(mkFunctions ['functionA, 'functionB])` to be able to use `functionA` and `functionB`

Since endpoints is defined, the contract is made available in the simulator and I can confirm the test manually in the simulator as well.
I am just very confused by this message. Did my code introduce an uncaptured error? I compiled some of the previous files without this message. What am I missing?

I just copied your code snipet in the Homework1.hs from week 5 in the playground at playground.plutus-community.com and I dont get any errors. Can share your whole file?

I wanted to clarify that it still compiles, it's just a warning message that shows up in the playground on compilation. @AngelCastillo you can find the file here: https://raw.githubusercontent.com/manonthemat/plutus-pioneer-program/homework/code/week05/src/Week05/Homework1.hs

The Playground needs some boilerplate added to a module:
mkSchemaDefinitions ''NAMEOFYOURSCHEMA
mkKnownCurrencies []


text:
I'm having issues with nix-shell
I keep getting this error, any thoughts? I have re-downloaded nix 3 times now and it's the same error as before. Not sure if it's the profiles or channels but this is what it gives me:
'''trying https://bintray.com/joneshf/generic/download_file?file_path=purty-6.2.0-osx.tar.gz
  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
  0     0    0     0    0     0      0      0 --:--:-- --:--:-- --:--:--     0
curl: (22) The requested URL returned error: 404 Not Found
error: cannot download download_file?file_path=purty-6.2.0-osx.tar.gz from any mirror
builder for '/nix/store/h5r5c5d2hq01xkdppsic3bl6qacc3wqj-download_file?file_path=purty-6.2.0-osx.tar.gz.drv' failed with exit code 1
building '/nix/store/ymrrdyw3n26pj4slkcmcqbmmyzd5k10k-edit-distance-lib-edit-distance-0.2.2.1-config.drv'...
cannot build derivation '/nix/store/w2j8cjba5cq80q8874c5zy2n4p6cjn11-purty-6.2.0.drv': 1 dependencies couldn't be built
error: build of '/nix/store/00czvl77x4dsjgyacq2i0ndknq1nhpig-sort-lib-sort-1.0.0.0.drv', '/nix/store/1skqzb2qn4cgh2wca78p3d7x8dzkwl6x-update-metadata-samples.drv', '/nix/store/24q0nd586wkyap6v79kcrk5141n2gj10-cabal-install-exe-cabal-3.4.0.0.drv', '/nix/store/2phjywsqy1607ing23kbwibh2aljsi2r-fix-stylish-haskell.drv', '/nix/store/31z19v2i3iibmfq76gyv5pqcr55976zv-updateMaterialized.drv', '/nix/store/3m344smmhpl6w0agwrf3h51h06smh28s-haskell-language-server-exe-haskell-language-server-1.1.0.0.drv', '/nix/store/51nz2l60xlkcg3kfml4115n9ndl37hjz-morph-1.5.0.drv', '/nix/store/6kqxqav9rh7fqi0csxzj9s4806i7vh75-signal-lib-signal-0.1.0.4.drv', '/nix/store/6lqh7knn0dfxdbmrm1xfn38dq1l8d29j-streaming-binary-lib-streaming-binary-0.2.2.0.drv', '/nix/store/6mmj5jxczlzdizisc0xlw18k84iwx9hz-agdaWithPackages-2.6.1.1.drv', '/nix/store/7kbhkhpilggidv66brc587jrkvkhq69n-partial-order-lib-partial-order-0.2.0.0.drv', '/nix/store/8012yr8janh31vlsjays761clvz20ami-ieee754-lib-ieee754-0.8.0.drv', '/nix/store/85npd6ymfj0q8wg92mzjsmdq0k41js85-r-dplyr-1.0.2.drv', '/nix/store/8j74dj2y8avqb5k6slnrn049lgzprvhg-hlint-exe-hlint-3.2.1.drv', '/nix/store/9820n0i8vhzgiiacpx2i6i6nyrsaway5-validation-lib-validation-1.1.1.drv', '/nix/store/9aqg02hwpvkvbh12cnmkdr0jf5qbc6dz-tree-diff-lib-tree-diff-0.2.drv', '/nix/store/9isss0nqik8hsmhymkx2gyq115xjs36y-sbv-lib-sbv-8.14.drv', '/nix/store/9lasjc950dfsn71hv9r8rzhspcscirg9-pretty-simple-lib-pretty-simple-4.0.0.0.drv', '/nix/store/bbidfihkb8x2gaf1fb2d8yjkfpqhm7xa-r-tidyverse-1.3.0.drv', '/nix/store/bdxspighrzkiip40jfnhbwnnia58bh0f-microlens-mtl-lib-microlens-mtl-0.2.0.1.drv', '/nix/store/c0kv959f5aq51cyzl4qnbpsvk88ps3m1-tdigest-lib-tdigest-0.2.1.1.drv', '/nix/store/c144bf3zwkpam1kbn04y97xhxfd9w601-generic-monoid-lib-generic-monoid-0.1.0.1.drv', '/nix/store/d6n0fpqh61s8x1ml1ighn8g8knv2qbxf-r-shiny-1.5.0.drv', '/nix/store/fsfi7xcvqrl6fcma5r1cs13yd277s618-streaming-bytestring-lib-streaming-bytestring-0.2.0.drv', '/nix/store/gbk4dp9gz0ggx66057nyi4gkv61j3a15-tasty-smallcheck-lib-tasty-smallcheck-0.8.2.drv', '/nix/store/gl9jrf8hc3ylpsplr8n2hs51xsn4nmbi-python3-3.8.6-env.drv', '/nix/store/gp6jgd67y75js5s3ackfkb5iszmzybsl-inline-r-lib-inline-r-0.10.4.drv', '/nix/store/hfv786xib23lfjk74lzxlrmm103q6v4s-r-plotly-4.9.2.2.drv', '/nix/store/i1igk4bviddh52vssqlm07hzf9j449p6-quickcheck-text-lib-quickcheck-text-0.1.2.1.drv', '/nix/store/ijzzvvq1kd953qhpiar696iqh8bxpgf9-r-shinyjs-2.0.0.drv', '/nix/store/ik042p673z6539x4zdp65k6xqmdkq0m6-ghc-shell-for-packages-ghc-8.10.4.20210212-env.drv', '/nix/store/ivgidgaa262s5javry9frg0hzckicbmw-r-purrr-0.3.4.drv', '/nix/store/j11byvlsxjykg0ynmddnqrf9d75wg5w5-typerep-map-lib-typerep-map-0.3.3.0.drv', '/nix/store/j678ky26621ys0jk651b7263cg7yn66z-extensible-effects-lib-extensible-effects-5.0.0.1.drv', '/nix/store/jzvxxyyqpbhbkfxxw2ac7hj8r57bb8by-process-extras-lib-process-extras-0.7.4.drv', '/nix/store/k9m80yh5wmrmic44nvlq57ll3nv5k334-tasty-expected-failure-lib-tasty-expected-failure-0.12.3.drv', '/nix/store/kkwfwqhfp5dr7s8xfwnvhz7h5hrpbq29-rate-limit-lib-rate-limit-1.4.2.drv', '/nix/store/lyvsqqnghjbspwp3zf0417zlhn49s51i-hspec-expectations-pretty-diff-lib-hspec-expectations-pretty-diff-0.7.2.5.drv', '/nix/store/m0wwdkv6dca42i8ii6h08k3j94j0fpmk-loch-th-lib-loch-th-0.2.2.drv', '/nix/store/mc8v4zm1vxj32mqhkbvc2h1r3s43x4bg-hspec-lib-hspec-2.7.9.drv', '/nix/store/mhd5irwlzbyzxxsbqrywlxxnkffm1gfm-hie-bios-exe-hie-bios-0.7.5.drv', '/nix/store/nkrkj480lwidfalwmijip0z3lpajllys-groups-lib-groups-0.5.2.drv', '/nix/store/nw0pm1c6pjxmxh3nm32y8c43igzm6v9s-pure-zlib-lib-pure-zlib-0.6.7.drv', '/nix/store/pmmbzhgf4qsd0sjfj61mak31a3b22z7x-r-stringr-1.4.0.drv', '/nix/store/qv7yjyqpby61b10876kg3w92qyqv7vks-tasty-quickcheck-lib-tasty-quickcheck-0.10.1.2.drv', '/nix/store/r290xlyhhrx7720f82b7piqs8q3bsidn-r-MASS-7.3-53.drv', '/nix/store/ssp8icp0lrb42dnkgzz3hbq9jcvnckzb-wl-pprint-lib-wl-pprint-1.2.1.drv', '/nix/store/vpbn2q57ljbdnryffkkg9yh574q92rif-moo-lib-moo-1.2.drv', '/nix/store/w0jpaqn7bm0j961kvqfbq9p6vn45l4dp-pre-commit-config.json.drv', '/nix/store/w2j8cjba5cq80q8874c5zy2n4p6cjn11-purty-6.2.0.drv', '/nix/store/w6hkfwbk4y92rj3y689sq5jhhcmgz9gh-update-client-deps.drv', '/nix/store/wmkc31ic82raw02wj75dihcp2cr442zl-gauge-lib-gauge-0.2.5.drv', '/nix/store/wra9k298zi1h037jyqk6d81d0pzl5g4w-criterion-lib-criterion-1.5.9.0.drv', '/nix/store/xjil71bs00sidlp6bmlnw1crzrpzbnig-z3.drv', '/nix/store/xs5fcb6zahna29znlpfxvfb6rhcd3qd6-cassava-lib-cassava-0.5.2.0.drv', '/nix/store/yw23258yf4idsinig1ac06h8gb4y347l-fix-purty.drv', '/nix/store/z8h2jvfqxzzcnbx9lv0vrnq52b4kj114-hint-lib-hint-0.9.0.4.drv', '/nix/store/zcyridhi051675splnihx5myd7599wd4-stylish-haskell-exe-stylish-haskell-0.12.2.0.drv', '/nix/store/ziifb1divbpabkg3dqkv1c0qi0bdhsnj-smallcheck-lib-smallcheck-1.2.1.drv', '/nix/store/zivnf3s09nf4l0zk8wi6gxr5s6av7x43-pipes-lib-pipes-4.3.15.drv', '/nix/store/zp3asyqhf3538a7x9cc5a3sb8xb2hjkc-tasty-hedgehog-lib-tasty-hedgehog-1.1.0.0.drv' failed'''

Can you please share which exact commit and branch you are trying?

It may help to use IOHK's binary caches.
You can set these up globally for your system by adding/creating these lines in /etc/nix/nix.conf:
substituters        = https://hydra.iohk.io https://iohk.cachix.org https://cache.nixos.org/
trusted-public-keys = hydra.iohk.io:f/Ea+s+dFdN+3Y/G+FDgSq+a5NEWhJGzdjvKNGv0/EQ= iohk.cachix.org-1:DpRUyj7h7V830dp/i6Nti+NEO2/nhblbov/8MW7Rqoo= cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=

I have tried that but the file is locked, so I duplicated and ran that and still is giving me the same error unfortunately. Im using MacOS M1,

I don't know if the ARM-based processor complicates things, but you can edit your file using sudo from the terminal. Prepend sudo to your favorite editor; for example run sudo vim /etc/nix/nix.conf to modify the file.

this worked for me, thanks

This doesn't work for me, I've added those lines and still get the same error

This worked for me.

There are multiple different types of nix.conf files in the $PATH, even when I made one globally. So What I initial did was replace all of them with the IOHK's binary caches, and from there it worked.


text:
Remix IDE & Cardano
Are there currently any plans for a Cardano version of the Remix IDE?
Currently it works for Solidity on Ethereum and Binance Smart Chain and the network is selectable from a drop fown list box. This suggests at least some form of modularity and extensibility.

Welcome to our new community! This question has 2 close votes (not from me!) so I just thought I'd warn you that these type of questions that are only temporarily valuable may be better for our chat room.

I’m voting to close this question because 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 did not personally hear anything about such plans.
However, I'm voting to close this question as I feel this is good question for Remix developers and might be off-topic for this StackExchange space.


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

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


text:
Undelegate stake with Daedalus wallet
How do I undelegate (unstake) with Daedalus wallet to receive my 2 ADA deposit back. I remember used to be an option but it seem I can no longer find it. Is there is any way without actually using Yoroi wallet. I trying to minimize typing my keys into other wallets I rather lose those 2ada if there are no longer undelegation support for Daedalus.

can someone add tag unstake undelegate so others can find it. I have no enough reputation to create new tag

Donni, added the tag.

As far as I can tell, the feature has been removed from Daedalus. I suppose you can just transfer your ADA to another wallet. I'm curious what is the particular reason you want to undelegate? it seems like there's no downside.

There are various reasons why somebody would like to undelegate. Simply managing your portfolio for example:  Merging few wallets into one, selling off some of your wallets, creating new keys and moving your balance to new wallet for security concerns. There should be option to unstake or otherwise I wouldn't call 2 ada as deposit. For now as far as I know I need to take additional steps and install new wallet to take deposit which I wont do for security reasons. Thanks

There is an issue open on Daedalus github requesting this feature. Looking into the linked pull request, the feature appears to be complete but not enabled for the main client yet. Per Daedalus devs, the solution right now is to import the keys to Yoroi. You could do this after transferring out balance & rewards to minimize the security risks.

I wasn't aware that somebody pointed this out in github. I tried look for information and it seems nobody raised it on any forums. So i though I will ask here. Anybody could comeback and look it up. Perhaps its solved and in upcoming Daedalus update feature will be back. Thanks

The way I got around this problem was to install Yoroi onto my mobile phone, ADDed a Shelley wallet and RESTORed each of my Daedalus wallets onto Yoroi.  By doing it this way I was able to get full access to all three of my Daedalus wallets.

At the moment you cannot undelegate in Daedalus 4.4 wallet but you can definitely do it using cardano-cli utility for getting the 2 ADA deposit back. Here's a deregistration command:
cardano-cli stake-address deregistration-certificate \
    --stake-verification-key-file stake.vkey \
    --out-file stake.cert

Then build a transaction:
stakeAddressDeposit=2000000

txOut=$((${totalBalance}+${stakeAddressDeposit}-${fee}))

cardano-cli transaction build-raw \
    --tx-in b64ae99e1195b04663ab863b62337e626c65b0c9444a9fbb9ef4458f81a6fe4#1 \
    --tx-out $(cat payment.addr)+${txOut} \
    --invalid-hereafter $((${currentSlot}+10000)) \
    --fee ${fee} \
    --alonzo-era \
    --out-file tx.draft \
    --certificate-file stake.cert \


text:
Does ADA have any credit features built into it?
Are there any feature of Cardano ADA or its ecosystem that make borrowing against ADA held easier or better than other cryptocurrencies?
Will all credit require that an application be developed to support it?

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

Celcius has already committed to integrating Cardano's ADA, which will let you borrow against your ADA for USD or a stable coin. I don't have a timeline when ADA will be implemented, my guess is after Alonzo.


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

Not currently possible for any currency.  All currency conversions require an exchange or broker.  Questions that ask for predictions are also not appropriate as they require speculation rather than facts in most cases.  If they can be answered with facts, they become obsolete over time.

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.

LocalBitcoin.com might have some options.


text:
Where is the returning Contract Monad in the handleError function of Contract Monad?
The type of handleError function is
:: (e -> Contract w s e' a)-> Contract w s e a -> Contract w s e' a

It takes two arguments

a function which takes error and returns a Contract monad (Contract w s e' a) without error
Contract Monad with error

and returns a Contract Monad without error (Contract w s e a). This is what I could understand. However when this is used in the following code
payContract = do
   pp <- endpoint @"pay"
   let tx = mustPayToPubKey (ppRecipient pp) $ lovelaceValueOf $ ppLovelace pp
   handleError (\err -> Contract.logInfo $ "caught error: " ++ unpack err) $ void $ submitTx tx
   payContract

In this function call submitTx Tx gives the Contract Monad with error and the lambda function \err -> Contract.logInfo $ "caught error: " ++ unpack err may be the first argument. What is happening to the returned Monad without error? and why void is used?

Definitions:
submitTx :: forall w s e. (HasWriteTx s, AsContractError e) => TxConstraints Void Void -> Contract w s e Tx
void :: Functor f => f a -> f ()
handleError :: (e -> Contract w s e' a)-> Contract w s e a -> Contract w s e' a
Explaination:
submitTx tx is of type Contract w s e Tx, i.e. a Contract Monad with return type Tx.
void takes any Monad and maps it to a Monad with return type (). This is useful if you don't care for the returned value: void $ submitTx tx :: Contract w s e ()
handleError then takes the Monad and handles any errors with the specified error handler (e -> Contract w s e' a). However, it doesn't change the return type of the Contract Monad. In case there is no error on runtime the return value is just passed through.
payContract calls itself recursively on the last line of the do block in order to listen to the pay-endpoint indefinitely. Let's assume you'd leave out handleError and only use void $ submitTx tx your contract would crash on the first submission error.
If you wouldn't use void, your program would still be valid, but your compiler would output a warning, because you didn't use the return value of submitTx tx.

What is happening to the returned Monad?

All of this takes place within the do block. So, similar to the
<- endpoint @"pay"

the returned Monad is being abstracted away for you. The whole function is returning a Contract, so if it fails on either line, it will exit "early" and return the failed value. The reason it's not using the <- symbol is the answer to your second question:

why void is used?

We don't need the contained value.
void :: Functor f => f a -> f ()

So, void for Contract converts Contract w s e a to Contract w s e ().

You could also do this conversion by ignoring the output of a monad, as long as you still return the correct a for Contract, which in this case is ().
_ <- submit tx
return ()

is equivalent to
void $ submit tx

However, void is more explicit and fits better with the
handleError (\err -> Contract.logInfo $ "caught error: " ++ unpack err)

in your example.