RandyMcMillan

Reusable taproot addresses

Abstract

This document proposes a new scheme to avoid address reuse while retaining some of the convenience of address reuse, keeping recoverability purely from Bitcoin time chain and avoiding visible fingerprint. The scheme has negligible average overhead.

Motivation

RandyMcMillan

use sha2::{Digest, Sha256};

/// Calculates the Hamming distance between two SHA-256 hashes.
///
/// This function takes two byte slices representing SHA-256 hashes and returns 
/// the number of bits that differ between them.
fn hamming_distance_sha256(hash1: &[u8], hash2: &[u8]) -> u32 {
    assert_eq!(hash1.len(), 32, "Invalid hash1 length");
    assert_eq!(hash2.len(), 32, "Invalid hash2 length");

RandyMcMillan

use sha2::{Digest, Sha256};

/// Calculates the Hamming distance between two SHA-256 hashes.
///
/// This function takes two byte slices representing SHA-256 hashes and returns 
/// the number of bits that differ between them.
fn hamming_distance_sha256(hash1: &[u8], hash2: &[u8]) -> u32 {
    assert_eq!(hash1.len(), 32, "Invalid hash1 length");
    assert_eq!(hash2.len(), 32, "Invalid hash2 length");

RandyMcMillan

use sha2::{Digest, Sha256};

/// Calculates the Hamming distance between two SHA-256 hashes.
///
/// This function takes two byte slices representing SHA-256 hashes and returns 
/// the number of bits that differ between them.
fn hamming_distance_sha256(hash1: &[u8], hash2: &[u8]) -> u32 {
    assert_eq!(hash1.len(), 32, "Invalid hash1 length");
    assert_eq!(hash2.len(), 32, "Invalid hash2 length");

RandyMcMillan

use actix_web::{get, web, App, HttpResponse, HttpServer, Responder};
use bitcoincore_rpc::{Auth, Client, RpcApi};
use serde_json::Value;

struct AppState {
    btc_client: Client,
}

#[get("/blocktemplate")]
async fn get_block_template(data: web::Data<AppState>) -> impl Responder {

RandyMcMillan

use sha2::{Digest, Sha256};

/// Calculates the Hamming distance between two SHA-256 hashes.
///
/// This function takes two byte slices representing SHA-256 hashes and returns 
/// the number of bits that differ between them.
fn hamming_distance_sha256(hash1: &[u8], hash2: &[u8]) -> u32 {
    assert_eq!(hash1.len(), 32, "Invalid hash1 length");
    assert_eq!(hash2.len(), 32, "Invalid hash2 length");

RandyMcMillan

use sha2::{Digest, Sha256};

/// Calculates the Hamming distance between two SHA-256 hashes.
///
/// This function takes two byte slices representing SHA-256 hashes and returns 
/// the number of bits that differ between them.
fn hamming_distance_sha256(hash1: &[u8], hash2: &[u8]) -> u32 {
    assert_eq!(hash1.len(), 32, "Invalid hash1 length");
    assert_eq!(hash2.len(), 32, "Invalid hash2 length");

RandyMcMillan

use sha2::{Digest, Sha256};

/// Calculates the Hamming distance between two SHA-256 hashes.
///
/// This function takes two byte slices representing SHA-256 hashes and returns 
/// the number of bits that differ between them.
fn hamming_distance_sha256(hash1: &[u8], hash2: &[u8]) -> u32 {
    assert_eq!(hash1.len(), 32, "Invalid hash1 length");
    assert_eq!(hash2.len(), 32, "Invalid hash2 length");

RandyMcMillan

use std::any::Any;
use std::fmt::Debug;

fn print_type_name<T: Any + Debug>(value: &T) {
    println!("Type of {:?} is: {}", value, std::any::type_name::<T>());
}

fn main() {
    let i: i32 = 42;
    print_type_name(&i);

RandyMcMillan

use std::fs;
use std::path::Path;

fn main() {
    let input = "/usr/share/doc";

    fn action(path: &str) { println!("\t{}" , path); }

    fn walk(path: &str) {
        println!("Listing {} ..." , path);