for ((n=1;n<=3;n++))

Extract the xpub of each wallet. To do this, the `listdescriptors` RPC is used. By default, Bitcoin Core single-sig wallets are created using path `m/44'/1'/0'` for PKH, `m/84'/1'/0'` for WPKH, `m/49'/1'/0'` for P2WPKH-nested-in-P2SH and `m/86'/1'/0'` for P2TR based accounts. Each of them uses the chain 0 for external addresses and chain 1 for internal ones, as shown in the example below.

The suffix (after #) is the checksum. Descriptors can optionally be suffixed with a checksum to protect against typos or copy-paste errors.

All RPCs in Bitcoin Core will include the checksum in their output.

declare -A xpubs

for ((n=1;n<=3;n++))

As previously mentioned, this step extracts the `m/84'/1'/0'` account instead of the path defined in [BIP 45](https://github.com/bitcoin/bips/blob/master/bip-0045.mediawiki) or [BIP 87](https://github.com/bitcoin/bips/blob/master/bip-0087.mediawiki), since there is no way to extract a specific path in Bitcoin Core at the time of writing.

The checksum for a descriptor without one can be computed using the `getdescriptorinfo` RPC. The response has the `descriptor` field, which is the descriptor with the checksum added.

* `active`: Sets the descriptor to be the active one for the corresponding output type (`wsh`, in this case).

* `internal`: Indicates whether matching outputs should be treated as something other than incoming payments (e.g. change).

* `timestamp`: Sets the time from which to start rescanning the blockchain for the descriptor, in UNIX epoch time.

To create the multisig wallet, first create an empty one (no keys, HD seed and private keys disabled).

After that, `getwalletinfo` can be used to check if the wallet was created successfully.

Once the wallets have already been created and this tutorial needs to be repeated or resumed, it is not necessary to recreate them, just load them with the command below:

Coins received by the wallet must have at least 1 confirmation before they can be spent. It is necessary to wait for a new block to be mined before continuing.

./contrib/signet/getcoins.py -c ./build/bin/bitcoin-cli -a $receiving_address

The `getbalances` RPC may be used to check the balance. Coins with `trusted` status can be spent.

The `walletcreatefundedpsbt` RPC is used to create and fund a transaction in the PSBT format. It is the first step in creating the PSBT.

amount=$(echo "$balance * 0.8" | bc -l | sed -e 's/^\./0./' -e 's/^-\./-0./')

There is also the `createpsbt` RPC, which serves the same purpose, but it has no access to the wallet or to the UTXO set. It is functionally the same as `createrawtransaction` and just drops the raw transaction into an otherwise blank PSBT. [[source](https://bitcointalk.org/index.php?topic=5131043.msg50573609#msg50573609)] In most cases, `walletcreatefundedpsbt` solves the problem.

The `analyzepsbt` RPC analyzes and provides information about the current status of a PSBT and its inputs, e.g. missing signatures.

The `walletprocesspsbt` is used by the wallet to sign a PSBT.

The PSBT, if signed separately by the co-signers, must be combined into one transaction before being finalized. This is done by `combinepsbt` RPC.

There is an RPC called `joinpsbts`, but it has a different purpose than `combinepsbt`. `joinpsbts` joins the inputs from multiple distinct PSBTs into one PSBT.

It checks that all inputs have complete scriptSigs and scriptWitnesses and, if so, encodes them into network serialized transactions.

After that, the rest of the process is the same: the PSBT is finalized and transmitted to the network.

self.skip_if_no_wallet()

@staticmethod

"""Extract the wallet's xpubs using `listdescriptors` and pick the one from the `pkh` descriptor since it's least likely to be accidentally reused (legacy addresses)."""

# Keep all key origin information (master key fingerprint and all derivation steps) for proper support of hardware devices

# See section 'Key origin identification' in 'doc/descriptors.md' for more details...

@staticmethod

def _check_psbt(psbt, to, value, multisig):

amount += vout["value"]

assert_approx(amount, float(value), vspan=0.001)

"""The multisig is created by importing the following descriptors. The resulting wallet is watch-only and every participant can do this."""

for i, node in enumerate(self.nodes):

node.createwallet(wallet_name=f"{self.name}_{i}", blank=True, disable_private_keys=True)

multisig = node.get_wallet_rpc(f"{self.name}_{i}")

result = multisig.importdescriptors([

"active": True,

"timestamp": "now",

])

assert all(r["success"] for r in result)

yield multisig

}

self.log.info("Generate and exchange xpubs...")

self.log.info("Every participant imports the following descriptors to create the watch-only multisig...")

self.log.info("Check that every participant's multisig generates the same addresses...")

for _ in range(10): # we check that the first 10 generated addresses are the same for all participant's multisigs