Hey guys

Some of you might remember a few months ago I introduced AIDIOS (Acyclic Immutable Decentralised Information Optimised Storage), a project I developed with the aim of enabling the storage and versioned access to arbitrary(non financial) data across networks like Bitcoin, Bitcoin Cash, and Litecoin. AIDIOS was built around a proprietary data protocol called KeyWeave, designed for on-chain indexing and versioning without bloating the blockchain. However the data( which was stored) leveraged multiple op_return outputs, and this does add bloat to the chain.


The response from this community in my original post was clear and thought-provoking (which I’ll get to in a minute). I originally designed the technology from the ground up, and eventually coded it all out… & it was working. Despite AIDIOS being capable of associating multiple versions of files( of any size within block limits) to a public key,  also using delta-encoding, and in my mind not breaking the rules(i.e I used op_return of 80 bytes for each output, and didn;t hijack the witness data, which is designed for signatures+public keys) it still was about putting arbitrary data on Bitcoin.


After much reflection and conversations with some developers & experienced members on the forum, I made the difficult decision to shelve AIDIOS. It was a hard choice for me, given the time, effort, and passion invested into creating a technology from scratch. In many ways I used it to get over some personal trauma with my wife's medical condition. And as a result put more effort into it than I should have!

 
Anyway taking this feedback to heart, I redirected my focus towards leveraging blockchain technology for its foundational purpose: financial transactions. ( and this was the advice of one of the members kind enough not to just shoot me down... - NotATether: I'm talking about you ) This pivot led me to start developing a new tool. This tool introduces a novel approach to managing cryptographic keys, aiming to benefit those using Bitcoin for its intended financial purposes. I understand the importance of aligning with the community's values and the core principles of Bitcoin.  

I invite you all to take a look at this new direction and share your thoughts, anyway. Maybe I’m crazy with this idea too.... However I spent so much effort and time on AIDIOS, I wanted to use the method I developed to achieve on-chain indexing, and focus that component on a financial purpose. This is what I came up with for now anyway. It’s a wallet system inspired by MAST and Taproot, which allows for messages(tweaks) to be embedded into useable blockchain addresses. It also has the ability to tweak either a private or public key. This means (with a users public key) you can create a distinct new address for them, where they can only spend the funds, once they apply the tweak(message) to their own private key( and it would only work with their private key ofc)

Anyway, he’s the new tool:
https://medium.com/@jamie.brian.gilchrist/my-new-wallet-client-txtailor-a-twist-on-cryptographic-key-tweaking-inspired-by-bitcoins-83233795feb1

And here was the original post I did on bitcointalk:
https://bitcointalk.org/index.php?topic=5472141.msg63075602#msg63075602


Here is the whitepaper for AIDIOS( which I never posted before or since, but in this document it outlines how I manipulate the generator point on the secp256k1 Elliptic Curve and this is the basis I used for txtailor idea)....:
https://www.researchgate.net/publication/376204278_AIDIOS_Acyclic_Immutable_Decentralised_Information_Optimised_Storage


And just for you guys, I’ve started up the env it was running on, so the original AIDIOS tool( which I;ve scrapped) can be found here: https://filemanagerv2.aidios.io and also the api( which I wont bother sharing the docs for)... but the UI can at least let people try what my crazy original idea was… and I’m sure any engineer can attest to getting totally blinded, and making a tool( which is inappropriate) where you still go all out, and l just focus on the making it work well…without thinking too much about IF I should be creating it at all. Anyway, I’ll turn it back off again, just wanted to make sure my post had all the context.

As others have said. In order to create an address, you first start with a secp256k1 private key, from which the public key is derived. From the public key, you can then derive the corresponding address.


This means, that the private key must exist before the public key.


However, directly answering your initial question " generating public keys only" is technically possible, but you need to work with an initial keypair. From there, you can take just the public key component, and then similar to the way Merkalised Abstract Syntax tree's work in Taproot, tweak only the public key. This can be done by modifying the generator point on the Elliptic Curve. I've written a wallet client which does this. If anyone is interested, here is the client in action.

https://medium.com/@jamie.brian.gilchrist/my-new-wallet-client-txtailor-a-twist-on-cryptographic-key-tweaking-inspired-by-bitcoins-83233795feb1

If anyone is interested, I'd be happy to explain more about exactly how this is achieved, but for those familiar with how taproot addresses are generated, will already conceptually understand what I'm doing anyway.

The limit wasn't 32MB in the begining...in version 0.1.0 of core is in open( no limit).

Fast forward to 2023...theres less chance of a ddos because of the fee's!! Lightning network is a compromise. If its offchain...lets just keep the data on central databases again?

I've ran a full node for 4 years using a small EC2 instance. It very occasionally has a hicup. This is pretty impressive low cost to run a Bitcoin mainnet node.


A few things to note, though. Since people are quoting Satoshi. He never flat out disagreed with data. He also never had a block limit in the begining. It was Hal who convinced him to do so. Also, it was temporary at 1MB...its now 20203. Due to high transaction fee's there are now 1000 shit coins!


Satoshi also explained that eventually Bitcoin will be ran by a few big data farms, and users would use thin clients. I think that future is inevitable. It is already here when considering the centralisation of mining.

Data from NFT's is stored in public keys not on chain. You can verify data existed ( supplying the preimsge) but not recover it. So it wont bloat the chain as the address contains the data already. Its true that subsequent  tx's from the wallet will likely be related to their coloured status though.


A contentious subject...but I created a protocol thst allows for storage of data on Bitcoin and many other networks. Although many disagree, there are also others who believe in the free market.

https://aidios.io

Hi everyone

Hopefully this is of some use/interest to someone.

I wrote a small article on Key Tweaking. I know many people here will be very familiar with this( having wrote the code implementing Taproot) but maybe useful to some others who never knew about the concept..

I've included links to a repo where you can render Taproot addresses with various conditions.

Hope everyone is having a great weekend so far!

https://medium.com/@jamie.brian.gilchrist/deterministic-nature-of-bitcoin-addresses-the-existence-of-condition-specific-wallets-9dc1ee2efb9a

Yes, that's right. Here is something to get you started in Python(I've tested with P2PKH, and it works ok). Please flesh it out.


# Identify the type of Script
# Only tested with P2PKH, please do for others
def identify_script_type(script_hex):
    script_bytes = bytes.fromhex(script_hex)

    # A P2PKH
    if script_bytes[:3] == b'\x76\xa9\x14' and script_bytes[-2:] == b'\x88\xac' and len(script_bytes) == 25:
        return "P2PKH (Pay-to-Public-Key-Hash)"
   
    # A P2SH
    elif script_bytes[:2] == b'\xa9\x14' and script_bytes[-1] == 0x87 and len(script_bytes) == 23:
        return "P2SH (Pay-to-Script-Hash)"
   
    # A Null Data (OP_RETURN)
    elif script_bytes[0] == 0x6a:
        return "Null Data (OP_RETURN)"
   
    # A Bare Multisig (assuming there is a small number of pubkeys)
    elif script_bytes[0] in range(0x51, 0x53) and script_bytes[-1] == 0xae:
        return "Bare Multisig (No wrapper)"
   
    # A P2WPKH&P2WSH
    elif script_bytes[0] in [0x00, 0x51]:
        if len(script_bytes[1:-1]) == 0x14:
            return "P2WPKH (Pay-to-Witness-Public-Key-Hash)"
        elif len(script_bytes[1:-1]) == 0x20:
            return "P2WSH (Pay-to-Witness-Script-Hash)"
   
    # A P2TR
    elif script_bytes[:2] == b'\x51\x20':
        return "P2TR (Pay-to-Taproot)"
   
    else:
        return "Unknown/Non-standard type"

# Use :
script_hex = "76a914a5d14911b042d61db6bff26b0e12f82b2aa590af88ac"
script_type = identify_script_type(script_hex)
print("Script Type:", script_type)

Hi there


I can help you out with that. I did the calculation on my end and derived the same address as you got from Blockchair: 1G7mD4PK42vKF8bDEvi93peFwmFpSZuzuJ

Let me explain the process:

First we need to extract the Public Key Hash from the scriptPubkey. The scriptPubkey is in this format:

OP_DUP OP_HASH160 <PubKeyHash> OP_EQUALVERIFY OP_CHECKSIG

We need to strip out the PubKeyHash. Which in your key would look like:
76a914 <PubKeyHash> 88ac


Next we shall create the address:

Address is derived from the <PubKeyHash> as follows:

- Add a version prefix (0x00 for mainnet P2PKH addresses) to the <PubKeyHash>.
- Calculate the double SHA-256 hash of the prefixed <PubKeyHash>.
- Take the first 4 bytes of this hash as the checksum.
- Concatenate the checksum to the prefixed <PubKeyHash>.
- Encode the result in Base58 to get the Bitcoin address.


Here's a small python script for you that will do what you need

from hashlib import sha256

def base58_encode(data):
    """
    Encode bytes into a base58-encoded string
    """
    alphabet = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
    n = int.from_bytes(data, 'big')
    res = []
    while n > 0:
        n, r = divmod(n, 58)
        res.append(alphabet[r])
    res = ''.join(res[::-1])
    czero = 0
    pad = 0
    while czero < len(data) and data[czero] == 0:
        pad += 1
        czero += 1
    return alphabet[0] * pad + res

def script_pub_key_to_address(script_pub_key):
    """
    Convert a ScriptPubKey to a Bitcoin address
    """
    # Extract the PubKeyHash
    pub_key_hash_hex = script_pub_key[6:-4]
    pub_key_hash_bytes = bytes.fromhex(pub_key_hash_hex)

    # Add netowkr prefix (0x00 for mainnet P2PKH)
    version_prefixed = b'\x00' + pub_key_hash_bytes

    # Double SHA256
    checksum = sha256(sha256(version_prefixed).digest()).digest()[:4]

    # Concatenate and encode Base58
    address_bytes = version_prefixed + checksum
    address = base58_encode(address_bytes)
    return address

# How to use
script_pub_key = "76a914a5d14911b042d61db6bff26b0e12f82b2aa590af88ac"
address = script_pub_key_to_address(script_pub_key)
print(address)

Hi

Thanks for sharing your ECDSA variant.

It's interesting to see how the nonce  k is derived using the message hash and how the precomputed tables contribute to the signature generation process too.

I understand that the random.randrange function is used for creating new tables every time a transaction is signed, introducing an element of non-determinism in the signatures. This means that the same message and private key can yield different signatures though, which might be undesirable in certain contexts.

Offline signing( not even using the node at all) is a good approach anyway, so it's  already pretty secure.  

Hi guys

Sorry for the delay, I was away for a few days.

Thanks for the feedback, I do appreciate it.

 I do understand that Bitcoin isn't a general storage solution. AIDIOS works across multiple blockchains anyway, and so impact is mitigated. Additionally, I did create this tool to be useful and help people. It may appear from the website like an enterprise, but it's my attempt at promoting a bit.

In the original version( and one available online now) there is a basic file manager( dealing with binary data of any kind) and another microservice which then enabled a CRUD system( with UUID tracked in a postgresdb), where record updates( via GraphQL or REST) were versioned, and used diff-based updates. However I have since finished work on a new version which includes binary delta encoding, and it's backwards compatible with the other microservice. In the new version there is no need for any databases to achieve versioning. I don't use Taproot witness data(yet), but plan to investigate more.

However(on a high level) I use a process of key-tweaking for generating version specific indexing.

- File Storage with Versioning:
- The user specifies a public key, file, and version number.
- The system tweaks the public key using the version number to generate a unique address.
- The file is stored at this tweaked address, effectively linking the file version to the tweaked address.
- File Retrieval with Versioning:
- To retrieve a file of a specific version, the user provides the public key and version number.
- The system tweaks the public key using the version number to find the corresponding address.
- The file is retrieved from this tweaked address.



I'm  going to try and find some financial related purposes( useful & appropriate)for AIDIOS as suggested. For now it'll just be more development work and research for me. 

Hello everyone,

Sorry for the delay. I was away for a few days.

Thank you for your  observations and clarifications. You're correct of course, and I appreciate the insight provided here. It seems I had mixed up the encoding formats. Your detailed responses have helped clarify the matter.

Finding a suitable Bech32m library indeed presented a challenge, prompting me to improvise a bit by hardcoding the Bech32m constants into the existing Bech32 encoding scheme. It's a workaround, but it served the purpose for the task at hand.

I've added a collection of tools to a GitHub repository which allows users to generate a Taproot address, tweak public keys, and set spending conditions.

For anyone interested( I hope useful to some folks)

https://github.com/test-sum/taproot-tools

Hi everyone,

I've been experimenting with deriving a Taproot Bech32m address using Bitcoin Core 0.22.1 and noticed something interesting. It seems that Blockstream's explorer on testnet3 is still displaying addresses in the Bech32 format.

I sent a transaction earlier today to fund the wallet for testing the preimage condition.

Bech32m Transaction:


However, when I checked the transaction on Blockstream's explorer, the address was shown in the Bech32 format.

Blockstream Explorer (Bech32):


I understand that updating explorers might not be the top priority, and I'm not raising this as a complaint. I used to run my own block explorer in the past, but lately, I've been using online services for convenience.

I'm curious about how the Taproot rollout has been going overall. I'm genuinely impressed with the careful thought, planning, and execution behind it. Taproot seems like one of the most significant changes I've witnessed in Bitcoin, and I'm just starting to explore the exciting possibilities it brings with its added functionality and privacy features.

Would love to hear your thoughts and experiences with the Taproot upgrade.

Thank you for your feedback and insights. I genuinely value your perspective and understand the concerns raised.


Firstly, it's crucial to note that Bitcoin and especially Bitcoin Cash, with its 220-byte OP_RETURN and 32MB block size, have been historically leveraged for various use-cases beyond just a currency already. - Proof-of-existence (PoE), timestamping, and other projects like Memo.cash, to name a few.

I want to clarify unequivocally: the goal of AIDIOS is not to turn Bitcoin into a data warehouse/cloud storage on any level!. Instead, it's about harnessing the blockchain's innate attributes to store a slightly more enriched set of data. When I say "enriched," I'm referring to, perhaps, an extra 1KB. This 'little extra' can transform the way we look at data on the blockchain - from disjointed, fragmented pieces to a more contextual and meaningful whole.

The term "arbitrary" can be misleading. What might seem arbitrary to one may hold immense value to another. The data AIDIOS aims to accommodate on the blockchain is by no means frivolous. It's structured, significant, and valuable.


It's also worth considering the broader ecosystem too. While there are genuine concerns about the growth of the Bitcoin blockchain, we must also consider the future. Incentivizing people to run full nodes is vital for Bitcoin's decentralisation. Right now, many do it to support the network or facilitate mining. But as we progress, we must explore other avenues of incentives.


I acknowledge that my initial presentation of AIDIOS might not have conveyed its true intent, and for that, I apologise. My objective was to demonstrate its resilience and flexibility. But I hear the community's feedback loud and clear, and I'll be adjusting the testable limit to 1KB to address these concerns.


Bitcoin, undoubtedly, is the pillar of the cryptocurrency world. Its success reverberates across the entire ecosystem. While there are other networks tailored for data anchoring and pairing with systems like IPFS, the trust and security that Bitcoin provides are unparalleled.

Lastly, considering smart contracts and potential Taproot-enabled functionalities, the synergy between on-chain storage via AIDIOS and these advanced features becomes even more evident. Envision scenarios where a smart contract on Bitcoin requires a single source of truth, or where the world turns to a decentralised, immutable ledger for verifiable facts. These aren't just lofty ideas; they're tangible use-cases that can redefine how we see value and truth across many systems.


Again, thank you for your feedback so far.

Hi Guys

Hope everyone is doing well!

I'm excited to share something I've been working on : AIDIOS (Acyclic Immutable Decentralised Information Optimised Storage - inspired by the Greek word for "Eternal") https://aidios.io

Navigating through Bitcoin's architectural layers, I've always been fascinated by its use cases(both current, and future). However, the constraints on data storage, specifically the 80-byte limit on Bitcoin and 220 bytes on Bitcoin Cash, often leave us with fragmented, context-deprived information(when used for timestamps,  hash as a proof etc)

AIDIOS is my humble attempt to navigate these waters.  This system isn't about converting Bitcoin into a data haven but rather about smartly harnessing its attributes to store structured information, such as JSON. This endeavour is to preserve the contextuality of data, ensuring its coherence even within the network’s inherent limitations.

Here's why I believe AIDIOS might interest you:

Efficient Data Segmentation: It respects Bitcoin's structural constraints, ensuring that the richness of data context doesn't burden the network.
Context Preservation: It elevates simple timestamping to a methodology that maintains the integrity and verifiability of comprehensive records.
Cost-Effective Approach: On Bitcoin Cash, AIDIOS is a wallet-friendly option, costing approximately £0.07 per KB, making secure, immutable data storage accessible.

Eager to learn from your insights and experiences. AIDIOS is a stepping stone, and your critiques, suggestions, and discussions are the catalysts for its refinement.

I invite you to delve into AIDIOS, explore its inner workings, challenge its premises, and explore with me.  For a deeper dive, my journey so far and to try Aidios, checkout  https://aidios.io

You can try the API(REST and GraphQL, along with web tools) all out on the website above:


As well as the documentation on the website above, I did a small medium article, where I explain a bit more and provide a quick intro(below)

https://medium.com/@jamie.brian.gilchrist/ive-developed-the-world-s-only-data-protocol-that-can-handle-direct-structured-and-versioned-data-9d65942a8b1e

Just a thought expirement. I am working on this:
https://github.com/flavacoin/community-coin-project

It's early days for now...but we have a small community built up so far( on discord). Always happy to bring on new members who want to help shape what we become. This is simply a community coin which will be distributed among all who take part. The early miners all contribute their gains to a communal  pot, to be dispensed to those who are unable to mine themselves..for whatever reason.

Are you the kind of person who wants to build new things? Are you the type of person who has great ideas but no one to listen to them?

www.flavacoin.com
 

The new name for cat sanctuaries everywhere! 😁

I'd say they are mutually inclusive.

Take an analogy of a computer algorithm/ cool application  as an example:

Working smarter: we could take that to mean using deep learning or other recursive data analysis to determine how/what we look for. The "why" in our work. This phase might mean many other algorthims might get use quicker or be adopted by more people before our in this hypothetical example. This is an architecture heavy, engineering light approach, I guess.

And working harder: to mean the application of iterations or intensity on work.( I think intensity would make more sense).

So the fundamental difference would not be in whether you use "hard" work or "smart" work...it would be at what stage of your goal achievement process do you utilise either and in what proportions. Hard work is always essential...but not if it's detremenal.

For example, once you've mastered how to achieve your end result quicker or in some way better( which will involve a lot of upfront architectural design...lot of analysis and trial/error etc....) You can then apply hardwork to great result.

If you apply that hardwork too early, without fully understanding, you will always be comprised in some way...running in less than ideal circumstances. This could either cause you to only achieve X versus Y, or it could cause you to fail all together.

Hi guys

I've been a long time lurker on this forum( for much longer than I'd like to admit). However I wanted to actually register and say hello.

I'm an engineer and generally love any and all tech. I'm most happy when I'm trying to understand a new technology or set of principles, or generally tinkering with things and trying to understand them.


 I've been pretty dedicated recently to blockchain and smart contracts systems, and how I may utilise these in novel and useful ways( things like tying in-game assets to tokens*which is kinda already done with cryptokitties...check that out if you haven't already* but I had new ideas in that regard or qualification verification systems which utilise the same mechanisms to achieve decentralisation from the vendor specific databases).

Like everyone I have lots of "ideas", but for the most part they usually stay as just that "ideas". I've thought long and hard about why that is...sometimes it's because the idea isn't actually good...sometimes it has no market...isn't novel...doesn't help people etc etc and other times is probably down to me and a lack of dedication or skill( or combination of both). ...However other times I feel it's due to the fact that people on their own are really up against it when they have truly great ideas...because they( ideas of any real scope) take a whole host of people to bring to life.


Anyway, with that in mind I just wanted to ask you guys....if you had a community of people who were actively trying to help you achieve goals( which will be common ones).... What would you try to pitch? It doesn't have to be anything to do with crypto ofc...

I am a firm believer that there are great minds and ideas everywhere at any given moment and time. Sometimes these ideas go unnoticed, however there are people( who often times lack the ability to come up with amazing ideas) who have the skills to put these things into doing( or atleast create the beginings...the concepts.)

I"m writing on my phone so I apologize for any typos( always harder to spot with autocorrections too don't you agree? 🧐)

The TLDR was: If you had a community of open minded people( who had both the minds and resources within reason) to help you bring your vision to fruition....what would you contribute or pitch to them?

Hope everyone is having a great weekend btw!

Flava

Subject :Proof of cat (POC)

Author: Flava
Updated 5th March 2021
Let me tell you a tail.

What is proof of cat (poc)?:

The 'Proof of cat' (PoC) concept states that a person(s) can mine or validate block transactions according to how many cats he or she holds(or can put up for validation). This means that the more cats owned by a miner, the more mining power he or she has.

KEY TAKEAWAYS:

With Proof of cat (PoC), meow miners can mine or validate block transactions based on the amount of cats a miner holds( aka their stake in cats).
Proof of cat (PoC) was created as an alternative to Proof of Work (POW), which is the original consensus algorithm in Blockchain technology, used to confirm transactions and add new blocks to the chain.  Proof-Of-Cat can be considered the next evolution of that.
Proof of Work (POW) requires huge amounts of energy, with miners needing to sell their coins to ultimately foot the bill; Proof of cat (PoC) gives mining power based on the percentage of cats held by a miner.
Proof of cat (PoC) is less risky in terms of the potential for miners to attack the network, as it structures compensation in a way that makes an attack less advantageous(or even possible) for the miner( think crazy cat lady maintenance).

Understanding Proof of cat (PoC):

I created Proof-of-Cat(PoC) as an alternative to the proof of work (PoW) consensus mechanism, to tackle inherent issues in the latter. When a transaction is initiated(in POW model), the transaction data is fitted into a block with a maximum capacity of 1 megabyte, and then duplicated across multiple computers or nodes on the network. The nodes are the administrative body of the blockchain and verify the legitimacy of the transactions in each block. To carry out the verification step, the nodes or miners would need to solve a computational puzzle, known as the proof of work problem. The first miner to decrypt each block transaction problem gets rewarded with coin. Once a block of transactions has been verified, it is added to the blockchain, a public transparent ledger.

Mining requires a great deal of computing power to run different cryptographic calculations to unlock the computational challenges. The computing power translates into a high amount of electricity and power needed for the proof of work consenus system.

The proof of cat (PoC) seeks to address this issue by attributing mining power to the proportion of cats held by a miner. This way, instead of utilizing energy to answer PoW puzzles, a PoC miner is limited to mining a percentage of transactions that is reflective of his or her ownership of cats. For instance, a miner who owns 3% of the total number of cats available can theoretically mine only 3% of the blocks.

The first cryptocurrency to adopt(and develop) the PoC method is, MeowCoin. I expect it to spread like wildfire. I also expect(as a by product) many more cats to find loving homes(in the short-medium term)  and (in the longer term) to be subjected to caged, datacentre based, accomodation. In any case I see this as the solution to the age old consensus issue, and would alleviate our rampant power consumption woes. It's also a useful way to generate passive income from an otherwise 'freeloading' animal. Puuurfect!

 Proof-Of-Cat   51% attack protection:
 
With a PoC consensus model,  the attacker would need to obtain 51% of the total number of cats in circulation!! The proof of cat avoids this ‘CATastrophie’ by making it disadvantageous for a miner (with an equivalent of 51% of all cats) to attack the network. Although it would be difficult and expensive to accumulate 51% of any reputable digital coin anyway , a miner attempting to achieve 51% of all cats to use as a POC, would be very busy..errr ...looking after cats..being meowed at....that type of thing. I've ran some (pretty advanced) calculations and predict that 51% of all cats would occupy ' a fuck tonne' of space. 

Please look out for my whitepaper ' Proof-Of-Cat consensus mechanism', which will go into details of the technical specifics of Proof-of-Cat. 

Have a great weekend folks!
Flava