add BIP341 to Motoko basic_bitcoin (#1080)

Author: altkdf

motoko/basic_bitcoin/README.md

@@ -15,12 +15,9 @@ For a deeper understanding of the ICP < > BTC integration, see the [Bitcoin inte
 ## Prerequisites
 
 - [x] Install the [IC
-  SDK](https://internetcomputer.org/docs/current/developer-docs/getting-started/install). For local testing, `dfx >= 0.22.0` is required.
+  SDK](https://internetcomputer.org/docs/current/developer-docs/getting-started/install).
 - [x] Clone the example dapp project: `git clone https://github.com/dfinity/examples`
 
-> [!WARNING]
-> This example is designed to be deployed on the mainnet. It will return errors when deployed locally; these errors are expected.
-
 Begin by opening a terminal window.
 
 ## Step 1: Setup the project environment
@@ -89,58 +86,40 @@ to check [this
 article](https://bitcoinmagazine.com/technical/bitcoin-address-types-compared-p2pkh-p2sh-p2wpkh-and-more)
 if you are interested in a high-level comparison of different address types.
 These addresses can be generated from an ECDSA public key or a Schnorr
-([BIP340](https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki))
-public key. The example code showcases how your canister can generate and spend
-from three types of addresses:
+([BIP340](https://github.com/bitcoin/bips/blob/master/bip-0340.mediawiki),
+[BIP341](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki)) public
+key. The example code showcases how your canister can generate and spend from
+three types of addresses:
 1. A [P2PKH address](https://en.bitcoin.it/wiki/Transaction#Pay-to-PubkeyHash)
    using the
    [ecdsa_public_key](https://internetcomputer.org/docs/current/references/ic-interface-spec/#ic-method-ecdsa_public_key)
    API.
 2. A [P2TR
    address](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki)
-   where the funds can be spent using the raw (untweaked) internal key
-   (so-called P2TR key path spend, but untweaked). The advantage of this
-   approach compared to P2TR script spends is its significantly smaller fee per
-   transaction because checking the transaction signature is analogous to P2PK
-   but uses Schnorr instead of ECDSA. The limitation of untweaked P2TR addresses
-   is that they cannot be used with scripts. IMPORTANT: Note that
-   [BIP341](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki#cite_note-23)
-   advises against using taproot addresses that can be spent with an untweaked
-   key. This precaution is to prevent attacks that can occur when creating
-   taproot multisigner addresses using specific multisignature schemes. However,
-   the Schnorr API of the internet computer does not support Schnorr
-   multisignatures.
+   where the funds can be spent using the internal key only ([P2TR key path
+   spend with unspendable script
+   tree](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki#cite_note-23)).
 3. A [P2TR
    address](https://github.com/bitcoin/bips/blob/master/bip-0341.mediawiki)
-   where the funds can be spent using the provided public key with the script
-   path, where the Merkelized Alternative Script Tree (MAST) consists of a
-   single script allowing to spend funds by exactly one key.
-
-Note that P2TR *key path* spending with a tweaked key is currently not available
-on the IC because the threshold Schnorr signing interface does not allow
-applying BIP341 tweaks to the private key. In contrast, the
-tweaked public key is used to spend in the script path, which is availble on the
-IC. For a technical comparison of different ways of how single-signer P2TR
-addresses can be constructed and used, you may want to take a look at [this
-post](https://bitcoin.stackexchange.com/a/111100) by Pieter Wuille.
+   where the funds can be spent using either 1) the internal key or 2) the
+   provided public key with the script path, where the Merkelized Alternative
+   Script Tree (MAST) consists of a single script allowing to spend funds by
+   exactly one key.
 
 On the Candid UI of your canister, click the "Call" button under
 `get_${type}_address` to generate a `${type}` Bitcoin address, where `${type}`
-is one of `[p2pkh, p2tr_raw_key_spend, p2tr_script_spend]`.
+is one of `[p2pkh, p2tr_key_only, p2tr]` (corresponding to the three types of
+addresses described above, in the same order).
 
 Or, if you prefer the command line:
 
 ```bash
 dfx canister --network=ic call basic_bitcoin get_${type}_address
 ```
 
-* The Bitcoin address you see will be different from the one above because the
-  ECDSA public key your canister retrieves is unique.
-
 * We are generating a Bitcoin testnet address, which can only be
 used for sending/receiving Bitcoin on the Bitcoin testnet.
 
-
 ## Step 3: Receiving bitcoin
 
 Now that the canister is deployed and you have a Bitcoin address, it's time to receive
@@ -150,7 +129,6 @@ to receive some bitcoin.
 Enter your address and click on "Send testnet bitcoins". In the example below we will use Bitcoin address `n31eU1K11m1r58aJMgTyxGonu7wSMoUYe7`, but you will use your address. The Bitcoin address you see will be different from the one above
 because the ECDSA/Schnorr public key your canister retrieves is unique.
 
-
 Once the transaction has at least one confirmation, which can take a few minutes,
 you'll be able to see it in your canister's balance.
 
@@ -171,15 +149,16 @@ Checking the balance of a Bitcoin address relies on the [bitcoin_get_balance](ht
 ## Step 5: Sending bitcoin
 
 You can send bitcoin using the `send_from_${type}` endpoint on your canister, where
-`${type}` is on of `[p2pkh, p2tr_raw_key_spend, p2tr_script_spend]`.
+`${type}` is one of
+`[p2pkh_address, p2tr_key_only_address, p2tr_address_key_path, p2tr_address_script_path]`.
 
 In the Candid UI, add a destination address and an amount to send. In the example
 below, we're sending 4'321 Satoshi (0.00004321 BTC) back to the testnet faucet.
 
 Via the command line, the same call would look like this:
 
 ```bash
-dfx canister --network=ic call basic_bitcoin send_from_p2pkh '(record { destination_address = "tb1ql7w62elx9ucw4pj5lgw4l028hmuw80sndtntxt"; amount_in_satoshi = 4321; })'
+dfx canister --network=ic call basic_bitcoin send_from_p2pkh_address '(record { destination_address = "tb1ql7w62elx9ucw4pj5lgw4l028hmuw80sndtntxt"; amount_in_satoshi = 4321; })'
 ```
 
 The `send_from_${type}` endpoint can send bitcoin by:

motoko/basic_bitcoin/dfx.json

@@ -2,7 +2,13 @@
   "version": 1,
   "canisters": {
     "basic_bitcoin": {
-      "main": "src/basic_bitcoin/src/Main.mo"
+      "main": "src/basic_bitcoin/src/Main.mo",
+      "type": "motoko"
+    },
+    "chainkey_testing_canister": {
+      "type": "custom",
+      "candid": "https://github.com/dfinity/chainkey-testing-canister/releases/download/v0.1.0/chainkey_testing_canister.did",
+      "wasm": "https://github.com/dfinity/chainkey-testing-canister/releases/download/v0.1.0/chainkey_testing_canister.wasm.gz"
     }
   },
   "defaults": {

motoko/basic_bitcoin/src/basic_bitcoin/src/EcdsaApi.mo

@@ -8,45 +8,38 @@ module {
   type SignWithECDSA = Types.SignWithECDSA;
   type SignWithECDSAReply = Types.SignWithECDSAReply;
   type Cycles = Types.Cycles;
-
-  /// Actor definition to handle interactions with the ECDSA canister.
-  type EcdsaCanisterActor = actor {
-      ecdsa_public_key : ECDSAPublicKey -> async ECDSAPublicKeyReply;
-      sign_with_ecdsa : SignWithECDSA -> async SignWithECDSAReply;
-  };
+  type EcdsaCanisterActor = Types.EcdsaCanisterActor;
 
   // The fee for the `sign_with_ecdsa` endpoint using the test key.
   let SIGN_WITH_ECDSA_COST_CYCLES : Cycles = 10_000_000_000;
 
-  let ecdsa_canister_actor : EcdsaCanisterActor = actor("aaaaa-aa");
-
   /// Returns the ECDSA public key of this canister at the given derivation path.
-  public func ecdsa_public_key(key_name : Text, derivation_path : [Blob]) : async Blob {
+  public func ecdsa_public_key(ecdsa_canister_actor: EcdsaCanisterActor, key_name : Text, derivation_path : [Blob]) : async Blob {
     // Retrieve the public key of this canister at derivation path
     // from the ECDSA API.
     let res = await ecdsa_canister_actor.ecdsa_public_key({
-        canister_id = null;
-        derivation_path;
-        key_id = {
-            curve = #secp256k1;
-            name = key_name;
-        };
+      canister_id = null;
+      derivation_path;
+      key_id = {
+        curve = #secp256k1;
+        name = key_name;
+      };
     });
-        
-    res.public_key
+
+    res.public_key;
   };
 
-  public func sign_with_ecdsa(key_name : Text, derivation_path : [Blob], message_hash : Blob) : async Blob {
+  public func sign_with_ecdsa(ecdsa_canister_actor: EcdsaCanisterActor, key_name : Text, derivation_path : [Blob], message_hash : Blob) : async Blob {
     ExperimentalCycles.add<system>(SIGN_WITH_ECDSA_COST_CYCLES);
     let res = await ecdsa_canister_actor.sign_with_ecdsa({
-        message_hash;
-        derivation_path;
-        key_id = {
-            curve = #secp256k1;
-            name = key_name;
-        };
+      message_hash;
+      derivation_path;
+      key_id = {
+        curve = #secp256k1;
+        name = key_name;
+      };
     });
-        
-    res.signature
+
+    res.signature;
   };
-}
+};

motoko/basic_bitcoin/src/basic_bitcoin/src/Main.mo

@@ -1,39 +1,54 @@
+import Principal "mo:base/Principal";
 import Text "mo:base/Text";
+import Array "mo:base/Array";
+import Blob "mo:base/Blob";
 
 import BitcoinApi "BitcoinApi";
 import P2pkh "P2pkh";
-import P2trRawKeySpend "P2trRawKeySpend";
-import P2trScriptSpend "P2trScriptSpend";
+import P2trKeyOnly "P2trKeyOnly";
+import P2tr "P2tr";
 import Types "Types";
 import Utils "Utils";
 
-actor class BasicBitcoin(_network : Types.Network) {
+actor class BasicBitcoin(network : Types.Network) {
   type GetUtxosResponse = Types.GetUtxosResponse;
   type MillisatoshiPerVByte = Types.MillisatoshiPerVByte;
   type SendRequest = Types.SendRequest;
   type Network = Types.Network;
   type BitcoinAddress = Types.BitcoinAddress;
   type Satoshi = Types.Satoshi;
   type TransactionId = Text;
+  type EcdsaCanisterActor = Types.EcdsaCanisterActor;
+  type SchnorrCanisterActor = Types.SchnorrCanisterActor;
+  type P2trDerivationPaths = Types.P2trDerivationPaths;
 
-  // The Bitcoin network to connect to.
-  //
-  // When developing locally this should be `regtest`.
-  // When deploying to the IC this should be `testnet`.
-  // `mainnet` is currently unsupported.
-  stable let NETWORK : Network = _network;
+  /// The Bitcoin network to connect to.
+  ///
+  /// When developing locally this should be `regtest`.
+  /// When deploying to the IC this should be `testnet`.
+  /// `mainnet` is currently unsupported.
+  stable let NETWORK : Network = network;
 
-  // The derivation path to use for ECDSA secp256k1.
+  /// The derivation path to use for ECDSA secp256k1 or Schnorr BIP340/BIP341 key
+  /// derivation.
   let DERIVATION_PATH : [[Nat8]] = [];
 
   // The ECDSA key name.
   let KEY_NAME : Text = switch NETWORK {
     // For local development, we use a special test key with dfx.
-    case (#regtest) "dfx_test_key";
+    case (#regtest) "insecure_test_key_1";
     // On the IC we're using a test ECDSA key.
     case _ "test_key_1";
   };
 
+  var ecdsa_canister_actor : EcdsaCanisterActor = actor ("aaaaa-aa");
+  var schnorr_canister_actor : SchnorrCanisterActor = actor ("aaaaa-aa");
+
+  public func for_test_only_change_management_canister_id(p : Principal) {
+    ecdsa_canister_actor := actor (Principal.toText(p));
+    schnorr_canister_actor := actor (Principal.toText(p));
+  };
+
   /// Returns the balance of the given Bitcoin address.
   public func get_balance(address : BitcoinAddress) : async Satoshi {
     await BitcoinApi.get_balance(NETWORK, address);
@@ -52,28 +67,51 @@ actor class BasicBitcoin(_network : Types.Network) {
 
   /// Returns the P2PKH address of this canister at a specific derivation path.
   public func get_p2pkh_address() : async BitcoinAddress {
-    await P2pkh.get_address(NETWORK, KEY_NAME, DERIVATION_PATH);
+    await P2pkh.get_address(ecdsa_canister_actor, NETWORK, KEY_NAME, p2pkhDerivationPath());
   };
 
   /// Sends the given amount of bitcoin from this canister to the given address.
   /// Returns the transaction ID.
   public func send_from_p2pkh_address(request : SendRequest) : async TransactionId {
-    Utils.bytesToText(await P2pkh.send(NETWORK, DERIVATION_PATH, KEY_NAME, request.destination_address, request.amount_in_satoshi));
+    Utils.bytesToText(await P2pkh.send(ecdsa_canister_actor, NETWORK, p2pkhDerivationPath(), KEY_NAME, request.destination_address, request.amount_in_satoshi));
+  };
+
+  public func get_p2tr_key_only_address() : async BitcoinAddress {
+    await P2trKeyOnly.get_address_key_only(schnorr_canister_actor, NETWORK, KEY_NAME, p2trKeyOnlyDerivationPath());
+  };
+
+  public func send_from_p2tr_key_only_address(request : SendRequest) : async TransactionId {
+    Utils.bytesToText(await P2trKeyOnly.send(schnorr_canister_actor, NETWORK, p2trKeyOnlyDerivationPath(), KEY_NAME, request.destination_address, request.amount_in_satoshi));
+  };
+
+  public func get_p2tr_address() : async BitcoinAddress {
+    await P2tr.get_address(schnorr_canister_actor, NETWORK, KEY_NAME, p2trDerivationPaths());
+  };
+
+  public func send_from_p2tr_address_key_path(request : SendRequest) : async TransactionId {
+    Utils.bytesToText(await P2tr.send_key_path(schnorr_canister_actor, NETWORK, p2trDerivationPaths(), KEY_NAME, request.destination_address, request.amount_in_satoshi));
+  };
+
+  public func send_from_p2tr_address_script_path(request : SendRequest) : async TransactionId {
+    Utils.bytesToText(await P2tr.send_script_path(schnorr_canister_actor, NETWORK, p2trDerivationPaths(), KEY_NAME, request.destination_address, request.amount_in_satoshi));
   };
 
-  public func get_p2tr_raw_key_spend_address() : async BitcoinAddress {
-    await P2trRawKeySpend.get_address(NETWORK, KEY_NAME, DERIVATION_PATH);
+  func p2pkhDerivationPath() : [[Nat8]] {
+    derivationPathWithSuffix("p2pkh");
   };
 
-  public func send_from_p2tr_raw_key_spend_address(request : SendRequest) : async TransactionId {
-    Utils.bytesToText(await P2trRawKeySpend.send(NETWORK, DERIVATION_PATH, KEY_NAME, request.destination_address, request.amount_in_satoshi));
+  func p2trKeyOnlyDerivationPath() : [[Nat8]] {
+    derivationPathWithSuffix("p2tr_key_only");
   };
 
-  public func get_p2tr_script_spend_address() : async BitcoinAddress {
-    await P2trScriptSpend.get_address(NETWORK, KEY_NAME, DERIVATION_PATH);
+  func p2trDerivationPaths() : P2trDerivationPaths {
+    {
+      key_path_derivation_path = derivationPathWithSuffix("p2tr_internal_key");
+      script_path_derivation_path = derivationPathWithSuffix("p2tr_script_key");
+    };
   };
 
-  public func send_from_p2tr_script_spend_address(request : SendRequest) : async TransactionId {
-    Utils.bytesToText(await P2trScriptSpend.send(NETWORK, DERIVATION_PATH, KEY_NAME, request.destination_address, request.amount_in_satoshi));
+  func derivationPathWithSuffix(suffix : Blob) : [[Nat8]] {
+    Array.flatten([DERIVATION_PATH, [Blob.toArray(suffix)]]);
   };
 };