Bitcoincore development – Bitcoin privacy – current state of privacy GDPs – is mimblewimble broken?

Community, what is the current state of data protection-related border inspection posts?

  • CoinJoin Related:
    • Adam Gibson's SNICKER design, which allows a simple unidirectional CoinJoin construction.
    • BIP 79, Bustapay, a standard for CoinJoined payments.
  • P2P improvements:
    • GDP 156, Dandelion: Routing of resend transactions some hops before sending.
    • Draft for BIP 324: encryption of the P2P layer, making the origin of the transaction more difficult for passive attackers to find
    • Design for Erlay GDP: (less privacy-oriented) introduces a less targeted, lower bandwidth transaction broadcast mechanism
  • Consensus rules:

The first sentence of these are not consensus or protocol changes in the Bitcoin network. These are just standards that Wallet can implement to improve the privacy of their own transactions. There are many other techniques that may or may not be implemented by wallets that have not been written as formal GDPs. Read this great article on Chris Belcher's wiki for an overview:

Is there anything on the core developer roadmap to be implemented in the main chain within the next year?

Data protection is a complex issue, and while at the protocol level, there may be some things in which core developers may be more involved, there is much more to do at the wallet level. The Taproot proposal is an example of a protocol-level change: it aims to improve another type: privacy in the chain. This is the problem where the type of scripts your wallet uses on the network tells you what actions it is taking (for example, Multisig, Lightning, 2FA, …). The goal of Taproot is to ensure that in cooperative cases, all transaction issues and inputs are indistinguishable. This is completely different from the type of data loss that CoinJoin treats (which exposes the connection between transactions).

I doubt anyone can tell you when it might be activated on the network. That's because of the community.

And regarding mimblewimble: Are you aware that I'm starting from the latest researcher claims about a broken privacy model from mimblewimble?

I think that's a very confusing statement. Mimblewimble itself does not offer any improvement in privacy. It's an improved design over confidential transactions (the is a privacy method (hiding transaction amounts) to improve scalability and allow for non-interactive CoinJoin.

If you look at the original paper Mimblewimble by Tom Elvis Jedusor or the more formal paper by Andrew Poelstra, you will find that privacy is only mentioned in the context of what is provided by CT or activated by CoinJoin.

CoinJoin itself is not broken, but how it is used is very important. Properly used, participants interact privately to co-create a single transaction that, when exposed to the public, can not be broken down into the contributions of individual participants. CoinJoin was used in a particular mimblewimble implementation in the public network, It should be obvious that this does not give anyone who observes the network privacy as it can easily see all the individual contributions to transactions. This is not a bad idea, just a gain in scalability. For privacy reasons, CoinJoin must also take place elsewhere.

So again: CoinJoin is not broken; it helps if used properly. Mimblewimble or its privacy will not be violated either – Confidential transactions and the possibility for non-interactive CoinJoin are great. Mimblewimble also enables non-interactive CoinJoin, which also happens to be used as a scalability enhancement, but does not improve privacy when run publicly.

Well, I think the current border control posts all have somehow a mimblewimble-like or CoinJoin-like approach to privacy, right?

They do not "solve" the privacy. Privacy is a goal that needs to be achieved, but it is diverse and not resolved by a single technical element. Essential parts of the privacy concern education and incentives, not a miracle technology that suddenly hides everything.

To my knowledge, nobody seriously suggested mimblewimble in Bitcoin.

Does BOgatty's quote also apply to current data protection border inspection posts (or to the majority of them)? Without arguing whether it is a mistake or not, the basic fact is that the current data protection GDPs have this approach to "place transactions in a single CoinJoin"?

No, since this does not apply to CoinJoin. This is true for the use of scalability enhancement, which is inherent in mimblewimble implementations and has been misrepresented by some as gaining privacy.

Would be nice if someone with Bitcoin can clarify the state of privacy or the future state.

It's hard, but we'll make it.

bitcoincore development – Bitcoin to use in bulk for payments – how feasible is this without real privacy?

Bitcoin is considered by many as a means of payment, just like the Fiat currencies in the future. Apart from the other big use case of a stable supply of value.

The payment application case is currently very flawed. From the day someone makes a payment and displays their public key, anyone (including people with malicious ideas) could begin to persecute that person, based on their public key, on the Blockchain for the rest of their lives. Anyone who uses BTC payments would sit "naked in a glass cup".

This is a horror scenario for everyone, businesses, individuals, a dangerous property.

This is currently not possible with cash or wire transfers. Anyone can have their IBAN account number, but no one else who has your IBAN (and is not a bank clerk) can ever track you or know your financial status, and so on.

How can btc achieve mass use status as a payment method in such serious circumstances? Is privacy not required as a prerequisite for payment use case?

How do Bitcoin developers try to tackle this unsolved problem? Or do you think that this is not an important topic?

Many thanks

Development – non-Segway P2SH byte structure

I'm working on a bitcoin block explorer in golangin which I want to gather as much information about transactions as possible.
I can extract addresses from all kinds of addresses outputand mostly any kind of entranceunless I try to find it clear P2SH Documentation.
BIP16 does not say much about non-SegWit P2SH Byte structure. I have read many examples where OP_0 is the first byte as opposed to P2WPKH in P2SH and P2WSH in P2SH where the first field is scriptSigTotal length followed by 0x0/OP_0,
As far as I know, a non-Segway P2PH The address is obtained by hashing the redemption script, but I need something to anchor to, such as the 1st byte OP_0, then comes the size of the data (probably a signature), loop to find OP_TRUE followed by OP_PUSHDATA1?
But is this the unique standard format?

film – Troubleshooting the development of Portra 800

I've just done a shoot with a single role Portra 800, new from Amazon.

Time-properly developed with refilled Fuji C-41 chemistry in a Jobo 1500 tank.

I measured the film at ISO 640, spot metering for the face.

Digital recording context, same ISO setting, same recording method.

Here are some negatives from the first & # 39; part of the roll.
Negative 1 (completely unchanged)
Negative 1 (automatic color correction)
Negative 2 (completely unchanged)
Negative 2 (automatic color correction)

I literally mixed just new batches of developer, bleach, and fixer with the right amount of replenisher and starter as usual.

What on earth is happening here? Any advice would be very grateful. Thanks a lot!

Distributed Computing – Development of front-end capabilities to support backend asynchronous CQRS operations

I am developing a microservice with CQRS and event sourcing. When an event is stored in the event store, the service also currently saves the updated aggregated root as a JSON object in a separate table. So far, I have separated the writing model from the reading model (but not in separate data stores).

I want to go one step further. I would like a microservice for the writing model and another for the reading model for reasons of scalability. Each service with its own database. I want to use messaging to ensure consistency between the read and write models.

I'll look at how this approach would affect the user experience in a frontend app for this backend.

For example, suppose a user creates a post. The write service returns in good order and the user is (intentionally) immediately redirected to the page where the newly created post and its contents are displayed.

Because of the asynchronous nature of messaging, the read model may not match the write transaction, and I risk a scenario in which the read service will not yet contain the newly created mail at the time the front-end attempts to invoke it.

How is this scenario handled in a conventional / industry-standard way?

ERC20 Token Development Company – Development Coins

Developcoins is one of the best ERC20 token development company in India and providing Ethereum Token Development Services around the world. We have an industry-proven experience and a team of token developers and consultants that are good at developing ERC20 tokens and provide end-to-end custom token development solutions for all types of industry sectors.


Are Google2Google Backlinks worth further development?

Is it worthwhile developing backlinks across multiple Google platforms? Would this help / hinder your OFF-PAGE search engine optimization? Are there any setbacks that you can think about? From the point of view of link development – in this mode most webmasters start to expand their internet marketing. However, the publication of your content on the Internet is not always a link development of your website with regard to the creation / backup / optimization of this link. Backlink search engine optimization based on …

Are Google2Google Backlinks worth further development?

Android libgdx java – Game Development Stack Exchange

Question 1: Bird collapses with coin, this time the coin no longer works, but it has appeared clever. What to do with? Android java libgdx

for (int i = 0; i <coins.size; i ++) {
Coin coin = coins.get (i);

          /* if(camera.position.x - (camera.viewportWidth / 2) > coin.getPosCoin().x + coin.getCoin().getWidth()){
                coin.reposition(coin.getPosCoin().x + ((Coin.COIN_WIDTH + COIN_SPACING) * COIN_COUNT));

                //coinscore = coinscore + 1;
             if( coinscore == 1232 || coinscore == 16 )

            // coin.reposition(0);
               // System.out.println("Collided");