MIME-Version: 1.0
References: <kbrvpw3Y5y3ko3Wf2VtcywN462JjMW6YjqecduPOXwrek2sR9FkWfSv6G2Fph22UTAAbgII88MtOn1AFo223jjryNAz8YNbbQlFRVQo_HMY=@protonmail.com>
 <CABm2gDqxOtrMrTu2Ovx32USJT2T+6DRpexct1-k3zwEEnsDPMA@mail.gmail.com>
 <HfqjtQb_3TfhHaAZzYOcUoMic1iG40qUjqlKpzOZY6PSBW1bXVFtFW4zCHFRUdOoIhrard9ZPslzbrIYO0cM-Oi37mLzeEv6MZiQ7JtulE4=@protonmail.com>
 <CAGpPWDZVqas6v9nQtGtgk2mMOw9KQ+=dytBc+fBE6SNL=F3bqQ@mail.gmail.com>
 <CALeFGL18ULkGW4UA_5Fod4PVoe_LeF5e97eZdJja-ctf2paLWQ@mail.gmail.com>
 <CAGpPWDYUTCsSgirR7iNmbUw+cjEqHSymtzH4EtH=BQnZRjvgmQ@mail.gmail.com>
 <CABm2gDqVcAAz-Nqwt+SPBZrFyTUN3kizSTYkbuWSkoG0xJtoPQ@mail.gmail.com>
 <YexjEuO_SQawFcFWRGWAoZ0aVZqw6_pem6IGvCrTUGW1Q6WoKFbQXMzf9ICkpxn1ffLGFnvCWv8205dv97pZo9CzfiUA7Q53-X2Sd7uCQEM=@protonmail.com>
In-Reply-To: <YexjEuO_SQawFcFWRGWAoZ0aVZqw6_pem6IGvCrTUGW1Q6WoKFbQXMzf9ICkpxn1ffLGFnvCWv8205dv97pZo9CzfiUA7Q53-X2Sd7uCQEM=@protonmail.com>
From: Billy Tetrud <billy.tetrud@gmail.com>
Date: Thu, 12 May 2022 12:28:39 -0500
Message-ID: <CAGpPWDaDofscrK=k-Ej4Ze1u-VaoiJ1-Liy6DuuO3Wuss0aoyQ@mail.gmail.com>
To: ZmnSCPxj <ZmnSCPxj@protonmail.com>
Content-Type: multipart/alternative; boundary="0000000000008dae5005ded3e40d"
Cc: Bitcoin Protocol Discussion <bitcoin-dev@lists.linuxfoundation.org>
Subject: Re: [bitcoin-dev] CTV BIP Meeting #8 Notes
Precedence: list

--0000000000008dae5005ded3e40d
Content-Type: text/plain; charset="UTF-8"

@Jorge & Zmn
>  A recursive covenant guarantees that the same thing will happen in the
future.

Just a clarification: a recursive covenant does not necessarily guarantee
any particular thing will happen in the future. Both recursives and a
non-recursive covenant opcodes *can* be used to guarantee something will
happen. Neither *necessarily* guarantee anything (because of
the possibility of alternative spend paths). A covenant isn't just a
promise, its a restriction.

A "recursive covenant" opcode is one that allows loops in the progression
through covenant addresses. Here's an example of a set of transitions from
one address with a covenant in the spend path to another (or "exit" which
does not have a covenant restriction):

A -> B
A -> C
B -> C
C -> A
C -> exit

The possible combinations of changes are:

A -> B -> C -> exit
A -> C -> A -> ...
A -> B -> C -> A -> ...

This would be a recursive covenant with an exit. Remove the exit
transition, and you have a walled garden. Even with this walled garden, you
can avoid going through address B (since you can skip directly to C).

A covenant opcode that can allow for infinite recursion (often talked about
as a "recursive covenant") can be used to return to a previous state, which
allows for permanent walled gardens.

So I would instead characterize a bitcoin covenant as:

A covenant in an input script places a requirement/restriction on the
output script(s) that input sends to. Pretty much any covenant allows for a
chain or graph of covenant-laden addresses to be prescribed, while a
"recursive covenant" opcode allows previous nodes in that graph to be
returned to such that the states can be looped through forever (which may
or may not have some way to exit).

One potentially confusing thing about the way covenants are usually talked
about is that in technical discussions about the risks of covenants, what
is being talked about is not what a particular covenant opcode always does,
but rather what the boundaries are on what can be done with that opcode.
Pretty much any recursive covenant you could design would be able to be
used to create normal simple non-walled-garden situations. The question is,
since they do allow someone to create walled gardens, is that ok.

I suppose maybe an interesting possibility would be to have a covenant
limit placed into a covenant opcode. Eg, let's say that you have
OP_LIMITEDCOVENANT (OP_LC) and OP_LC specifies that the maximum covenant
chain is 100. The 100th consecutive output with an OP_LC use could simply
ignore it and be spent normally to anywhere (given that the rest of the
script allows it). This could effectively prevent the ability to create
walled gardens, without eliminating most interesting use cases. Among
people who care about covenants on this mailing list, the consensus seems
to be that infinitely recursive covenants are not something to be afraid
of. However, if maybe something like this could make more powerful
covenants acceptable to a larger group of people, it could be worth doing.

On Thu, May 12, 2022 at 7:20 AM ZmnSCPxj <ZmnSCPxj@protonmail.com> wrote:

> Good morning Jorge,
>
> > I fail to understand why non recursive covenants are called covenants at
> all. Probably I'm missing something, but I guess that's another topic.
>
> A covenant simply promises that something will happen in the future.
>
> A recursive covenant guarantees that the same thing will happen in the
> future.
>
> Thus, non-recursive covenants can be useful.
>
> Consider `OP_EVICT`, for example, which is designed for a very specific
> use-case, and avoids recursion.
>
> Regards,
> ZmnSCPxj
>

--0000000000008dae5005ded3e40d
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

<div dir=3D"ltr"><div>@Jorge &amp; Zmn<br></div>&gt;=C2=A0

A recursive covenant guarantees that the same thing will happen in the futu=
re.<div><br></div><div>Just a clarification: a recursive covenant does not =
necessarily guarantee any particular thing will happen in the future. Both =
recursives and a non-recursive covenant opcodes *can* be used to guarantee =
something will happen. Neither *necessarily* guarantee anything (because of=
 the=C2=A0possibility of alternative spend paths). A covenant isn&#39;t jus=
t a promise, its a restriction.=C2=A0=C2=A0</div><div><br></div><div>A &quo=
t;recursive covenant&quot; opcode is one that allows loops in the progressi=
on through covenant addresses. Here&#39;s an example of a set of transition=
s from one address with a covenant in the spend path to another (or &quot;e=
xit&quot; which does not have a covenant restriction):</div><div><br></div>=
<div>A -&gt; B</div><div>A -&gt; C</div><div>B -&gt; C</div><div>C -&gt; A<=
/div><div>C -&gt; exit</div><div><br></div><div>The possible combinations o=
f changes are:</div><div><br></div><div>A -&gt; B -&gt; C -&gt; exit</div><=
div>A -&gt; C -&gt; A -&gt; ...</div><div>A -&gt; B -&gt; C -&gt; A -&gt; .=
..</div><div><br></div><div>This would be a recursive covenant with an exit=
. Remove the exit transition, and you have a walled garden. Even with this =
walled garden, you can avoid going through address B (since you can skip di=
rectly to C).=C2=A0</div><div><br></div><div>A covenant opcode that can all=
ow for infinite recursion (often talked about as a &quot;recursive covenant=
&quot;) can be used to return to a previous state, which allows for permane=
nt walled gardens.=C2=A0=C2=A0</div><div><br></div><div>So I would instead =
characterize a bitcoin covenant as:</div><div><br></div><div>A covenant in =
an input script places a requirement/restriction on the output script(s) th=
at input sends to. Pretty much any covenant allows for a chain or graph of =
covenant-laden addresses to be prescribed, while a &quot;recursive covenant=
&quot; opcode allows previous nodes in that graph to be returned to such th=
at the states can be looped through forever (which may or may not have some=
 way to exit).=C2=A0=C2=A0</div><div><br></div><div>One potentially confusi=
ng thing about the way covenants are usually talked about is that in techni=
cal discussions about the risks of covenants, what is being talked about is=
 not what a particular covenant opcode always does, but rather what the bou=
ndaries are on what can be done with that opcode. Pretty much any recursive=
 covenant you could design would be able to be used to create normal simple=
 non-walled-garden situations. The question is, since they do allow someone=
 to create walled gardens, is that ok.=C2=A0=C2=A0</div><div><br></div><div=
>I suppose maybe an interesting possibility would be to have a covenant lim=
it placed into a covenant opcode. Eg, let&#39;s say that you have OP_LIMITE=
DCOVENANT (OP_LC) and OP_LC specifies that the maximum covenant chain is 10=
0. The 100th consecutive output with an OP_LC use could simply ignore it an=
d be spent normally to anywhere (given that the rest of the script allows i=
t). This could effectively prevent the ability to create walled gardens, wi=
thout eliminating most interesting use cases. Among people who care about c=
ovenants on this mailing list, the consensus seems to be that infinitely re=
cursive covenants are not something to be afraid of. However, if maybe some=
thing like this could make more powerful covenants acceptable to a larger g=
roup of people, it could be worth doing.=C2=A0</div></div><br><div class=3D=
"gmail_quote"><div dir=3D"ltr" class=3D"gmail_attr">On Thu, May 12, 2022 at=
 7:20 AM ZmnSCPxj &lt;<a href=3D"mailto:ZmnSCPxj@protonmail.com">ZmnSCPxj@p=
rotonmail.com</a>&gt; wrote:<br></div><blockquote class=3D"gmail_quote" sty=
le=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);paddi=
ng-left:1ex">Good morning Jorge,<br>
<br>
&gt; I fail to understand why non recursive covenants are called covenants =
at all. Probably I&#39;m missing something, but I guess that&#39;s another =
topic.<br>
<br>
A covenant simply promises that something will happen in the future.<br>
<br>
A recursive covenant guarantees that the same thing will happen in the futu=
re.<br>
<br>
Thus, non-recursive covenants can be useful.<br>
<br>
Consider `OP_EVICT`, for example, which is designed for a very specific use=
-case, and avoids recursion.<br>
<br>
Regards,<br>
ZmnSCPxj<br>
</blockquote></div>

--0000000000008dae5005ded3e40d--