Opening Remarks

The Great Script Restoration Project

You're probably aware that v0.3.1 of Bitcoin disabled numerous Script opcodes, most famously OP_CAT. Bringing them back unlocks a great deal of power, and there are a few additional opcodes that complement them well in a modern Bitcoin system (such as key addition). This talk aims to present a coherent model for making Bitcoin Script as capable as I think it can be, while avoiding the pitfalls which caused it to be hobbled in the first place.

Introducing BitVMX: A CPU for Universal Computation on Bitcoin

Coming Soon!

Running the VLS on Embedded Hardware

Ken Sedgwick will discuss the goals and challenges of running the Validating Lightning Signer (VLS) on embedded hardware devices.

Chain-sync-athon

Join Hiro’s engineers to get your node synced, so you’ll be ready for building a bitcoin indexer or building on a full node for the hackathon later in the week!

Panel: Battle of the Covenants

What is a covenant? What are the challenges around adding this functionality to bitcoin? Join a panel of experts led by the legendary Jusneth as we dig into defining the different proposals for covenant updates and the tradeoffs around each of them.

secp256k1-jdk, bitcoinj, and the Bitcoin JDK ecosystem

We'll start with a look at the greater Bitcoin JDK ecosystem and a brief intro to modern (2024+), functional-style Java. We'll compare modern Java with Rust and look at how Rust libraries can be used in Java. We'll introduce the new secp256k1-jdk API and its implementation using libsecp256k1 and the Foreign Function & Memory API ("Panama"). We'll also look at the refactored bitcoinj 0.17 and beyond.

Optimistic execution of RISC-V in Tapscript

If it compiles, it can be verified in Bitcoin script. We'll show how a covenant addition to Bitcoin could power up Tapscript to enable verification of arbitrary computation, and other good stuff.

Deep dive into BIP324

BIP324 is Bitcoin's new P2P transport protocol which features opportunistic encryption, a mild bandwidth reduction, and the ability to negotiate upgrades before exchanging application messages. We'll look into the intuition behind constructing the initial v2 handshake between nodes and encryption schemes used for constructing network messages.

Covenants with CAT

Using only OP_CAT and BIP340/341 schnorr signatures, you can do a surprising amount of transaction introspection in bitcoin script. In this talk, we explore the mathematics and mechanics of the technique, and see some sample applications with code and a discussion of the tradeoffs and considerations.

Docker Run VLS

Easily setting up a configurable lightning node in cloud or local system with VLS, CLBOSS, etc. by using docker containers. SETUP REQUIRED: We need to have a docker installation on the system. Reference can be taken from official docker documentation: https://docs.docker.com/engine/install/

sigops more like sigoops

Does Bitcoin have gas fees? No but there are limits to execution built-in to the scripting system. In this talk, we’ll get into how Bitcoin measures and rate-limits CPU usage of scripts by talking about the sigops limit!

State of the Ark

Status update on development of the Ark layer-two protocol.

TXHASH, TL;DR for those not reading BIPs

A quick overview of the TXHASH covenant proposal"

Replace by Fee-Rate

Transaction pinning is potential threat to many multi-party protocols such as lightning. Yet it's also an economic exploit: miners are leaving money on the table. Here we'll look at replace-by-fee-rate, an incentives-based solution to pinning that both fixes the problem, and earns miners more money.

BitVM: Compute anything on Bitcoin

An overview of BitVM, stateful scripts using Lamport signatures and connector outputs. Particularly, trust-minimized bridges to sidechains.

Bolt12 Makes Bitcoin Digital Cash

Bitcoin aims to provide a decentralized, private, secure, and unstoppable currency. However, the Lightning Network has faced challenges in meeting these goals. We will explore how BOLT12 addresses these issues and the technical details that enable its functionality.

The Unscalability of Bitcoin

Bitcoin has lots of scalability problems, from payments to ownership, and so much more. We'll break down why bitcoin has troubles scaling and how we may or may not be able to fix it.

Treasure hunting mistakes on Bitcoin

A hands-on introduction to the use of connectors and Winternitz signatures to locate errors in a chain of hashes. This mechanism allows for challenging arbitrary computations on Bitcoin using BitVMX, paving the way for a more decentralized connection with Rootstock.

LDK: Lightning Like You Mean It

The Lightning Development Kit (LDK) lets developers efficiently build Lightning applications. LDK is a comprehensive, open-source Lightning implementation used by dozens of projects including Lightspark, Mutiny, Cash App, and BitKit. Conor Okus will outline the SDK's capabilities, LDK Node, Lightning Network services compatible with LDK, and the current development roadmap.

SV2 explained: a step towards mining decentralization

An overview of SV2: history, why, what, how, and roadmap. Also some hands-on activity where the audience sets up pools and CPU miners.

Validating Metaprotocols in Bitcoin Script w/ Covenants

Metaprotocols built on Bitcoin such as the Taproot Assets Protocol define new rules for transactions containing specific committed metadata (eg: a new leaf in the tapscript tree). A sub-class of these protocols in the client-side validation paradigm rely on special nodes that validate these transaction with auxiliary information to overlay a new consensus system on top of Bitcoin. However as Bitcoin Script isn't aware of these meta protocols, it's possible to mine a transaction that is valid for Bitcoin consensus, but invalid from the PoV of a metaprotocol. In this talk, we'll explore how we can use covenants to incrementally make Bitcoin Script aware of these metaprotocols, which unlocks the door to new scaling solution and expressibility on Bitcoin.

The State Of Bitcoin Web Development with BitScript

Lessons Learned & Insights Gained On How We'll Finally Keep Developers Around

How to build a compact Bitcoin index

One of the biggest pain points we see from developers building on Bitcoin is indexing the chain. Many devs have to maintain their own index of blockchain chainstate, which can incur high storage costs and be challenging to keep up to date. Re-orgs of chainstate happen often, and every time there’s a re-org, you have to re-index the entire chain, which can be a time-intensive process. At Hiro, we built an open source indexing engine (Chainhook) that enables anyone to build consistent, reorg-proof databases that index only the information you want— creating a lighter-weight index. In this workshop, we'll show you how to create individual "chainhooks" to filter and trigger specific actions based on on-chain events.

BitEscrow: Pioneering Non-Custodial Reversible Transactions

Escrow: the everyday, unseen guardian of almost every transaction. Discover how BitEscrow elevates crucial security with innovative, non-custodial reversible transactions — powered by our APIs and SDKs — shaping the future of Bitcoin transactions.

Miniscript Deep Dive

Presentation about Miniscript Fragments, Types, and Properties

Banking on Ark

Ark brings Bitcoin lending to reality: why would I borrow Bitcoin?

Miniscript for Developers

Diving into Miniscript doesn't have to be daunting. In this talk you'll learn the basics of the Miniscript language, the benefits of using it over traditional Bitcoin Script, and how you can use it in your own applications. I'll also share the challenges I encountered with existing Miniscript libraries and explain the motivation for developing my own.

Splice Is Nice(r) with Splice Script!

A talk about the latest “scripting” language coming to Core Lightning to help make complex splices a reality for lightning!

(Mini)Scripting in covenant world

We will discuss how complex scripting could look like with different covenant opcodes. Note: This is not an endorsement of any opcode proposal.

Quirky Covenants

A forward and backward look at the ways various covenant proposals overlap, interact, and sometimes do surprising things. We'll touch on SIGHASH_ANYPREVOUT (BIP118), OP_CHECKTEMPLATEVERIFY (BIP119), OP_CHECKSIGFROMSTACK(VERIFY), OP_VAULT(RECOVER) (BIP345), OP_CHECKCONTRACTVERIFY, and OP_CAT. Did you know that OP_VAULT is recursive? Did you know that OP_CHECKTEMPLATEVERIFY+OP_CHECKSIGFROMSTACK has many of the same benefits as SIGHASH_ANYPREVOUT and then some bonuses? Can OP_CAT alone enable Lightning Symmetry channels? These questions and more will be answered as we explore quirky covenants.

Panel: Tooling Script

The scripting landscape is quickly evolving, and along with it the tools for

Simphony: High-level Simplicity

Simplicity is the future of Bitcoin smart contracts. The language brings arbitrary computation without loops and formal correctness to the blockchain. However, Simplicity is hard to write, like Assembly. Simphony is a high-level language, like Rust, that compiles to Simplicity. In my talk, I will introduce you to Simphony and to the web IDE that runs Simphony in the browser. Start Simplicity development today on your phone!

sighash_noinput, a history

What is sighash_noinput? Where did it come from? How did it come to be known as APO? In this talk Blockstream’s Christian Decker will walk us through the the evolution of BIP118 over the years, giving us a good picture of where the proposal stands now.

Ice, Ice, Maybe? OPVAULT and reactive security for your cold storage

Locking your coins up into a vault is one proposal for updating script (OP_VAULT). How does this work and why should you

CAT, Scripts and Lamport Sigs

In 2021, Jeremy Rubin showed that it is possible to do 32-bit Lamport signatures in Bitcoin Script, without any changes to the network. This development, while independently interesting for some oracle applications, has really shown its value by its use in BitVM, an aggressively ambitious project by Robin Linus to do arbitrary computations in Script by splitting them across dozens of transactions indexing billion-entry Merkle trees. The core idea is that we can think of Lamport signatures as indexing a sort of "global key-value store" supporting single writes and erasures, where each entry has an owner. We discuss this idea, as well as how it generalizes using OP_CAT beyond 32-bit values to "real" signatures, commitments to Merkle trees, and more.

OP_EXPIRE

Why it can be useful to make outputs impossible to spend after a deadline, and how we can make this reasonably reorg safe.

Coinjoin & Bitcoin Script

Write coinjoin software and learn the scripts that help you do it

FROSTy Brews: Protocol Augmentations

A guided tour through a series of protocols that are compatible with FROST: proactive secret sharing, Taproot and BIP32 key tweaking, participant enrollment/disenrollment, share repairability, MuSig2 nesting, and adaptor signatures.

sMATT contracts, zero to hero

How to go from idea to Bitcoin smart contracts using OP_CHECKCONTRACTVERIFY

Hackathon

Hackathon

Hackathon

Hackathon

Presentations

Hackathon Awards