DEV Community: John Godwin

A Beginner's Guide to Smartcontract development on BSV

John Godwin — Mon, 20 May 2024 21:27:54 +0000

The rapid growth of blockchain technology has capture the attention of investors, technologists and everyday individuals alike, but despite it growing popularity, many people still find the concept of blockchain daunting.However, the Bitcoin SV blockchain amongst many others offers robust scalable,secure and micropayment features for enterprise, investors and developers.
Explore about the cutting edge of BSV blockchain and it key features by enrolling on BSV academy .
In this article, i will be providing you the basic introduction of smartcontract on Bitcoin SV and showing you a simple smartcontract sample with sCrypt.

What is Smart Contract?

Smartcontract is a computer program or script on a blockchain that automatically executes agreements when predetermined conditions are met. Once the conditions are met, the code executes automatically, ensuring a transparent and tamper-proof process.

Think of it like a vending machine: you put in the money (fulfill a condition), and the machine dispenses the product (automatically executes an action) without needing a middleman.

How do Bitcoin Smart Contracts work?

Smart contracts on Bitcoin are based on the UTXO model.Each bitcoin transaction consists of some inputs and outputs.

An output contains:

The amount of bitcoins (satoshis) it contains.
bytecodes (the locking script).

While an input contains:
A reference to the previous transaction output.
bytecodes (the unlocking script).

UTXO Model

UTXO stands for unspent transaction output. this is referred to the portion of bitcoin not yet spend or used as an input in another transaction.An Unspent Transaction Output (UTXO) is an output not consumed in any transaction yet. The low-level bytecode/opcode is called Bitcoin Script, which is interpreted by the Bitcoin Virtual Machine (BVM).

the image above shows and explain the concept of bitcoin UTXO model and how smartcontract works on bitcoin.In the example above, we have two transactions, each having one input (in green) and one output (in red) and the transaction on the right spends that on the left. The locking script can be regarded as a boolean function f that specifies conditions to spend the bitcoins in the UTXO, acting as a lock (thus the name "locking"). The unlocking script in turns provides the function arguments that makes f evaluates to true, i.e., the "key" (also called witness) needed to unlock. Only when the “key” in an input matches previous output’s “lock”, it can spend bitcoins contained in the output.
Now that you have gotten a good introduction on what is smartcontract and how it works on bitcoin, let's move on explaining how write smartcontract using sCrypt.

A little about sCrypt

sCrypt is a typescript framework for writing smartcontracts on Bitcoin SV. it is an embedded Domain Specific Language (eDSL) based on TypeScript.
A smartcontract is a class that extends the smartcontract base class. Here is an example of a smartcontract;

import { SmartContract, method, prop, assert } from "scrypt-ts"

class Equations extends SmartContract {

  @prop()
  sum: bigint

  @prop()
  diff: bigint

  constructor(sum: bigint, diff: bigint) {
    super(...arguments)
    this.sum = sum
    this.diff = diff
  }

  @method()
  public unlock(x: bigint, y: bigint) {
    assert(x + y == this.sum, 'incorrect sum')
    assert(x - y == this.diff, 'incorrect diff')
  }

}

The smart contract above requires solving for two equations with unknown variables, x and y.

Class members decorated with @prop and @method will end up on the blockchain and thus must be a strict subset of TypeScript. Everywhere decorated with them can be regarded in the on-chain context. Members decorated with neither are regular TypeScript and are kept off chain. The significant benefit of sCrypt is that both on-chain and off-chain code are written in the same language: TypeScript.

Conlusion

In the next part of this guide you will learn how to write,deploy and call your first smartcontract using sCrypt, and you can also learn more about sCrypt here.

The Complete Guide To FullStack BSV Development.

John Godwin — Thu, 11 Apr 2024 03:01:45 +0000

Tic Tac Toe On Bitcoin SV Blockchain

Bitcoin SV (BSV) blockchain upholds the original vision of Bitcoin as outlined by Satoshi Nakamoto in the bitcoin whitepaper. Bitcoin SV distinguishes itself by providing a stable and scalable foundation for building dApps, leveraging it robust infrastructure and unique features.

In this comprehensive guide, we will delve into building a decentralized Tic-Tac-Toe game on the Bitcoin SV blockchain using sCrypt. From setting up the development environment to writing the smartcontracts and frontend integration, we will provide step-by-step instructions, practical insights to help you navigate the exciting world of Bitcoin SV dApp development using sCrypt.

The game is initialized with the Bitcoin public key of two players (Alice and Bob respectively). They each bet the same amount and lock it into the contract. The winner takes all bitcoins locked in the contract. If no one wins and there is a draw, the two players can each withdraw half of the money.

sCrypt Overview

sCrypt is an embedded Domain Specific Language (eDSL) based on TypeScript for writing smart contracts on Bitcoin SV. sCrypt simplifies the process of writing, testing, and deploying smart contracts, empowering developers to build secure and scalable applications on the Bitcoin SV network.

Prerequisite to Get Started

Make sure all prerequisite are install;

Install Node.js (require version >=16) and NPM on your machine by following the instructions over here
Install Git
Next, install the sCrypt Cli: follow this command to install the sCrypt Cli globally to your machine
npm install -g scrypt-cli
The tools we will be using for this project include;

sCrypt language: a typescript base framework for writing smartcontract on Bitcoin SV with a high-level abstraction. It’s a static –typed language which provides a safety and easy to use.
sCrypt library: a comprehensive library for client-side seamless interaction with the Bsv blockchain
sCrypt Cli: to easily create and compile sCrypt into bitcoin script and provides a best-practice scaffolding to help developers follow the recommended standards and conventions for writing sCrypt code.
React: the client-side framework.
Yours wallet:Yours Wallet is an open-source, non-custodial Bitcoin SV web3 wallet designed for ease of use and everyday transactions. Yours offers a straightforward and secure way to receive, send, and manage your digital assets.

Getting Started

create a new React project with TypeScript template
npx create-react-app tic tac toe --template typescript
add sCrypt dependencies to your project.
cd tic-tac-toe npx scrypt-cli@latest init

Creating Tic Tac Toe Contract

create a contract at src/contracts/tictactoe.ts

import {
    prop, method, SmartContract, PubKey, FixedArray, assert, Sig, Utils, toByteString, hash160,
    hash256,
    fill,
    ContractTransaction,
    MethodCallOptions,
    bsv
} from "scrypt-ts";

export class TicTacToe extends SmartContract {
    @prop()
    alice: PubKey;
    @prop()
    bob: PubKey;
    @prop(true)
    isAliceTurn: boolean;
    @prop(true)
    board: FixedArray<bigint, 9>;
    static readonly EMPTY: bigint = 0n;
    static readonly ALICE: bigint = 1n;
    static readonly BOB: bigint = 2n;

    constructor(alice: PubKey, bob: PubKey) {
        super(...arguments)
        this.alice = alice;
        this.bob = bob;
        this.isAliceTurn = true;
        this.board = fill(TicTacToe.EMPTY, 9);
    }

    @method()
    public move(n: bigint, sig: Sig) {
        // check position `n`
        assert(n >= 0n && n < 9n);
        // check signature `sig`
        let player: PubKey = this.isAliceTurn ? this.alice : this.bob;
        assert(this.checkSig(sig, player), `checkSig failed, pubkey: ${player}`);
        // update stateful properties to make the move
        assert(this.board[Number(n)] === TicTacToe.EMPTY, `board at position ${n} is not empty: ${this.board[Number(n)]}`);
        let play = this.isAliceTurn ? TicTacToe.ALICE : TicTacToe.BOB;
        this.board[Number(n)] = play;
        this.isAliceTurn = !this.isAliceTurn;

        // build the transation outputs
        let outputs = toByteString('');
        if (this.won(play)) {
            outputs = Utils.buildPublicKeyHashOutput(hash160(player), this.ctx.utxo.value);
        }
        else if (this.full()) {
            const halfAmount = this.ctx.utxo.value / 2n;
            const aliceOutput = Utils.buildPublicKeyHashOutput(hash160(this.alice), halfAmount);
            const bobOutput = Utils.buildPublicKeyHashOutput(hash160(this.bob), halfAmount);
            outputs = aliceOutput + bobOutput;
        }
        else {
            // build a output that contains latest contract state.
            outputs = this.buildStateOutput(this.ctx.utxo.value);
        }
        if (this.changeAmount > 0n) {
            outputs += this.buildChangeOutput();
        }
        // make sure the transaction contains the expected outputs built above
        assert(this.ctx.hashOutputs === hash256(outputs), "check hashOutputs failed");
    }

    @method()
    won(play: bigint): boolean {
        let lines: FixedArray<FixedArray<bigint, 3>, 8> = [
            [0n, 1n, 2n],
            [3n, 4n, 5n],
            [6n, 7n, 8n],
            [0n, 3n, 6n],
            [1n, 4n, 7n],
            [2n, 5n, 8n],
            [0n, 4n, 8n],
            [2n, 4n, 6n]
        ];
        let anyLine = false;
        for (let i = 0; i < 8; i++) {
            let line = true;
            for (let j = 0; j < 3; j++) {
                line = line && this.board[Number(lines[i][j])] === play;
            }
            anyLine = anyLine || line;
        }
        return anyLine;
    }

    @method()
    full(): boolean {
        let full = true;
        for (let i = 0; i < 9; i++) {
            full = full && this.board[i] !== TicTacToe.EMPTY;
        }
        return full;
    }

}

Contract Properties

The tic-tac-toe contract supports two players and their public keys need to be saved. It contains the following contract properties:

Two stateless properties alice and bob, both of which are PubKey type.
Two stateful properties:
is_alice_turn: a boolean. It represents whether it is alice's turn to play.
board: a fixed-size array FixedArray with a size of 9. It represents the state of every square in the board.
Three constants:
EMPTY, type bigint, value 0n. It means that a square in the board is empty
ALICE, type bigint, value 1n. Alice places symbol X in a square.
BOB, type bigint, value 2n. Bob places symbol O in a square.

Constructor

all the non-static properties are initialized in the constructor. at first, the entire board is empty.

constructor(alice: PubKey, bob: PubKey) {
    super(...arguments);
    this.alice = alice;
    this.bob = bob;
    this.is_alice_turn = true;
    this.board = fill(TicTacToe.EMPTY, 9);
}

Public Methods

The TicTacToe contract contains a public@methodnamed move(), which accepts two parameters. Alice and Bob engage in the game by sequentially invoking move() after each locking X bitcoins in a UTXO associated with the TicTacToecontract.

@method()
public move(n: bigint, sig: Sig) {
    assert(n >= 0n && n < 9n);
}

After deploying the game contract, it becomes publicly accessible for viewing and potential interaction. To ensure that only the intended player can update the contract when it's their turn, an authentication mechanism is required. This is accomplished through the use of digital signatures.
this.checkSig() is used to verify a signature against a public key. Use it to verify the sig parameter against the desired player in move(), identified by their public key stored in the contract's properties.

// check signature `sig`
let player: PubKey = this.is_alice_turn ? this.alice : this.bob;
assert(this.checkSig(sig, player), `checkSig failed, pubkey: ${player}`);

Non-Public Methods

The TicTacToe contract have two Non-Public methods:

won() : iterate over the lines array to check if a player has won the game. returns boolean type.
full() : traverse all the squares of the board to check if all squares of the board have symbols. returns boolean type.

Customise a contract transaction builder

we need to customise a transaction builder for our public method move()

static buildTxForMove(
    current: TicTacToe,
    options: MethodCallOptions<TicTacToe>,
    n: bigint
  ): Promise<ContractTransaction> {
    const play = current.isAliceTurn ? TicTacToe.ALICE : TicTacToe.BOB;
    const nextInstance = current.next();
    nextInstance.board[Number(n)] = play;
    nextInstance.isAliceTurn = !current.isAliceTurn;
    const unsignedTx: bsv.Transaction = new bsv.Transaction().addInput(
      current.buildContractInput(options.fromUTXO)
    );
    if (nextInstance.won(play)) {
      const script = Utils.buildPublicKeyHashScript(
        hash160(current.isAliceTurn ? current.alice : current.bob)
      );
      unsignedTx.addOutput(
        new bsv.Transaction.Output({
          script: bsv.Script.fromHex(script),
          satoshis: current.balance,
        })
      );
      if (options.changeAddress) {
        unsignedTx.change(options.changeAddress);
      }
      return Promise.resolve({
        tx: unsignedTx,
        atInputIndex: 0,
        nexts: [],
      });
    }
    if (nextInstance.full()) {
      const halfAmount = current.balance / 2;
      unsignedTx
        .addOutput(
          new bsv.Transaction.Output({
            script: bsv.Script.fromHex(
              Utils.buildPublicKeyHashScript(hash160(current.alice))
            ),
            satoshis: halfAmount,
          })
        )
        .addOutput(
          new bsv.Transaction.Output({
            script: bsv.Script.fromHex(
              Utils.buildPublicKeyHashScript(hash160(current.bob))
            ),
            satoshis: halfAmount,
          })
        );
      if (options.changeAddress) {
        unsignedTx.change(options.changeAddress);
      }
      return Promise.resolve({
        tx: unsignedTx,
        atInputIndex: 0,
        nexts: [],
      });
    }
    unsignedTx.setOutput(0, () => {
      return new bsv.Transaction.Output({
        script: nextInstance.lockingScript,
        satoshis: current.balance,
      });
    });
    if (options.changeAddress) {
      unsignedTx.change(options.changeAddress);
    }
    const nexts = [
      {
        instance: nextInstance,
        atOutputIndex: 0,
        balance: current.balance,
      },
    ];
    return Promise.resolve({
      tx: unsignedTx,
      atInputIndex: 0,
      nexts,
      next: nexts[0],
    });
  }

Integrate front-end

after writing and testing our contract, the front-end gives user t an interface to interact and play the the Tic Tac Toe game. However, we need to compile our contract using this line of code:
npx scrypt-cli@latest compile

this should generate tictactoe.json artifact file in the artifact directory which can be further use to initialize the contract at the frontend.

import { TicTacToe } from './contracts/tictactoe';
import artifact from '../artifacts/tictactoe.json';

TicTacToe.loadArtifact(artifact);

Connect to wallet

before deploying the contract, you need to connect to a wallet. but first thing first,

install yours wallet
After installing the wallet, click the settings button in the upper right corner to switch to testnet.

Then copy your wallet address and follow the guide here to get funded.

so, after that been done, you can request access to the wallet, you can use its requestAuth method and also call getDefaultPubKey() to get its public key.

const walletLogin = async () => {
    try {
      const provider = new DefaultProvider({
          network: bsv.Networks.testnet
      });
      const signer = new PandaSigner(provider);
      signerRef.current = signer;

      const { isAuthenticated, error } = await signer.requestAuth()
      if (!isAuthenticated) {
        throw new Error(error)
      }
      setConnected(true);
      const alicPubkey = await signer.getDefaultPubKey();
      setAlicePubkey(toHex(alicPubkey))
      // Prompt user to switch accounts
    } catch (error) {
      console.error("pandaLogin failed", error);
      alert("pandaLogin failed")
    }
};

Initialize the contract

the contract is initialized with the public keys of two players alice and bob. The public key can be obtained through calling getDefaultPubKey() of Signer.

The following code initializes the contract.

const [alicePubkey, setAlicePubkey] = useState("");
const [bobPubkey, setBobPubkey] = useState("");
...
const startGame = async (amount: number) => {
  try {
    const signer = signerRef.current as PandaSigner;
    const instance = new TicTacToe(
        PubKey(toHex(alicePubkey)),
        PubKey(toHex(bobPubkey))
      );
    await instance.connect(signer);

  } catch(e) {
    console.error('deploy TicTacToe failes', e)
    alert('deploy TicTacToe failes')
  }
};

Call the contract

const { tx: callTx } = await p2pkh.methods.unlock(
    (sigResponses: SignatureResponse[]) => findSig(sigResponses, $publickey),
    $publickey,
    {
        pubKeyOrAddrToSign: $publickey.toAddress()
    } as MethodCallOptions<P2PKH>
);

Every move is a call to the contract and causes a change in the state of the contract.

Once you've completed working on the front-end, you can simply execute it by running

npm start

You can then access it through your browser at http://localhost:3000/.

Conclusion

Through this comprehensive guide, we've navigated the intricate landscape of BSV blockchain dAPP development using sCrypt, from smart contract creation to front-end integration, unlocking the potential for endless innovation using sCrypt on BSV blockchain. learn more about sCrypt from its comprehensive documentation here

The Complete Guide To Full Stack Bsv Development with sCrypt.

John Godwin — Tue, 02 Apr 2024 03:41:24 +0000

Introducing sCrypt

sCrypt is an embedded domain specific language (eDSL) based on TypeScript for writing Smartcontract on Bitcoin. Scrypt uses and enables us to write an eDSL that abstract away many of the complex low level operations you’d typically need to do if you are building without it, making it easier and appreciable to write Smartcontract on the Bitcoin SV network.

In this guide to full stack BSV development with sCrypt, we’ll walk through the process of writing smartcontract, deploying it to the blockchain, calling it and also integrating a front-end. This will provide a basic introduction to the sCrypt programming language and how it’s used to build decentralized applications on the BSV blockchain.

By the end of this guide, you’ll have a better understanding of fullstack development on Bitcoin SV using sCrypt.

The tools we will be using for this project include;

sCrypt language: a typescript base framework for writing smartcontract on Bitcoin SV with a high-level abstraction. It’s a static –typed language which provides a safety and easy to use.

sCrypt library: a comprehensive library for client-side seamless interaction with the Bsv blockchain

sCrypt Cli: to easily create and compile sCrypt into bitcoin script and provides a best-practice scaffolding to help developers follow the recommended standards and conventions for writing sCrypt code.

React: the client-side framework.

Yours wallet:Yours Wallet is an open-source, non-custodial Bitcoin SV web3 wallet designed for ease of use and everyday transactions. Yours offers a straightforward and secure way to receive, send, and manage your digital assets.

Make sure all prerequisite are install;

Install Node.js (require version >=16) and NPM on your machine by following the instructions over here
Install Git
Next, install the sCrypt Cli: follow this command to install the sCrypt Cli globally to your machine
```
             npm install -g scrypt-cli
```

Creating a new project

Run the following commands to create a new project:

                 npx scrypt-cli project helloworld
                 cd helloworld

Install all necessary dependencies on your project:

                 npm install

The resulting project will contain a sample smart contract src/contracts/helloworld.ts, along with all the scaffolding. Let's modify it to the following code:

         import { assert, ByteString, method, prop, sha256, Sha256, SmartContract } from 'scrypt-ts'

export class Helloworld extends SmartContract {

    @prop()
    hash: Sha256;

    constructor(hash: Sha256){
        super(...arguments);
        this.hash = hash;
    }

    @method()
    public unlock(message: ByteString) {
        assert(sha256(message) == this.hash, 'Hash does not match')
    }
}

The Helloworld contract stores the sha256 hash of a message in the contract property hash. Only a message which hashes to the value set in this.hash will unlock the contract.

Compile Contract

Run following command to compile the Helloworld contract:

                 npx scrypt-cli compile

This command will generate a contract artifact file at artifacts\helloworld.json.

Then call the loadArtifact() function in the code:

                await Helloworld.loadArtifact()

Compile using the watch option

                    npx scrypt-cli compile --watch

The watch option in the provided command appears to facilitate continuous monitoring of sCrypt level errors during the compilation process. When invoked with the specified command, it utilizes the "npx scrypt-cli compile --watch" syntax to initiate a watch mode. This mode likely allows users to observe real-time updates and notifications regarding any errors specific to sCrypt, which are distinct from TypeScript errors.

Contract Deployment & Call

Before we deploy the contract, you need to generate a Bitcoin key.

                    npm run genprivkey

then follow the instruction to fund the key.After getting your Bitcoin key and funding, you can now proceed into deploying and calling you contract

To deploy a smart contract, simply call its deploy method.
To call a smart contract, call one of its public method.

Overwrite deploy.ts in the root of the project with the following code to deploy and call the Helloworld contract:

          import { Helloworld } from './src/contracts/helloworld'
import { getDefaultSigner } from './tests/utils/txHelper'
import { toByteString, sha256 } from 'scrypt-ts'

(async () => {

    // set network env
    process.env.NETWORK = 'testnet'

    const message = toByteString('hello world', true)

    await Helloworld.loadArtifact()
    const instance = new Helloworld(sha256(message))

    // connect to a signer
    await instance.connect(getDefaultSigner())

    // deploy the contract and lock up 42 satoshis in it
    const deployTx = await instance.deploy(42)
    console.log('Helloworld contract deployed: ', deployTx.id)

    // contract call
    const { tx: callTx } = await instance.methods.unlock(message)
    console.log('Helloworld contract `unlock` called: ', callTx.id)

})()

Run the following command:

              npx ts-node deploy.ts

You will see some output like:

You can view the deployment transaction using the WhatsOnChain blockchain explorer:

You can also view the calling transaction

Congrats! You have deployed and called your first Bitcoin smart contract, we will proceed on how to integrate a frontend to our smartcontract.

Integrate With a Frontend

This section, you will learn how to integrate your smart contract to a Frontend, so that users can interact with it.

Step 1

Create your frontend project.
React
Run the following command to create a React named helloworld.

           npx create-react-app helloworld --template typescript

Step 2

Run the init command of the CLI to add sCrypt support in your project.

                   cd helloworld
                   npx scrypt-cli init

This installs all the dependencies and configures the contract development environment.

Load Contract

Before interacting with a smart contract at the front end, we need to load the contract class in two steps.

We'll take a look at how to generate the artifact by ourselves first.

1. Compile Contract

Before you start, you need to get the contract source files, as a frontend developer. we will be using the Helloworld contract we wrote in the beginning of this guide as our contract src file,so copy and paste helloworld.ts into the src/contracts directory.

Run the following command to compile the contract.

             npx scrypt-cli compile

After the compilation, you will get an JSON artifact file at artifacts/helloworld.json.

2. Load Artifact

Now with the contract artifact file, you directly load it in the index.tsx file.

          import { Helloworld } from './contracts/helloworld';
          import artifact from '../artifacts/helloworld.json';
          Helloworld.loadArtifact(artifact);

Now you can create an instance from the contract class as before.

           const message = toByteString('hello world', true)
           const instance = new Helloworld(sha256(message))

Integrate Wallet

we will integrate Panda, a browser extension wallet similar to MetaMask, into the project
To request access to the wallet, you can use its requestAuth method.

              const provider = new DefaultProvider({
              network: bsv.Networks.testnet
              });

              const signer = new PandaSigner(provider);

              // request authentication
              const { isAuthenticated, error } = await 
              signer.requestAuth();
              if (!isAuthenticated) {
              // something went wrong, throw an Error with `error` 
               message
              throw new Error(error);
             }

              // authenticated
              // you can show user's default address
             const userAddress = await signer.getDefaultAddress();
              // ...

Now you can connect the wallet to the contract instance as before.

             await instance.connect(signer);

Afterwards, you can interact with the contract from the front end by calling its method

Conclusion

FullStack BSV development with sCrypt is rapidly growing. It offers developers the ability to create decentralized applications that are powerful, secure and scalable. With sCrypt, developers can build a powerful smart contract that runs on the BSV blockchain, providing a fast, secure, and decentralized platform for applications. sCrypt makes it easier for developers to create these applications, with its high-level abstractions and static-typing system.
Access the full comprehensive sCrypt documentation here

DEV Community: John Godwin

A Beginner's Guide to Smartcontract development on BSV

What is Smart Contract?

How do Bitcoin Smart Contracts work?

UTXO Model

A little about sCrypt

Conlusion

The Complete Guide To FullStack BSV Development.

Tic Tac Toe On Bitcoin SV Blockchain

sCrypt Overview

Prerequisite to Get Started

Getting Started

Creating Tic Tac Toe Contract

Contract Properties

Constructor

Public Methods

Non-Public Methods

Customise a contract transaction builder

Integrate front-end

Connect to wallet

Initialize the contract

Call the contract

Conclusion

The Complete Guide To Full Stack Bsv Development with sCrypt.

Introducing sCrypt

Creating a new project

Compile Contract

Compile using the watch option

Contract Deployment & Call

Integrate With a Frontend

Step 1

Step 2

Load Contract

1. Compile Contract

2. Load Artifact

Integrate Wallet

Conclusion