Miniscript language vs policy (languague?)

[dr-orlovsky]

Can you please explain the difference between miniscript and policy?

[sanket1729]

At a high level:

Miniscript is an intermediate more structured representation for actual Bitcoin Scripts. It is useful as a toolbox because it simplifies static analysis of scripts, and things like generic signing.

The policy language is intended to simplify designing Scripts for humans.

In detail:

• Policy is compiled to Minsicript (using compiler).
• Miniscript is encoded to bitcoin Script. (One to One Mapping)
• Bitcoin Script is decoded back to Miniscript. (One to One Mapping)
• Policy and Miniscript can both be lifted to another representation for static analysis.

Following invariants are respected in Miniscript: Let ms be a miniscript, s be bitcoin script, pol be policy

decode(encode(ms)) = ms
encode(decode(s)) = s
lift(pol) = lift(compile(pol))

When would I use policy language rather than Miniscript? What does policy language offer that Miniscript doesn't? What are the key differences between them?

I think this is question is best answered by an example.

Writing an efficient Miniscipt directly from spending conditions is not trivial. Policy language is a more natural way to write the spending conditions. Consider an Hashlock example from Bob to Alice, your requirements are

• Alice can spend the coins if they know a preimage for hash H
• Funds are sent back to Bob after some time T say 10 blocks
• This naturally translates to following policy or(and(sha256(H),pk(A)),and(older(10),pk(B))) . Writing a Miniscript for this directly would be complicated and probably would turn out to be inefficient. This is where the compiler can help you.

The compiler would then compile down to a miniscript like the one shown below. andor(c:pk(A),sha256(H),and_v(vc:pk(B),older(10))) which has a one to one mapping to script.

Note that it is non-trivial to directly write down this Miniscript and involves complicated fragments like andor.

The policy language additionally allows specifying the odds(by using @ as shown below) for a or branch which can help the compiler produce byte efficient script. In the above example, we expect the Hashlock to succeed with high probability and the timelock branch should almost never be taken. We can use the odds in the policy language as follows:

or(99@and(sha256(H),pk(A)),1@and(older(10),pk(B)))

which then compiles down to a different miniscript(note that pk(B) changed to pk_h(B))

andor(c:pk(A),sha256(H),and_v(vc:pk_h(B),older(10)))

[sanket1729]

Based on https://bitcoin.stackexchange.com/questions/91565/what-does-bitcoin-policy-language-offer-the-developer-that-miniscript-doesnt-w. But slightly adapated

[dr-orlovsky]

Following invariants are respected in Miniscript:

encode(decode(s)) = s

Is it respected?

encode(decode(ln_cmt_offered_htlc)) != ln_cmt_offered_htlc