0.17.0-beta.0

Blockchain Support

• The Bitcoin Computer now supports BTC in addition to LTC

Expressive Power

• This release adds support for all data structures that are built up recursively from basic types, arrays and objects. This makes it possible to use advanced data structures like lists, queues, stacks, tries, trees, graphs, bloom filters and others in smart contracts. The execution cost is still independent from the complexity of the algorithm and the computational overhead is still constant. The Bitcoin Computer is the only smart contract system with these important properties.

Testing

• We have tested the Bitcoin Computer with tens of thousands of randomly generated Javascript programs. These programs create large complicated data structures and we have verified that the Bitcoin Computer evaluates all of them exactly like other Javascript runtimes.

Security

• We are working on a formal security proof that shows that the security properties are met. We have reorganized our security related tests following the structure of the proof. We have detected and fixed many bugs in the process.

Applications

• The new block explorer package allows a user to:

  • Deploy an ES6 module as a smart contract on BTC and LTC
  • Create a new smart object from a smart contract
  • Read the state of a smart object for which the user has read permissions, and
  • Update the state of a smart object for which the user has write permission.

• A Bitcoin and Litecoin wallet to store cryptocurrency and on chain assets, that includes

  • Select the blockchain (BTC and LTC) and network mode (mainnet, testnet, regtest)
  • Login using BIP39 mnemonic
  • Show the balance
  • Send and receive transactions and view sent and received transactions
  • View and update all smart objects owned by the wallet

0.16.0-beta.0

This release gives the programmer more fine grained control over the transactions that are built from the smart contracts. This makes it possible to implement advanced smart contracts like swaps and exchanges. It also enables building applications that integrate with other smart contract protocols like ordinals and inscriptions.

Library

• Our ES6 module system is now based on the inscription protocol. We provide a simple way to read and write inscriptions from the browser. Each ES6 module can now store up to 4 MB at a 4x lower cost and modules of arbitrary size can be exported by importing one module into another.
• The order of inputs and outputs of a transaction can now be determined by the smart contract. This allows you that to build smart contracts that work for both the Bitcoin Computer and the Ordinals protocol.
• Signing parameters can be provided when calling a function to give you control over which inputs to sign and which signature and sighash type to use. This enables applications in which one user signs only a part of a transaction and another changes the part that was not signed.
• Partially signed transactions can now be created from function calls by passing in mocked up smart objects. This enables smart contracts in which not all objects are known when part of the transaction is created, for example when selling an asset to any buyer.
• The funding mechanism can now be configured to include or exclude specific UTXOs according to user preferences.
• We now support a wider class of data structures called directed acyclic graphs (DAGs). Until now, we only supported tree-shaped data structures. DAGs enable many natural smart contracts amplifying the library's expressive power.
• The fee paid to the miners can now be controlled by passing satoshi per byte and dust relay fee settings to the computer constructor.
• You can inspect the effect of a function call before committing the update by broadcasting a transaction. The transaction can be broadcast with arbitrary delay. When the transaction is eventually broadcast the state update will either be exactly as predicted, or there will be no state update whatsoever and an error is thrown.
• Smart objects now contain the version number of the software that created them.
• Updated the docs to version 0.16

0.15.0-beta.0

Library

• Implemented a new format for revisions: we are now using the syntax txId:outputIndex to better integrate with the ordinals ecosystem and simplify the usage of revisions in URL query strings.
• Updated the computer.fund() function to accept an array of revision strings instead of an array of UnspentOutput objects for the include and exclude parameters. This way users do not need to create UnspentOutput objects.
• Modified the type of computer.getUtxos() to return an array of revisions (string[]) instead of an array of UnspentOutput objects.

Node

• Upgraded to Litecoin version 0.21.2.2.
• Added a new index to the database for querying by module specifier.
• Enforce that off-chain data is communicated only via https between the node and the client.

Open Source Projects

• Optimized page loading behavior.
• Refactored the user interface.

NFT

• More work on creating and accepting offers for NFTs.
• The offers are sent thought the Bitcoin Computer off-chain solution to reduce the fees.
• Enabled non-logged-in users to view all NFTs.
• Optimized page loading behavior.

Docs

• Improved documentation for computer.fund() and computer.getUtxos().
• Added examples for querying by module specifier.

0.14.1-beta.1

Library

• Add a new way of querying for smart objects by module specifier

const mod = await computer.export(`export const x = ${Math.random()}`)
a = await computer.new(A, [], mod)
const revs = await computer.query({ mod })
expect(revs.length).eq(1)

• Fix bug in off-chain storage and encryption
• Run integration and unit tests with all bundles
• Consolidate tsconfig files
• Fix bug in _root computation
• More work on Readme files

Node

• Ensure that the node resumes synchronization where it left off on restart
• Add daily rotation of log files

NFT app

• Include an script for deploying smart contracts
• Import smart contracts from modules
• Start adding trustless trading
• Start adding royalty payments and offers
• UI/UX improvements

0.14.0-beta.0

• Add experimental support for ordinals
• Prevent assignment to this outside function calls to enhance security
• Fix auth verification from docker container health checks.
• Add support for Litecoin mainnet
• Add unit tests for trustless trading
• Add unit tests for sending NFTs with royalty payments
• Open source projects can now easily launched with npx
• Refactor all open source projects
• Improve documentation

0.13.4-beta.0

New features

• New low level interface for advanced features like off-chain signing and server side funding
• Support for ES6 module system to decompose smart contracts and enable library functions
• Simplified query interface to the Bitcoin Computer Node
• New browser bundle for distribution to CDNs
• More work on the BRC721 contract
• Internal security audit revision

0.10.0-beta.3

Move existing codebase to monorepo.

• Simplified and reduced fees. We are now charging exactly the same amount as miners per transaction. This makes it easier for users to estimate the fees for using the Bitcoin Computer.
• Refactored the two lower levels of our stack. We are trying to get all compatibility breaking changes out of the way before we publish a "long term support" version.
• Made it easy to query the RPC interface of the Bitcoin node.
• Refactored the database schema, improved typing, simplified the architecture, and cleaned up the entire code base.
• Upgraded to the latest version of Litecoin, litecoind 0.21.
• Much better error handling and logging.
• Both lib and node are now ES6 modules for increased efficiency (eg tree-shaking), better testability, and easier integration into the modern JS ecosystem.
• Improved scripting: migrated from Bash to Python.