Received-SPF: pass (sog-mx-2.v43.ch3.sourceforge.com: domain of gmail.com
	designates 209.85.216.47 as permitted sender)
	client-ip=209.85.216.47; envelope-from=gmaxwell@gmail.com;
	helo=mail-qw0-f47.google.com; 
MIME-Version: 1.0
In-Reply-To: <1089B122-1274-454C-9097-700D392BF0FA@ceptacle.com>
References: <CANEZrP1ic4RXFzoqf66MGv=rJe3MgWxVi5nnk2VKkMc4VMCDyw@mail.gmail.com>
	<CABsx9T3WKv3RLWT+Q6s7cCLzDL3sVRCWfmPiKcSp=_Re05m+zQ@mail.gmail.com>
	<CAAS2fgSYwUdiyY2XfHhWn+aN_6a72XRKs-8W7ibZM5t0tZ28rg@mail.gmail.com>
	<CALf2ePy=3N1JQodP3s9PzH=Af1z-7qGdy_4=QW9-CJmaxYGz5Q@mail.gmail.com>
	<7A50EE90-0FFC-45FB-A27F-786AEB23A8CA@ceptacle.com>
	<CAAS2fgTx8gEztUt-UrDObMCQtfdzZc52fzS6c1q8mm+a-TjwjQ@mail.gmail.com>
	<CABsx9T3YnK9ogc3J39nO=Q+29daMTDhP2J_FGvpozTGAxD1z6Q@mail.gmail.com>
	<1089B122-1274-454C-9097-700D392BF0FA@ceptacle.com>
Date: Thu, 27 Oct 2011 05:08:53 -0400
Message-ID: <CAAS2fgQAo-xxJxVtoXbTMZ3nvQvtiFxeqOKrN5-xxppMgmBdqg@mail.gmail.com>
From: Gregory Maxwell <gmaxwell@gmail.com>
To: =?UTF-8?Q?Michael_Gr=C3=B8nager?= <gronager@ceptacle.com>
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Cc: Bitcoin Dev <bitcoin-development@lists.sourceforge.net>
Subject: Re: [Bitcoin-development] Detecting OP_EVAL scriptPubKeys that are
	to you
Precedence: list

(taking this a bit out of order)

On Thu, Oct 27, 2011 at 3:32 AM, Michael Gr=C3=B8nager <gronager@ceptacle.c=
om> wrote:
> OK, let me try to explain what I see is the problem:
[snip]
> This, I find a nice and clean setup, where cryptographic keys can be mapp=
ed to assets.

From my perspective that clean boundary remains: Functionally the
script is part of the cryptographic key.

[snip]
> except if you also have the knowledge of the script that was used.

Which you must.

I can see no functional difference than if you said of the current
system "except if you also have knowledge of the final 32 bits of the
ECC private key".

I don't see any reason to expect clients to identify funds without
knowing the information required=E2=80=94 it's impossible. I mean, sure, yo=
u
_could_ bruteforce the final 32 bits of your private key=E2=80=94 or you co=
uld
attempt to try the cartesian product of every key you have with every
key seen in the block chain for finding an op_eval script. But thats
unworkable, unnecessary, equally bad for all client types, and not
being suggested.  Under either system a coin is not yours unless you
know all of the right bits=E2=80=94 knowing some is not good enough.

Could you suggest how else we could gain the advantages of op_eval
without it?   How can I secure my wallet under whatever scheme I like=E2=80=
=94
create a trust that requires multiparty signoff=E2=80=94 and securely have
senders pay into it without expecting them all to handle some rare and
complicated procedure for sending to me? (Or a burdensome address
which serializes a script and a large amount of data into hundreds of
characters, and which still may be unable to represent the rules I
wish to have govern my account=E2=80=94 and which the sender might mutate=
=E2=80=94
e.g. twiddling the threshold counts=E2=80=94 and cause me great
problems/confusion)

[snip]
> So far we the bitcoin addresses are (for all practical purposes) a one-to=
-one mapping between a pubkey and uint160. This mean that your wallet is de=
fined solely by your privatekeys (from which you can extract pubkeys and th=
en uint160 btc-addresses).
[snip]
> I agree that it will work and I (and bitcoin-js and blockexplorer) can of=
 change the concept of a wallet to also include scripts, but it breaks an i=
ntrinsic logic of uint160s and transactions that has so far been quite nice=
 and clean.
>
> So I also support checkmultisig to be the standard transaction type, but =
I do not appreciate the support of OP_EVAL.

On the basis of the discussion here I now oppose checkmultisig as a
standard transaction type. (Sorry, I'm not trying to be a jerk if it
came off that way, I'm not opposing it simply because you support it:)

The advantage I saw of having it was faster deployment for the
explicit escrow cases that don't need to encode the payment rules in
an address (as is needed for wallet security and trusts)... but it
seems to me that there is a serious misunderstanding that there is a
bijection between hash160s and public keys, and one between ECC
private keys and spendable transactions, and that this bijection is
desirable or even essential to bitcoin.

I'm concerned that this misunderstanding will moot the flexibility of
the script system because every script that doesn't look like a direct
mapping of hash160->pubkey->payee will be regarded as _broken_=E2=80=94 not
just useless to one app or another which could have simply chosen not
to generate those addresses=E2=80=94 but actually incompatible with bitcoin=
,
as is basically being argued here=E2=80=94 or, keeping in mind that people =
can
freely mine non-standard transactions, could this result in tools
which are rendered insecure by unexpected transaction types=E2=80=94 Will a
system that thinks HASH160 =3D IDENTITY recognize that a script which
also requires an additional secret key on the stack is unspendable?

Keeping checkmultisig alone as a standard transaction, when it's
functionally a redundant subset of OP_EVAL  (and inferior because it
reduces the txn you can place in a block) could only further that
misunderstanding. :-/