Mint Physical Bitcoin

Make bits of bitcoin physical with The Bitcoin Mint. Our minting standard is open source and permanently inscribed under Satoshi # 1632665171305931. You can copy and run the code in any Jupyter notebook to test it for yourself.

How it Works

• 🌿Create or find a natural standard—an object with a unique natural pattern that can’t be replicated.
• ⬆️Upload an image of your natural standard to The Bitcoin Mint’s minting script.
• 💻The minting script will read the unique features of the object in your natural standard and translate it into a receive-only bitcoin address.
• 📡Broadcast your minting transaction to the network by sending bitcoin to that address.
• 🔗The bitcoin in the transaction becomes physical once the network confirms the transaction is forever added to a block in the Bitcoin Blockchain.
• ✅To confirm and verify, simply run the natural standard on the minting script to see if it generates the same address recorded on the blockchain. If it does, you know that the bitcoin at the address will never leave because no private or public key was used to generate it. And the bitcoin permanently ascribed to that destination can only ever be translated into your physical object.

Minting Script

Upload your natural standard and generate a 1BtcMint address below.

!pip install opencv-python==4.8.0.76 opencv-contrib-python==4.8.0.76 base58==2.1.1 numpy==1.26.4

import cv2
import numpy as np
import hashlib
from matplotlib import pyplot as plt
import binascii
import base58  # Ensure this import is included

def compute_sift_features(image_path):
    image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
    if image is None:
        raise ValueError("Image not loaded properly")

    # Histogram equalization for lighting normalization
    image = cv2.equalizeHist(image)

    # Adjust SIFT parameters for better robustness
    sift = cv2.SIFT_create(contrastThreshold=0.04, edgeThreshold=10, nfeatures=200)

    keypoints, descriptors = sift.detectAndCompute(image, None)
    if descriptors is None:
        return np.array([]), []

    feature_vector = descriptors.flatten()
    return feature_vector, cv2.drawKeypoints(image, keypoints, None)

def generate_feature_vector_hash(feature_vector):
    adjustment_counter = 0
    while True:
        adjusted_feature_vector = np.roll(feature_vector, adjustment_counter)
        feature_vector_bytes = adjusted_feature_vector.tobytes()
        hash_object = hashlib.sha256(feature_vector_bytes)
        hash_hex = hash_object.hexdigest()[:19]
        if '0' not in hash_hex and 'I' not in hash_hex:
            return hash_hex
        adjustment_counter += 1

def b58ec(s):
    unencoded = bytearray.fromhex(s)
    encoded = base58.b58encode(unencoded)
    return encoded.decode('ascii')

def b58dc(encoded, trim=0):
    unencoded = base58.b58decode(encoded)[:-trim]
    return unencoded

def burn(s):
    decoded = b58dc(s, trim=4)
    decoded_hex = binascii.hexlify(decoded).decode('ascii')
    check = hh256(decoded)[:8].decode('ascii')
    coded = decoded_hex + check
    return b58ec(coded)

def hh256(s):
    s = hashlib.sha256(s).digest()
    return binascii.hexlify(hashlib.sha256(s).digest())

def validate_btc_address(address):
    try:
        decoded = base58.b58decode_check(address)
        return decoded[0] == 0x00
    except Exception:
        return False

# Example usage
image_path = 'THE NATURAL STANDARD IMAGE PATH HERE'
feature_vector, image_with_keypoints = compute_sift_features(image_path)
feature_vector_hash = generate_feature_vector_hash(feature_vector)
print("Feature vector hash:", feature_vector_hash)
plt.imshow(image_with_keypoints, cmap='gray')
plt.show()

template = f"1BtcMint{feature_vector_hash}XXXXXXX"
burn_address = burn(template)
print("BTC Burn Address:", burn_address)

address_valid = validate_btc_address(burn_address)
print("Address formatting valid:", address_valid)