feat(bitcoin): Added support for Bitcoin transfers

examples/btc-to-evm-fungible-transfer/.env.sample

@@ -0,0 +1,8 @@
+SYGMA_ENV=devnet
+BLOCKSTREAM_URL=https://blockstream.info/testnet/api
+DESTINATION_ADDRESS=
+PRIVATE_KEY=
+DESTINATION_DOMAIN_ID=
+RESOURCE_ID=
+SOURCE_DOMAIN_CAIPID=
+EXPLORER_URL=https://blockstream.info/testnet/tx

examples/btc-to-evm-fungible-transfer/README.md

@@ -0,0 +1,77 @@
+# Sygma SDK BTC to EVM example
+
+## Sygma SDK ERC20 Example
+
+This is an example script that demonstrates the functionality of the SDK using the Sygma ecosystem. The script showcases a asset transfer between a BTC testnet account and a EVM Sepolia account.
+
+## Prerequisites
+
+Before running the script, ensure that you have the following:
+
+- Node.js
+- Yarn (version 3.4.1 or higher)
+- A development wallet with some testnet BTC
+- The private key of a Taproot address to sign the transaction
+- Valid UTXO information of your taproot address. You can get the UTXO's of your address by querying some public APIS like blockstream one and passing your address as parameter
+
+## Getting started
+
+### 1. Clone the repository
+
+To get started, clone this repository to your local machine with:
+
+```bash
+git clone [email protected]:sygmaprotocol/sygma-sdk.git
+cd sygma-sdk/
+```
+
+### 2. Install dependencies
+
+Install the project dependencies by running:
+
+```bash
+yarn install
+```
+
+### 3. Build the sdk
+
+To start the example you need to build the sdk first with:
+
+```bash
+yarn build:all
+```
+
+## Usage
+
+This example uses the `dotenv` module to manage private keys and also to define env variables needed for this example to work. To run the example, you will need to configure your environment variables A `.env.sample` is provided as a template.
+
+**DO NOT COMMIT PRIVATE KEYS WITH REAL FUNDS TO GITHUB. DOING SO COULD RESULT IN COMPLETE LOSS OF YOUR FUNDS.**
+
+Create a `.env` file in the btc-to-evm example folder:
+
+```bash
+cd examples/btc-to-evm-fungible-transfer
+touch .env
+```
+
+Replace between the quotation marks your taproot address private key:
+
+`PRIVATE_KEY="YOUR_PRIVATE_KEY_HERE"`
+
+To send Testnet BTC to your EVM account on Sepolia run:
+
+```bash
+yarn run transfer
+```
+
+Replace the placeholder values in the `.env` file with your own Testnet BTC Taproot private key as well as the other env variables needed such as DESTINATION_ADDRESS, DESTINATION_DOMAIN_ID, RESOURCE_ID and SOURCE_DOMAIN_ID.
+
+## Script Functionality
+
+This example script performs the following steps:
+- I creates a signer to sign the Bitcoin Testnet transaction using your provider private key from your taproot address.
+- it gets the fee for 5 confirmations blocks. You can change that following this [reference](https://github.com/Blockstream/esplora/blob/master/API.md#get-fee-estimates)
+- it then encodes the provided EVM address + the destination domain id needed to relay the funds
+- Once you have provided with the UTXO information needed, it will calculate the fee of the transaction based on some aproximation value
+- it then instantiate a PSBT class to be able to provide the inputs and outputs needed to relay the assets
+- It signs the transaction and the broadcasted into the Bitcoin testnet network. You will get an url with the transaction id to follow the confirmation of the transaction.

examples/btc-to-evm-fungible-transfer/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@buildwithsygma/sygma-sdk-btc-to-evm-fungible-transfer-example",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Sygma sdk examples",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/sygmaprotocol/sygma-sdk"
+  },
+  "keywords": [
+    "sygma",
+    "sygmaprotocol",
+    "buildwithsygma",
+    "web3",
+    "bridge",
+    "bitcoin"
+  ],
+  "scripts": {
+    "transfer": "tsx src/transfer.ts"
+  },
+  "author": "Sygmaprotocol Product Team",
+  "license": "LGPL-3.0-or-later",
+  "devDependencies": {
+    "dotenv": "^16.3.1",
+    "eslint": "8",
+    "ts-node": "10.9.1",
+    "typescript": "5.0.4"
+  },
+  "dependencies": {
+    "@buildwithsygma/btc": "workspace:^",
+    "@buildwithsygma/core": "workspace:^",
+    "bitcoinjs-lib": "^6.1.6",
+    "ecpair": "^2.1.0",
+    "tiny-secp256k1": "^2.2.3",
+    "tsx": "^4.15.4"
+  }
+}

examples/btc-to-evm-fungible-transfer/src/transfer.ts

@@ -0,0 +1,139 @@
+import dotenv from 'dotenv';
+import { createBitcoinFungibleTransfer } from '@buildwithsygma/btc';
+import { ECPairFactory, ECPairAPI } from 'ecpair';
+import {
+  initEccLib,
+  networks,
+  payments,
+  Psbt
+} from "bitcoinjs-lib";
+import * as tinysecp from 'tiny-secp256k1';
+import { broadcastTransaction, calculateFee, getFeeEstimates, getTweakedSigner, toXOnly } from './utils';
+
+dotenv.config();
+
+const DESTINATION_ADDRESS = process.env.DESTINATION_ADDRESS;
+const DESTINATION_DOMAIN_ID = Number(process.env.DESTINATION_DOMAIN_ID);
+const BLOCKSTREAM_URL = process.env.BLOCKSTREAM_URL;
+const PRIVATE_KEY = process.env.PRIVATE_KEY;
+const RESOURCE_ID = process.env.RESOURCE_ID;
+const SOURCE_DOMAIN_CAIPID = process.env.SOURCE_DOMAIN_CAIPID
+const FEE_ADDRESS = 'tb1p0r2w3ugreaggd7nakw2wd04up6rl8k0cce8eetxwmhnrelgqx87s4zdkd7'
+const FEE_AMOUNT = 1000000;
+const EXPLORER_URL = process.env.EXPLORER_URL;
+
+if (!DESTINATION_ADDRESS || !PRIVATE_KEY || !DESTINATION_DOMAIN_ID || !BLOCKSTREAM_URL || !RESOURCE_ID || !SOURCE_DOMAIN_CAIPID) {
+  throw new Error('Please provided needed env variavles in .env file');
+}
+
+type InputData = {
+  hash: string;
+  index: number;
+  witnessUtxo: { value: number; script: Buffer };
+  tapInternalKey: Buffer;
+};
+
+async function btcToEvmTransfer(): Promise<void> {
+  // pre setup
+  const testnet = networks.testnet;
+  initEccLib(tinysecp as any);
+  const ECPair: ECPairAPI = ECPairFactory(tinysecp);
+
+  console.log('Transfer BTC to EVM');
+
+  // tweaking signer
+  const { tweakedSigner, publicKey } = getTweakedSigner(ECPair, tinysecp, testnet, PRIVATE_KEY!);
+
+  // Generate an address from the tweaked public key
+  const p2pktr = payments.p2tr({
+    pubkey: toXOnly(tweakedSigner.publicKey),
+    network: testnet,
+  });
+
+  const p2pktrAdddress = p2pktr.address as string;
+  // address here should match the one that you generated for your private key
+  console.log('Taproot address to use', p2pktrAdddress)
+
+  const feeEstimatesPerBlockConfirmation = await getFeeEstimates(BLOCKSTREAM_URL!);
+
+  /**
+   * Get UTXO to use for the transfer
+   * You can get UTXO from any source, for this example we are using Blockstream API
+   * Add the txid and vout of the UTXO to the inputData. Also add the value of the UTXO to the witnessUtxo value field
+   */
+
+  const inputData: InputData = {
+    hash: '', // utxo tx id
+    index: 0, // utxo index
+    witnessUtxo: { value: 0, script: p2pktr.output! }, // utxo value
+    tapInternalKey: toXOnly(publicKey)
+  };
+
+  const params = {
+    sourceDomain: SOURCE_DOMAIN_CAIPID,
+    destinationAddress: DESTINATION_ADDRESS,
+    amount: inputData.witnessUtxo.value,
+    resource: RESOURCE_ID
+  }
+
+  const transfer = await createBitcoinFungibleTransfer(params);
+
+  const transferRequestData = transfer.getBTCTransferRequest();
+
+  const psbt = new Psbt({ network: testnet });
+
+  // encoded data
+  const data = Buffer.from(
+    `${DESTINATION_ADDRESS}_${DESTINATION_DOMAIN_ID}`, // EMV ADDRESS + DESTINATION DOMAIN ID HERE
+    "utf8",
+  );
+
+  const embed = payments.embed({ data: [data] });
+
+  const amount = transferRequestData.amount - 1e4;
+  const amountMinusBridgeFee = amount - FEE_AMOUNT;
+
+  const outputEncodedData = {
+    script: embed.output!,
+    value: 0,
+  };
+
+  const outputData = {
+    address: transferRequestData.depositAddress,
+    value: amountMinusBridgeFee
+  };
+
+  const outputDataFee = {
+    address: FEE_ADDRESS,
+    value: FEE_AMOUNT
+  };
+
+  const feeValue = calculateFee(psbt, feeEstimatesPerBlockConfirmation, inputData, outputEncodedData, outputData, outputDataFee, tweakedSigner);
+
+  const psbtWithFee = new Psbt({ network: testnet });
+
+  const amountWitFeeApplied = amount - feeValue - FEE_AMOUNT;
+
+  psbtWithFee.addInput(inputData);
+
+  psbtWithFee.addOutput(outputEncodedData);
+
+  psbtWithFee.addOutput(outputDataFee);
+
+  psbtWithFee.addOutput({
+    address: transferRequestData.depositAddress,
+    value: amountWitFeeApplied
+  });
+
+  psbtWithFee.signInput(0, tweakedSigner);
+  psbtWithFee.finalizeAllInputs();
+
+  const tx = psbtWithFee.extractTransaction(true);
+
+  console.log(`Broadcasting Transaction Hex: ${tx.toHex()}`);
+  const txid = await broadcastTransaction(BLOCKSTREAM_URL!, tx.toHex());
+
+  console.log(`Transaction ID: ${EXPLORER_URL}/${txid}`);
+}
+
+btcToEvmTransfer().finally(() => { })

examples/btc-to-evm-fungible-transfer/src/utils.ts

@@ -0,0 +1,91 @@
+import { Signer, networks, crypto, Psbt } from "bitcoinjs-lib";
+import { ECPairAPI, TinySecp256k1Interface } from "ecpair";
+
+
+type InputData = { hash: string, index: number, witnessUtxo: { value: number, script: Buffer }, tapInternalKey: Buffer }
+
+type OutputData = { value: number, script: Buffer, address: string }
+
+
+// shortens the public key to 32 bytes
+export function toXOnly(pubkey: Buffer): Buffer {
+  return pubkey.subarray(1, 33)
+}
+
+function tapTweakHash(pubKey: Buffer, h: Buffer | undefined): Buffer {
+  return crypto.taggedHash(
+    'TapTweak',
+    Buffer.concat(h ? [pubKey, h] : [pubKey]),
+  );
+}
+
+// Get the tweaked signer and returns also public key
+export function getTweakedSigner(ECPair: ECPairAPI, tinysecp: TinySecp256k1Interface, network: networks.Network, privateKey: string): { tweakedSigner: Signer, publicKey: Buffer } {
+  const keypair = ECPair.fromWIF(privateKey!, networks.testnet) as Signer;
+  // @ts-ignore
+  let privKey: Uint8Array = keypair.privateKey!;
+
+  if (keypair.publicKey[0] === 3) {
+    privKey = tinysecp.privateNegate(privKey);
+  }
+
+  const tweakedPrivateKey = tinysecp.privateAdd(
+    privKey,
+    tapTweakHash(toXOnly(keypair.publicKey), undefined),
+  );
+
+  if (!tweakedPrivateKey) {
+    throw new Error('Invalid tweaked private key!');
+  }
+
+  return {
+    tweakedSigner: ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {
+      network: networks.testnet,
+    }), publicKey: keypair.publicKey
+  };
+}
+
+export async function getFeeEstimates(blockstreamUrl: string): Promise<number> {
+  try {
+    const response = await fetch(`${blockstreamUrl}/fee-estimates`);
+
+    const data = await response.json();
+
+    return data['5']; // fee for 5 blocks confirmation
+  } catch (error) {
+    throw new Error('Failed to get fee estimates');
+  }
+}
+
+export async function broadcastTransaction(blockstreamUrl: string, txHex: string): Promise<string> {
+  try {
+    const response = await fetch(`${blockstreamUrl}/tx`, {
+      method: 'POST',
+      body: txHex,
+      headers: {
+        'Content-Type': 'text/plain'
+      }
+    });
+
+    return await response.text();
+  } catch (error) {
+    console.log('error', error)
+    throw new Error('Failed to broadcast transaction');
+  }
+}
+
+export function calculateFee(psbt: Psbt, feeRate: number, inputData: InputData, bridgeOutputData: Pick<OutputData, "script" | "value">, valueOutputData: Pick<OutputData, "address" | "value">, outputFeeData: Pick<OutputData, "address" | "value">, tweakedSigner: Signer): number {
+  psbt.addInput(inputData);
+  psbt.addOutput(bridgeOutputData);
+  psbt.addOutput(valueOutputData);
+  psbt.addOutput(outputFeeData);
+
+  psbt.signInput(0, tweakedSigner);
+  psbt.finalizeAllInputs();
+
+  const tx = psbt.extractTransaction(true);
+
+  const virtualSize = tx.virtualSize();
+
+  return Math.round(virtualSize * feeRate);
+}

examples/btc-to-evm-fungible-transfer/tsconfig.json

@@ -0,0 +1,21 @@
+{
+	"compilerOptions": {
+		"composite": true,
+		"module": "ES2022",
+		"allowJs": true,
+		"declaration": true,
+		"sourceMap": true,
+		"declarationMap": true,
+		"resolveJsonModule": true,
+		"skipLibCheck": true,
+		"strict": true,
+		"esModuleInterop": true,
+		"downlevelIteration": true,
+		"allowSyntheticDefaultImports": true,
+		"forceConsistentCasingInFileNames": true,
+		"moduleResolution": "node",
+	},
+	"include": [
+		"src"
+	]
+}

examples/evm-to-btc-fungible-transfer/.env.sample

@@ -0,0 +1,4 @@
+SEPOLIA_RPC_URL=
+BTC_DESTINATION_ADDRESS=
+PRIVATE_KEY=
+SYGMA_ENV=devnet

examples/evm-to-btc-fungible-transfer/README.md

@@ -0,0 +1 @@
+# evm-to-btc-fungible-transfer