How the Collection Works

How Bitcoin Nouns came into existence and how we made it happen.

A New Noun, A New Bitcoin Noun

With the birth of each Noun comes the opportunity to etch its identity onto the Bitcoin Nouns collection. As the Ethereum-based Nouns march into the future, a new Bitcoin Noun is inscribed daily, enriching the collection with each unique creation. To be a part of this journey, explore the marketplace and seize the chance to immortalize a Noun on the Bitcoin blockchain.

Or, if you are ambitious, maybe you can inscribe today's Bitcoin Noun?

The original Nouns (from Nouns.wtf) inscribed on Bitcoin.

Minting Bitcoin Nouns

Between February 5, 2023 and March 24, 2024, approximately 200 Nouns were inscribed by roughly 100 people. Then, on March 24, 2024, the community was organized and, within two days, inscribed all existing Nouns to Bitcoin as Ordinals. All existing Nouns were inscribed to Bitcoin by March 26, 2024. Since that day, each new Noun has been quickly inscribed and included in the Bitcoin Nouns collection.

>> Inscribe a Bitcoin Noun

Only the first-version inscriptions of each Noun are included in the Bitcoin Nouns Magic Eden collection. First is first. To learn more about our mission, check out this short thread on Twitter.

The "First Inscription" simply means the earliest inscription. For the Bitcoin Nouns collection, the First Inscription is inscription 3901, WTF, that's early.

Bitcoin Nouns' first inscription, Inscription #3,901, on ordiscan.

How First Inscriptions are Identified

To identify the First Inscriptions, we are using SHA-256 image hashes and an API from OrdinalsBot. Comments and code reviews are welcomed. Here's an overview of the process, including the code that was used:

1. What the Code Does: This Python script below automates the process of comparing image files to existing Bitcoin inscriptions stored on the blockchain. It does this by calculating a unique identifier called a SHA-256 hash for each image and then using this identifier to search for similar patterns in the database through an API.

2. SHA-256 Hash: The SHA-256 hash is like a unique fingerprint for each image. It takes the raw data of the image and converts it into a fixed-length string of characters. Even a tiny change in the image would result in a completely different hash. So, it's a reliable way to compare images byte by byte.

3. Comparing Images to Bitcoin Inscriptions: Bitcoin inscriptions are essentially records stored on the Bitcoin blockchain. These records can contain various types of data, including images. The API used in the script allows us to search through these Bitcoin inscriptions by providing their unique identifiers or hashes.

4. API Interaction: The script sends the SHA-256 hash of each image to the API, which then looks for similar hashes in its database of Bitcoin inscriptions. If it finds a match, it means that there's an identical image already recorded in the Bitcoin blockchain. This process helps determine whether the image being analyzed is unique or if it's already associated with a Bitcoin inscription.

5. Updating an Excel Spreadsheet: The script keeps track of its findings by updating an Excel spreadsheet. It records details such as the filename of the image, any related Bitcoin transaction IDs (TXIDs), and other relevant information obtained from the API. This spreadsheet acts as a logbook of the analysis results.

6. Moving Processed Files: Once an image is processed and its information is recorded, the script moves the image file to a separate folder called "Processed Successfully." This step ensures that the script doesn't repeatedly analyze the same image.

7. Additional Information: For further context and reference, the script also adds hyperlinks in the Excel spreadsheet to external websites like "Nouns.wtf" and "Ordiscan." These links provide additional information about the Bitcoin inscriptions or related content.

In essence, the script serves as an automated detective, using SHA-256 hashes to compare the original Nouns images to existing Bitcoin inscriptions and keeping track of its findings in an Excel spreadsheet. This process helps identify unique images and their associations with the Bitcoin blockchain.

Here's the Python code that is used to determine First Inscriptions:

#!/Python310/python.exe

import os
import shutil
import requests
import hashlib
import json
import time
from datetime import datetime
from openpyxl import Workbook, load_workbook
from openpyxl.utils import get_column_letter
from openpyxl.styles import Font
from openpyxl.utils.cell import coordinate_from_string

def calculate_sha256(filename):
    sha256_hash = hashlib.sha256()
    with open(filename, "rb") as f:
        for byte_block in iter(lambda: f.read(4096), b""):
            sha256_hash.update(byte_block)
    return sha256_hash.hexdigest()

def search_ordinals(hash_value, filename):
    url = "https://api.ordinalsbot.com/search"
    params = {'hash': hash_value}
    headers = {'x-api-key': 'xxxxx'}
    
    try:
        response = requests.get(url, params=params, headers=headers)
        time.sleep(0.5)  # Add a delay of 0.5 seconds
        data = response.json()
        
        if response.status_code == 200 and data.get('results'):
            # Extract results
            results = data['results']
            
            # Sort results based on 'inscriptionnumber' and 'createdat'
            sorted_results = sorted(results, key=lambda x: (int(x.get('inscriptionnumber', float('inf'))), x.get('createdat', '')))
            
            # Select the first result (with lowest 'inscriptionnumber' and earliest 'createdat')
            result = sorted_results[0]
            
            result_data = {
                "filename": filename,
                "txid": result.get('txid', ''),
                "inputindex": result.get('inputindex', ''),
                "inscriptionid": result.get('inscriptionid', ''),
                "inscriptionnumber": result.get('inscriptionnumber', ''),
                "blockheight": result.get('blockheight', ''),
                "contenttypestr": result.get('contenttypestr', ''),
                "contenthash": result.get('contenthash', ''),
                "contentlength": result.get('contentlength', ''),
                "createdat": result.get('createdat', '')
            }

            return result_data
        else:
            return {
                "filename": filename,
                "hash_not_found": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
                "contenthash": hash_value
            }
    except Exception as e:
        return {
            "filename": filename,
            "error": f"An error occurred: {e}"
        }

def main():
    image_files = os.listdir("images")
    if not image_files:
        print("No image files found in the 'images' directory.")
        return

    if os.path.exists("results.xlsx"):
        workbook = load_workbook("results.xlsx")
        sheet = workbook.active
    else:
        workbook = Workbook()
        sheet = workbook.active
        sheet.append([
            "Filename", "TXID", "Input Index", "Inscription ID", "Inscription Number",
            "Block Height", "Content Type", "SHA-256 Hash", "Content Length", "Created At", "Hash Not Found",
            "Last Updated At", "Nouns.wtf Link", "Ordiscan Link"
        ])

    for filename in image_files:
        file_path = os.path.join("images", filename)
        hash_value = calculate_sha256(file_path)
        print("Processing file:", filename)

        existing_row_index = None
        for idx, row_data in enumerate(sheet.iter_rows(values_only=True), 1):
            if row_data[0] == filename:
                existing_row_index = idx
                break

        result = search_ordinals(hash_value, filename)
        if "error" in result:
            print(result["error"])
            if existing_row_index is not None:
                sheet.cell(row=existing_row_index, column=11).value = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            else:
                sheet.append([filename, "", "", "", "", "", "", "", "", "", result["hash_not_found"], ""])
            workbook.save("results.xlsx")
            continue

        if existing_row_index is not None:
            sheet.cell(row=existing_row_index, column=2).value = result.get("txid", "")
            sheet.cell(row=existing_row_index, column=3).value = result.get("inputindex", "")
            sheet.cell(row=existing_row_index, column=4).value = result.get("inscriptionid", "")
            sheet.cell(row=existing_row_index, column=5).value = result.get("inscriptionnumber", "")
            sheet.cell(row=existing_row_index, column=6).value = result.get("blockheight", "")
            sheet.cell(row=existing_row_index, column=7).value = result.get("contenttypestr", "")
            sheet.cell(row=existing_row_index, column=8).value = result.get("contenthash", "")
            sheet.cell(row=existing_row_index, column=9).value = result.get("contentlength", "")
            sheet.cell(row=existing_row_index, column=10).value = result.get("createdat", "")
            sheet.cell(row=existing_row_index, column=11).value = result.get("hash_not_found", "")
            sheet.cell(row=existing_row_index, column=12).value = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        else:
            sheet.append([
                result["filename"],
                result.get("txid", ""),
                result.get("inputindex", ""),
                result.get("inscriptionid", ""),
                result.get("inscriptionnumber", ""),
                result.get("blockheight", ""),
                result.get("contenttypestr", ""),
                result.get("contenthash", ""),
                result.get("contentlength", ""),
                result.get("createdat", ""),
                result.get("hash_not_found", ""),
                datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            ])

        # Add hyperlink for 'Nouns.wtf Link' column
        hyperlink_cell_nouns = sheet.cell(row=sheet.max_row, column=sheet.max_column - 1)
        hyperlink_cell_nouns.value = f"Nouns Link"
        hyperlink_cell_nouns.font = Font(underline="single", color="0563C1")
        hyperlink_cell_nouns.hyperlink = f"https://nouns.wtf/noun/{os.path.splitext(filename)[0]}"

        # Add hyperlink for 'Ordiscan Link' column
        if result.get("inscriptionnumber"):
            hyperlink_cell_ordiscan = sheet.cell(row=sheet.max_row, column=sheet.max_column)
            hyperlink_cell_ordiscan.value = f"Inscription {result.get('inscriptionnumber')}"
            hyperlink_cell_ordiscan.font = Font(underline="single", color="0563C1")
            hyperlink_cell_ordiscan.hyperlink = f"https://ordiscan.com/inscription/{result.get('inscriptionnumber')}"

        workbook.save("results.xlsx")
        print("Results saved to results.xlsx")

        if "txid" in result:
            os.makedirs("Processed Successfully", exist_ok=True)
            shutil.move(file_path, os.path.join("Processed Successfully", filename))
            print(f"File '{filename}' moved to 'Processed Successfully' folder.")

    print("\nDetailed Results:")
    for row in sheet.iter_rows(values_only=True):
        print(row)

if __name__ == "__main__":
    main()