zecfoundation
/
parity-zcash
mirror of https://github.com/ZcashFoundation/parity-zcash.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

replace try with ? in script

This commit is contained in:
Svyatoslav Nikolsky 2018-03-02 10:56:37 +03:00
parent 916feb1e65
commit efbb4d4b57
3 changed files with 102 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

170
script/src/interpreter.rs
View File

@ -175,7 +175,7 @@ fn check_signature_encoding(sig: &[u8], flags: &VerificationFlags, version: Sign
} }
if flags.verify_low_s { if flags.verify_low_s {
try!(is_low_der_signature(sig)); is_low_der_signature(sig)?;
} }
if flags.verify_strictenc && !is_defined_hashtype_signature(version, sig) { if flags.verify_strictenc && !is_defined_hashtype_signature(version, sig) {
@ -258,13 +258,13 @@ pub fn verify_script(
let mut stack_copy = Stack::new(); let mut stack_copy = Stack::new();
let mut had_witness = false; let mut had_witness = false;
try!(eval_script(&mut stack, script_sig, flags, checker, version)); eval_script(&mut stack, script_sig, flags, checker, version)?;
if flags.verify_p2sh { if flags.verify_p2sh {
stack_copy = stack.clone(); stack_copy = stack.clone();
} }
let res = try!(eval_script(&mut stack, script_pubkey, flags, checker, version)); let res = eval_script(&mut stack, script_pubkey, flags, checker, version)?;
if !res { if !res {
return Err(Error::EvalFalse); return Err(Error::EvalFalse);
} }
@ -298,9 +298,9 @@ pub fn verify_script(
// an empty stack and the EvalScript above would return false. // an empty stack and the EvalScript above would return false.
assert!(!stack.is_empty()); assert!(!stack.is_empty());
let pubkey2: Script = try!(stack.pop()).into(); let pubkey2: Script = stack.pop()?.into();
let res = try!(eval_script(&mut stack, &pubkey2, flags, checker, version)); let res = eval_script(&mut stack, &pubkey2, flags, checker, version)?;
if !res { if !res {
return Err(Error::EvalFalse); return Err(Error::EvalFalse);
} }
@ -597,7 +597,7 @@ pub fn eval_script(
// Thus as a special case we tell CScriptNum to accept up // Thus as a special case we tell CScriptNum to accept up
// to 5-byte bignums, which are good until 2**39-1, well // to 5-byte bignums, which are good until 2**39-1, well
// beyond the 2**32-1 limit of the nLockTime field itself. // beyond the 2**32-1 limit of the nLockTime field itself.
let lock_time = try!(Num::from_slice(try!(stack.last()), flags.verify_minimaldata, 5)); let lock_time = Num::from_slice(stack.last()?, flags.verify_minimaldata, 5)?;
// In the rare event that the argument may be < 0 due to // In the rare event that the argument may be < 0 due to
// some arithmetic being done first, you can always use // some arithmetic being done first, you can always use
@ -615,7 +615,7 @@ pub fn eval_script(
}, },
Opcode::OP_CHECKSEQUENCEVERIFY => { Opcode::OP_CHECKSEQUENCEVERIFY => {
if flags.verify_checksequence { if flags.verify_checksequence {
let sequence = try!(Num::from_slice(try!(stack.last()), flags.verify_minimaldata, 5)); let sequence = Num::from_slice(stack.last()?, flags.verify_minimaldata, 5)?;
if sequence.is_negative() { if sequence.is_negative() {
return Err(Error::NegativeLocktime); return Err(Error::NegativeLocktime);
@ -644,7 +644,7 @@ pub fn eval_script(
Opcode::OP_IF | Opcode::OP_NOTIF => { Opcode::OP_IF | Opcode::OP_NOTIF => {
let mut exec_value = false; let mut exec_value = false;
if executing { if executing {
exec_value = cast_to_bool(&try!(stack.pop().map_err(|_| Error::UnbalancedConditional))); exec_value = cast_to_bool(&stack.pop().map_err(|_| Error::UnbalancedConditional)?);
if opcode == Opcode::OP_NOTIF { if opcode == Opcode::OP_NOTIF {
exec_value = !exec_value; exec_value = !exec_value;
} }
@ -666,7 +666,7 @@ pub fn eval_script(
exec_stack.pop(); exec_stack.pop();
}, },
Opcode::OP_VERIFY => { Opcode::OP_VERIFY => {
let exec_value = cast_to_bool(&try!(stack.pop())); let exec_value = cast_to_bool(&stack.pop()?);
if !exec_value { if !exec_value {
return Err(Error::Verify); return Err(Error::Verify);
} }
@ -675,32 +675,32 @@ pub fn eval_script(
return Err(Error::ReturnOpcode); return Err(Error::ReturnOpcode);
}, },
Opcode::OP_TOALTSTACK => { Opcode::OP_TOALTSTACK => {
altstack.push(try!(stack.pop())); altstack.push(stack.pop()?);
}, },
Opcode::OP_FROMALTSTACK => { Opcode::OP_FROMALTSTACK => {
stack.push(try!(altstack.pop().map_err(|_| Error::InvalidAltstackOperation))); stack.push(altstack.pop().map_err(|_| Error::InvalidAltstackOperation)?);
}, },
Opcode::OP_2DROP => { Opcode::OP_2DROP => {
try!(stack.drop(2)); stack.drop(2)?;
}, },
Opcode::OP_2DUP => { Opcode::OP_2DUP => {
try!(stack.dup(2)); stack.dup(2)?;
}, },
Opcode::OP_3DUP => { Opcode::OP_3DUP => {
try!(stack.dup(3)); stack.dup(3)?;
}, },
Opcode::OP_2OVER => { Opcode::OP_2OVER => {
try!(stack.over(2)); stack.over(2)?;
}, },
Opcode::OP_2ROT => { Opcode::OP_2ROT => {
try!(stack.rot(2)); stack.rot(2)?;
}, },
Opcode::OP_2SWAP => { Opcode::OP_2SWAP => {
try!(stack.swap(2)); stack.swap(2)?;
}, },
Opcode::OP_IFDUP => { Opcode::OP_IFDUP => {
if cast_to_bool(try!(stack.last())) { if cast_to_bool(stack.last()?) {
try!(stack.dup(1)); stack.dup(1)?;
} }
}, },
Opcode::OP_DEPTH => { Opcode::OP_DEPTH => {
@ -708,46 +708,46 @@ pub fn eval_script(
stack.push(depth.to_bytes()); stack.push(depth.to_bytes());
}, },
Opcode::OP_DROP => { Opcode::OP_DROP => {
try!(stack.pop()); stack.pop()?;
}, },
Opcode::OP_DUP => { Opcode::OP_DUP => {
try!(stack.dup(1)); stack.dup(1)?;
}, },
Opcode::OP_NIP => { Opcode::OP_NIP => {
try!(stack.nip()); stack.nip()?;
}, },
Opcode::OP_OVER => { Opcode::OP_OVER => {
try!(stack.over(1)); stack.over(1)?;
}, },
Opcode::OP_PICK | Opcode::OP_ROLL => { Opcode::OP_PICK | Opcode::OP_ROLL => {
let n: i64 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)).into(); let n: i64 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?.into();
if n < 0 || n >= stack.len() as i64 { if n < 0 || n >= stack.len() as i64 {
return Err(Error::InvalidStackOperation); return Err(Error::InvalidStackOperation);
} }
let v = match opcode { let v = match opcode {
Opcode::OP_PICK => try!(stack.top(n as usize)).clone(), Opcode::OP_PICK => stack.top(n as usize)?.clone(),
_ => try!(stack.remove(n as usize)), _ => stack.remove(n as usize)?,
}; };
stack.push(v); stack.push(v);
}, },
Opcode::OP_ROT => { Opcode::OP_ROT => {
try!(stack.rot(1)); stack.rot(1)?;
}, },
Opcode::OP_SWAP => { Opcode::OP_SWAP => {
try!(stack.swap(1)); stack.swap(1)?;
}, },
Opcode::OP_TUCK => { Opcode::OP_TUCK => {
try!(stack.tuck()); stack.tuck()?;
}, },
Opcode::OP_SIZE => { Opcode::OP_SIZE => {
let n = Num::from(try!(stack.last()).len()); let n = Num::from(stack.last()?.len());
stack.push(n.to_bytes()); stack.push(n.to_bytes());
}, },
Opcode::OP_EQUAL => { Opcode::OP_EQUAL => {
let v1 = try!(stack.pop()); let v1 = stack.pop()?;
let v2 = try!(stack.pop()); let v2 = stack.pop()?;
if v1 == v2 { if v1 == v2 {
stack.push(vec![1].into()); stack.push(vec![1].into());
} else { } else {
@ -755,116 +755,116 @@ pub fn eval_script(
} }
}, },
Opcode::OP_EQUALVERIFY => { Opcode::OP_EQUALVERIFY => {
let equal = try!(stack.pop()) == try!(stack.pop()); let equal = stack.pop()? == stack.pop()?;
if !equal { if !equal {
return Err(Error::EqualVerify); return Err(Error::EqualVerify);
} }
}, },
Opcode::OP_1ADD => { Opcode::OP_1ADD => {
let n = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)) + 1.into(); let n = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)? + 1.into();
stack.push(n.to_bytes()); stack.push(n.to_bytes());
}, },
Opcode::OP_1SUB => { Opcode::OP_1SUB => {
let n = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)) - 1.into(); let n = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)? - 1.into();
stack.push(n.to_bytes()); stack.push(n.to_bytes());
}, },
Opcode::OP_NEGATE => { Opcode::OP_NEGATE => {
let n = -try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let n = -Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
stack.push(n.to_bytes()); stack.push(n.to_bytes());
}, },
Opcode::OP_ABS => { Opcode::OP_ABS => {
let n = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)).abs(); let n = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?.abs();
stack.push(n.to_bytes()); stack.push(n.to_bytes());
}, },
Opcode::OP_NOT => { Opcode::OP_NOT => {
let n = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)).is_zero(); let n = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?.is_zero();
let n = Num::from(n); let n = Num::from(n);
stack.push(n.to_bytes()); stack.push(n.to_bytes());
}, },
Opcode::OP_0NOTEQUAL => { Opcode::OP_0NOTEQUAL => {
let n = !try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)).is_zero(); let n = !Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?.is_zero();
let n = Num::from(n); let n = Num::from(n);
stack.push(n.to_bytes()); stack.push(n.to_bytes());
}, },
Opcode::OP_ADD => { Opcode::OP_ADD => {
let v1 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v1 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v2 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v2 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
stack.push((v1 + v2).to_bytes()); stack.push((v1 + v2).to_bytes());
}, },
Opcode::OP_SUB => { Opcode::OP_SUB => {
let v1 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v1 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v2 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v2 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
stack.push((v2 - v1).to_bytes()); stack.push((v2 - v1).to_bytes());
}, },
Opcode::OP_BOOLAND => { Opcode::OP_BOOLAND => {
let v1 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v1 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v2 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v2 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v = Num::from(!v1.is_zero() && !v2.is_zero()); let v = Num::from(!v1.is_zero() && !v2.is_zero());
stack.push(v.to_bytes()); stack.push(v.to_bytes());
}, },
Opcode::OP_BOOLOR => { Opcode::OP_BOOLOR => {
let v1 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v1 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v2 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v2 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v = Num::from(!v1.is_zero() || !v2.is_zero()); let v = Num::from(!v1.is_zero() || !v2.is_zero());
stack.push(v.to_bytes()); stack.push(v.to_bytes());
}, },
Opcode::OP_NUMEQUAL => { Opcode::OP_NUMEQUAL => {
let v1 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v1 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v2 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v2 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v = Num::from(v1 == v2); let v = Num::from(v1 == v2);
stack.push(v.to_bytes()); stack.push(v.to_bytes());
}, },
Opcode::OP_NUMEQUALVERIFY => { Opcode::OP_NUMEQUALVERIFY => {
let v1 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v1 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v2 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v2 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
if v1 != v2 { if v1 != v2 {
return Err(Error::NumEqualVerify); return Err(Error::NumEqualVerify);
} }
}, },
Opcode::OP_NUMNOTEQUAL => { Opcode::OP_NUMNOTEQUAL => {
let v1 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v1 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v2 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v2 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v = Num::from(v1 != v2); let v = Num::from(v1 != v2);
stack.push(v.to_bytes()); stack.push(v.to_bytes());
}, },
Opcode::OP_LESSTHAN => { Opcode::OP_LESSTHAN => {
let v1 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v1 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v2 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v2 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v = Num::from(v1 > v2); let v = Num::from(v1 > v2);
stack.push(v.to_bytes()); stack.push(v.to_bytes());
}, },
Opcode::OP_GREATERTHAN => { Opcode::OP_GREATERTHAN => {
let v1 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v1 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v2 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v2 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v = Num::from(v1 < v2); let v = Num::from(v1 < v2);
stack.push(v.to_bytes()); stack.push(v.to_bytes());
}, },
Opcode::OP_LESSTHANOREQUAL => { Opcode::OP_LESSTHANOREQUAL => {
let v1 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v1 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v2 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v2 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v = Num::from(v1 >= v2); let v = Num::from(v1 >= v2);
stack.push(v.to_bytes()); stack.push(v.to_bytes());
}, },
Opcode::OP_GREATERTHANOREQUAL => { Opcode::OP_GREATERTHANOREQUAL => {
let v1 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v1 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v2 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v2 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v = Num::from(v1 <= v2); let v = Num::from(v1 <= v2);
stack.push(v.to_bytes()); stack.push(v.to_bytes());
}, },
Opcode::OP_MIN => { Opcode::OP_MIN => {
let v1 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v1 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v2 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v2 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
stack.push(cmp::min(v1, v2).to_bytes()); stack.push(cmp::min(v1, v2).to_bytes());
}, },
Opcode::OP_MAX => { Opcode::OP_MAX => {
let v1 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v1 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v2 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v2 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
stack.push(cmp::max(v1, v2).to_bytes()); stack.push(cmp::max(v1, v2).to_bytes());
}, },
Opcode::OP_WITHIN => { Opcode::OP_WITHIN => {
let v1 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v1 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v2 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v2 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
let v3 = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let v3 = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
if v2 <= v3 && v3 < v1 { if v2 <= v3 && v3 < v1 {
stack.push(vec![1].into()); stack.push(vec![1].into());
} else { } else {
@ -872,31 +872,31 @@ pub fn eval_script(
} }
}, },
Opcode::OP_RIPEMD160 => { Opcode::OP_RIPEMD160 => {
let v = ripemd160(&try!(stack.pop())); let v = ripemd160(&stack.pop()?);
stack.push(v.to_vec().into()); stack.push(v.to_vec().into());
}, },
Opcode::OP_SHA1 => { Opcode::OP_SHA1 => {
let v = sha1(&try!(stack.pop())); let v = sha1(&stack.pop()?);
stack.push(v.to_vec().into()); stack.push(v.to_vec().into());
}, },
Opcode::OP_SHA256 => { Opcode::OP_SHA256 => {
let v = sha256(&try!(stack.pop())); let v = sha256(&stack.pop()?);
stack.push(v.to_vec().into()); stack.push(v.to_vec().into());
}, },
Opcode::OP_HASH160 => { Opcode::OP_HASH160 => {
let v = dhash160(&try!(stack.pop())); let v = dhash160(&stack.pop()?);
stack.push(v.to_vec().into()); stack.push(v.to_vec().into());
}, },
Opcode::OP_HASH256 => { Opcode::OP_HASH256 => {
let v = dhash256(&try!(stack.pop())); let v = dhash256(&stack.pop()?);
stack.push(v.to_vec().into()); stack.push(v.to_vec().into());
}, },
Opcode::OP_CODESEPARATOR => { Opcode::OP_CODESEPARATOR => {
begincode = pc; begincode = pc;
}, },
Opcode::OP_CHECKSIG | Opcode::OP_CHECKSIGVERIFY => { Opcode::OP_CHECKSIG | Opcode::OP_CHECKSIGVERIFY => {
let pubkey = try!(stack.pop()); let pubkey = stack.pop()?;
let signature = try!(stack.pop()); let signature = stack.pop()?;
let sighash = parse_hash_type(version, &signature); let sighash = parse_hash_type(version, &signature);
let mut subscript = script.subscript(begincode); let mut subscript = script.subscript(begincode);
match version { match version {
@ -908,8 +908,8 @@ pub fn eval_script(
}, },
} }
try!(check_signature_encoding(&signature, flags, version)); check_signature_encoding(&signature, flags, version)?;
try!(check_pubkey_encoding(&pubkey, flags)); check_pubkey_encoding(&pubkey, flags)?;
let success = check_signature(checker, signature.into(), pubkey.into(), &subscript, version); let success = check_signature(checker, signature.into(), pubkey.into(), &subscript, version);
match opcode { match opcode {
@ -927,21 +927,21 @@ pub fn eval_script(
} }
}, },
Opcode::OP_CHECKMULTISIG | Opcode::OP_CHECKMULTISIGVERIFY => { Opcode::OP_CHECKMULTISIG | Opcode::OP_CHECKMULTISIGVERIFY => {
let keys_count = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let keys_count = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
if keys_count < 0.into() || keys_count > script::MAX_PUBKEYS_PER_MULTISIG.into() { if keys_count < 0.into() || keys_count > script::MAX_PUBKEYS_PER_MULTISIG.into() {
return Err(Error::PubkeyCount); return Err(Error::PubkeyCount);
} }
let keys_count: usize = keys_count.into(); let keys_count: usize = keys_count.into();
let keys: Vec<_> = try!((0..keys_count).into_iter().map(|_| stack.pop()).collect()); let keys = (0..keys_count).into_iter().map(|_| stack.pop()).collect::<Result<Vec<_>, _>>()?;
let sigs_count = try!(Num::from_slice(&try!(stack.pop()), flags.verify_minimaldata, 4)); let sigs_count = Num::from_slice(&stack.pop()?, flags.verify_minimaldata, 4)?;
if sigs_count < 0.into() || sigs_count > keys_count.into() { if sigs_count < 0.into() || sigs_count > keys_count.into() {
return Err(Error::SigCount); return Err(Error::SigCount);
} }
let sigs_count: usize = sigs_count.into(); let sigs_count: usize = sigs_count.into();
let sigs: Vec<_> = try!((0..sigs_count).into_iter().map(|_| stack.pop()).collect()); let sigs = (0..sigs_count).into_iter().map(|_| stack.pop()).collect::<Result<Vec<_>, _>>()?;
let mut subscript = script.subscript(begincode); let mut subscript = script.subscript(begincode);
@ -965,8 +965,8 @@ pub fn eval_script(
let key = keys[k].clone(); let key = keys[k].clone();
let sig = sigs[s].clone(); let sig = sigs[s].clone();
try!(check_signature_encoding(&sig, flags, version)); check_signature_encoding(&sig, flags, version)?;
try!(check_pubkey_encoding(&key, flags)); check_pubkey_encoding(&key, flags)?;
let ok = check_signature(checker, sig.into(), key.into(), &subscript, version); let ok = check_signature(checker, sig.into(), key.into(), &subscript, version);
if ok { if ok {
@ -977,7 +977,7 @@ pub fn eval_script(
success = sigs.len() - s <= keys.len() - k; success = sigs.len() - s <= keys.len() - k;
} }
if !try!(stack.pop()).is_empty() && flags.verify_nulldummy { if !stack.pop()?.is_empty() && flags.verify_nulldummy {
return Err(Error::SignatureNullDummy); return Err(Error::SignatureNullDummy);
} }
@ -1019,7 +1019,7 @@ pub fn eval_script(
} }
let success = !stack.is_empty() && { let success = !stack.is_empty() && {
let last = try!(stack.last()); let last = stack.last()?;
cast_to_bool(last) cast_to_bool(last)
}; };

16
script/src/script.rs
View File

@ -250,7 +250,7 @@ impl Script {
} }
pub fn get_instruction(&self, position: usize) -> Result<Instruction, Error> { pub fn get_instruction(&self, position: usize) -> Result<Instruction, Error> {
let opcode = try!(self.get_opcode(position)); let opcode = self.get_opcode(position)?;
let instruction = match opcode { let instruction = match opcode {
Opcode::OP_PUSHDATA1 | Opcode::OP_PUSHDATA1 |
Opcode::OP_PUSHDATA2 | Opcode::OP_PUSHDATA2 |
@ -261,9 +261,9 @@ impl Script {
_ => 4, _ => 4,
}; };
let slice = try!(self.take(position + 1, len)); let slice = self.take(position + 1, len)?;
let n = try!(read_usize(slice, len)); let n = read_usize(slice, len)?;
let bytes = try!(self.take(position + 1 + len, n)); let bytes = self.take(position + 1 + len, n)?;
Instruction { Instruction {
opcode: opcode, opcode: opcode,
step: len + n + 1, step: len + n + 1,
@ -271,7 +271,7 @@ impl Script {
} }
}, },
o if o <= Opcode::OP_PUSHBYTES_75 => { o if o <= Opcode::OP_PUSHBYTES_75 => {
let bytes = try!(self.take(position + 1, opcode as usize)); let bytes = self.take(position + 1, opcode as usize)?;
Instruction { Instruction {
opcode: o, opcode: o,
step: opcode as usize + 1, step: opcode as usize + 1,
@ -436,7 +436,7 @@ impl Script {
while pc < self.len() - 2 { while pc < self.len() - 2 {
let instruction = self.get_instruction(pc).expect("this method depends on previous check in script_type()"); let instruction = self.get_instruction(pc).expect("this method depends on previous check in script_type()");
let data = instruction.data.expect("this method depends on previous check in script_type()"); let data = instruction.data.expect("this method depends on previous check in script_type()");
let address = try!(Public::from_slice(data)).address_hash(); let address = Public::from_slice(data)?.address_hash();
addresses.push(ScriptAddress::new_p2pkh(address)); addresses.push(ScriptAddress::new_p2pkh(address));
pc += instruction.step; pc += instruction.step;
} }
@ -559,8 +559,8 @@ impl fmt::Display for Script {
}; };
match instruction.data { match instruction.data {
Some(data) => try!(writeln!(f, "{:?} 0x{:?}", instruction.opcode, Bytes::from(data.to_vec()))), Some(data) => writeln!(f, "{:?} 0x{:?}", instruction.opcode, Bytes::from(data.to_vec()))?,
None => try!(writeln!(f, "{:?}", instruction.opcode)), None => writeln!(f, "{:?}", instruction.opcode)?,
} }
pc += instruction.step; pc += instruction.step;

18
script/src/stack.rs
View File

@ -62,20 +62,20 @@ impl<T> Stack<T> {
#[inline] #[inline]
pub fn top(&self, i: usize) -> Result<&T, Error> { pub fn top(&self, i: usize) -> Result<&T, Error> {
let pos = i + 1; let pos = i + 1;
try!(self.require(pos)); self.require(pos)?;
Ok(&self.data[self.data.len() - pos]) Ok(&self.data[self.data.len() - pos])
} }
#[inline] #[inline]
pub fn remove(&mut self, i: usize) -> Result<T, Error> { pub fn remove(&mut self, i: usize) -> Result<T, Error> {
let pos = i + 1; let pos = i + 1;
try!(self.require(pos)); self.require(pos)?;
let to_remove = self.data.len() - pos; let to_remove = self.data.len() - pos;
Ok(self.data.remove(to_remove)) Ok(self.data.remove(to_remove))
} }
pub fn drop(&mut self, i: usize) -> Result<(), Error> { pub fn drop(&mut self, i: usize) -> Result<(), Error> {
try!(self.require(i)); self.require(i)?;
let mut j = i; let mut j = i;
while j > 0 { while j > 0 {
self.data.pop(); self.data.pop();
@ -85,7 +85,7 @@ impl<T> Stack<T> {
} }
pub fn dup(&mut self, i: usize) -> Result<(), Error> where T: Clone { pub fn dup(&mut self, i: usize) -> Result<(), Error> where T: Clone {
try!(self.require(i)); self.require(i)?;
let mut j = i; let mut j = i;
while j > 0 { while j > 0 {
let v = self.data[self.data.len() - i].clone(); let v = self.data[self.data.len() - i].clone();
@ -97,7 +97,7 @@ impl<T> Stack<T> {
pub fn over(&mut self, i: usize) -> Result<(), Error> where T: Clone { pub fn over(&mut self, i: usize) -> Result<(), Error> where T: Clone {
let mut j = i * 2; let mut j = i * 2;
try!(self.require(j)); self.require(j)?;
let to_clone = j; let to_clone = j;
while j > i { while j > i {
let v = self.data[self.data.len() - to_clone].clone(); let v = self.data[self.data.len() - to_clone].clone();
@ -109,7 +109,7 @@ impl<T> Stack<T> {
pub fn rot(&mut self, i: usize) -> Result<(), Error> { pub fn rot(&mut self, i: usize) -> Result<(), Error> {
let mut j = i * 3; let mut j = i * 3;
try!(self.require(j)); self.require(j)?;
let to_remove = self.data.len() - j; let to_remove = self.data.len() - j;
let limit = j - i; let limit = j - i;
while j > limit { while j > limit {
@ -123,7 +123,7 @@ impl<T> Stack<T> {
pub fn swap(&mut self, i: usize) -> Result<(), Error> { pub fn swap(&mut self, i: usize) -> Result<(), Error> {
let mut j = i * 2; let mut j = i * 2;
let mut k = i; let mut k = i;
try!(self.require(j)); self.require(j)?;
let len = self.data.len(); let len = self.data.len();
while k > 0 { while k > 0 {
self.data.swap(len - j, len - k); self.data.swap(len - j, len - k);
@ -134,14 +134,14 @@ impl<T> Stack<T> {
} }
pub fn nip(&mut self) -> Result<(), Error> { pub fn nip(&mut self) -> Result<(), Error> {
try!(self.require(2)); self.require(2)?;
let len = self.data.len(); let len = self.data.len();
self.data.swap_remove(len - 2); self.data.swap_remove(len - 2);
Ok(()) Ok(())
} }
pub fn tuck(&mut self) -> Result<(), Error> where T: Clone { pub fn tuck(&mut self) -> Result<(), Error> where T: Clone {
try!(self.require(2)); self.require(2)?;
let len = self.data.len(); let len = self.data.len();
let v = self.data[len - 1].clone(); let v = self.data[len - 1].clone();
self.data.insert(len - 2, v); self.data.insert(len - 2, v);