defmodule BitcoinLib.Script.OpcodeManager do
@moduledoc """
Converts back and forts from script to opcode list
"""
alias BitcoinLib.Script.Opcodes.Arithmetic
alias BitcoinLib.Script.Opcodes.{
Arithmetic,
BitwiseLogic,
Constants,
Crypto,
FlowControl,
Stack,
Locktime,
Reserved,
Splice,
PseudoWords,
Data
}
@byte 8
@zero Constants.Zero.v()
@one Constants.One.v()
@one_negate Constants.OneNegate.v()
@two Constants.Two.v()
@three Constants.Three.v()
@four Constants.Four.v()
@five Constants.Five.v()
@six Constants.Six.v()
@seven Constants.Seven.v()
@eight Constants.Eight.v()
@nine Constants.Nine.v()
@ten Constants.Ten.v()
@eleven Constants.Eleven.v()
@twelve Constants.Twelve.v()
@thirteen Constants.Thirteen.v()
@fourteen Constants.Fourteen.v()
@fifteen Constants.Fifteen.v()
@sixteen Constants.Sixteen.v()
@push_data_1 Constants.PushData1.v()
@push_data_2 Constants.PushData2.v()
@push_data_4 Constants.PushData4.v()
@nop FlowControl.Nop.v()
@if FlowControl.If.v()
@else_ FlowControl.Else.v()
@end_if FlowControl.EndIf.v()
@verify FlowControl.Verify.v()
@return FlowControl.Return.v()
@to_alt_stack Stack.ToAltStack.v()
@from_alt_stack Stack.FromAltStack.v()
@if_dup Stack.IfDup.v()
@depth Stack.Depth.v()
@drop Stack.Drop.v()
@dup Stack.Dup.v()
@rot Stack.Rot.v()
@swap Stack.Swap.v()
@two_dup Stack.TwoDup.v()
@two_over Stack.TwoOver.v()
@two_swap Stack.TwoSwap.v()
@size Splice.Size.v()
@equal BitwiseLogic.Equal.v()
@equal_verify BitwiseLogic.EqualVerify.v()
@one_add Arithmetic.OneAdd.v()
@one_sub Arithmetic.OneSub.v()
@sub Arithmetic.Sub.v()
@bool_or Arithmetic.BoolOr.v()
@less_than Arithmetic.LessThan.v()
@greater_than Arithmetic.GreaterThan.v()
@negate Arithmetic.Negate.v()
@abs Arithmetic.Abs.v()
@not_ Arithmetic.Not.v()
@min Arithmetic.Min.v()
@within Arithmetic.Within.v()
@ripemd160 Crypto.Ripemd160.v()
@sha1 Crypto.Sha1.v()
@sha256 Crypto.Sha256.v()
@hash160 Crypto.Hash160.v()
@hash256 Crypto.Hash256.v()
@code_separator Crypto.CodeSeparator.v()
@check_sig Crypto.CheckSig.v()
@check_sig_verify Crypto.CheckSigVerify.v()
@check_multi_sig Crypto.CheckMultiSig.v()
@check_multi_sig_verify Crypto.CheckMultiSigVerify.v()
@check_lock_time_verify Locktime.CheckLockTimeVerify.v()
@nop1 Reserved.Nop1.v()
@invalid_opcode PseudoWords.InvalidOpcode.v()
alias BitcoinLib.Signing.Psbt.CompactInteger
alias BitcoinLib.Script.Opcodes.Data
@doc """
Encode an opcode into a bitstring
"""
@spec encode_opcode(any) :: bitstring()
def encode_opcode(%Constants.Zero{}) do
Constants.Zero.encode()
end
def encode_opcode(%Constants.One{}) do
Constants.One.encode()
end
def encode_opcode(%Constants.OneNegate{}) do
Constants.OneNegate.encode()
end
def encode_opcode(%Constants.Two{}) do
Constants.Two.encode()
end
def encode_opcode(%Constants.Three{}) do
Constants.Three.encode()
end
def encode_opcode(%Constants.Four{}) do
Constants.Four.encode()
end
def encode_opcode(%Constants.Five{}) do
Constants.Five.encode()
end
def encode_opcode(%Constants.Six{}) do
Constants.Six.encode()
end
def encode_opcode(%Constants.Seven{}) do
Constants.Seven.encode()
end
def encode_opcode(%Constants.Eight{}) do
Constants.Eight.encode()
end
def encode_opcode(%Constants.Nine{}) do
Constants.Nine.encode()
end
def encode_opcode(%Constants.Ten{}) do
Constants.Ten.encode()
end
def encode_opcode(%Constants.Eleven{}) do
Constants.Eleven.encode()
end
def encode_opcode(%Constants.Twelve{}) do
Constants.Twelve.encode()
end
def encode_opcode(%Constants.Thirteen{}) do
Constants.Thirteen.encode()
end
def encode_opcode(%Constants.Fourteen{}) do
Constants.Fourteen.encode()
end
def encode_opcode(%Constants.Fifteen{}) do
Constants.Fifteen.encode()
end
def encode_opcode(%Constants.Sixteen{}) do
Constants.Sixteen.encode()
end
def encode_opcode(%Constants.PushData1{value: value}) do
opcode = Constants.PushData1.encode()
data = Data.encode(%Data{value: value})
<<opcode::bitstring-8, data::bitstring>>
end
def encode_opcode(%Constants.PushData2{value: value}) do
opcode = Constants.PushData2.encode()
data = Data.encode(%Data{value: value})
<<opcode::bitstring-8, data::bitstring>>
end
def encode_opcode(%Constants.PushData4{value: value}) do
opcode = Constants.PushData4.encode()
data = Data.encode(%Data{value: value})
<<opcode::bitstring-8, data::bitstring>>
end
def encode_opcode(%Stack.ToAltStack{}) do
Stack.ToAltStack.encode()
end
def encode_opcode(%Stack.FromAltStack{}) do
Stack.FromAltStack.encode()
end
def encode_opcode(%Stack.IfDup{}) do
Stack.IfDup.encode()
end
def encode_opcode(%Stack.Depth{}) do
Stack.Depth.encode()
end
def encode_opcode(%Stack.Drop{}) do
Stack.Drop.encode()
end
def encode_opcode(%Stack.Dup{}) do
Stack.Dup.encode()
end
def encode_opcode(%Stack.Rot{}) do
Stack.Rot.encode()
end
def encode_opcode(%Stack.Swap{}) do
Stack.Swap.encode()
end
def encode_opcode(%Stack.TwoDup{}) do
Stack.TwoDup.encode()
end
def encode_opcode(%Stack.TwoOver{}) do
Stack.TwoOver.encode()
end
def encode_opcode(%Stack.TwoSwap{}) do
Stack.TwoSwap.encode()
end
def encode_opcode(%Splice.Size{}) do
Splice.Size.encode()
end
def encode_opcode(%Crypto.Sha1{}) do
Crypto.Sha1.encode()
end
def encode_opcode(%Crypto.Sha256{}) do
Crypto.Sha256.encode()
end
def encode_opcode(%Crypto.Ripemd160{}) do
Crypto.Ripemd160.encode()
end
def encode_opcode(%Crypto.CodeSeparator{}) do
Crypto.CodeSeparator.encode()
end
def encode_opcode(%Crypto.Hash160{}) do
Crypto.Hash160.encode()
end
def encode_opcode(%Crypto.Hash256{}) do
Crypto.Hash256.encode()
end
def encode_opcode(%FlowControl.If{}) do
FlowControl.If.encode()
end
def encode_opcode(%FlowControl.Else{}) do
FlowControl.Else.encode()
end
def encode_opcode(%FlowControl.EndIf{}) do
FlowControl.EndIf.encode()
end
def encode_opcode(%FlowControl.Nop{}) do
FlowControl.Nop.encode()
end
def encode_opcode(%FlowControl.Verify{}) do
FlowControl.Return.encode()
end
def encode_opcode(%FlowControl.Return{}) do
FlowControl.Return.encode()
end
def encode_opcode(%BitwiseLogic.EqualVerify{}) do
BitwiseLogic.EqualVerify.encode()
end
def encode_opcode(%BitwiseLogic.Equal{}) do
BitwiseLogic.Equal.encode()
end
def encode_opcode(%Arithmetic.OneAdd{}) do
Arithmetic.OneAdd.encode()
end
def encode_opcode(%Arithmetic.OneSub{}) do
Arithmetic.OneSub.encode()
end
def encode_opcode(%Arithmetic.Sub{}) do
Arithmetic.Sub.encode()
end
def encode_opcode(%Arithmetic.BoolOr{}) do
Arithmetic.BoolOr.encode()
end
def encode_opcode(%Arithmetic.LessThan{}) do
Arithmetic.LessThan.encode()
end
def encode_opcode(%Arithmetic.GreaterThan{}) do
Arithmetic.GreaterThan.encode()
end
def encode_opcode(%Arithmetic.Negate{}) do
Arithmetic.Negate.encode()
end
def encode_opcode(%Arithmetic.Abs{}) do
Arithmetic.Abs.encode()
end
def encode_opcode(%Arithmetic.Not{}) do
Arithmetic.Not.encode()
end
def encode_opcode(%Arithmetic.Min{}) do
Arithmetic.Min.encode()
end
def encode_opcode(%Arithmetic.Within{}) do
Arithmetic.Within.encode()
end
def encode_opcode(%Crypto.CheckSig{}) do
Crypto.CheckSig.encode()
end
def encode_opcode(%Crypto.CheckSigVerify{}) do
Crypto.CheckSigVerify.encode()
end
def encode_opcode(%Crypto.CheckMultiSig{}) do
Crypto.CheckMultiSig.encode()
end
def encode_opcode(%Crypto.CheckMultiSigVerify{}) do
Locktime.CheckLockTimeVerify.encode()
end
def encode_opcode(%Locktime.CheckLockTimeVerify{}) do
Crypto.CheckMultiSigVerify.encode()
end
def encode_opcode(%Reserved.Nop1{}) do
Reserved.Nop1.encode()
end
def encode_opcode(%PseudoWords.InvalidOpcode{}) do
PseudoWords.InvalidOpcode.encode()
end
def encode_opcode(%Data{} = data) do
Data.encode(data)
end
@doc """
Extract the opcode on the top of the stack given as an argument
"""
@spec extract_from_script(bitstring(), bitstring()) ::
{:empty_script}
| {:opcode, any(), bitstring()}
| {:data, bitstring(), bitstring()}
| {:error, binary(), bitstring()}
def extract_from_script(<<>>, _whole_script), do: {:empty_script}
def extract_from_script(<<@zero::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Zero{}, remaining}
end
def extract_from_script(<<@one::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.One{}, remaining}
end
def extract_from_script(<<@one_negate::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.OneNegate{}, remaining}
end
def extract_from_script(<<@two::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Two{}, remaining}
end
def extract_from_script(<<@three::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Three{}, remaining}
end
def extract_from_script(<<@four::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Four{}, remaining}
end
def extract_from_script(<<@five::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Five{}, remaining}
end
def extract_from_script(<<@six::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Six{}, remaining}
end
def extract_from_script(<<@seven::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Seven{}, remaining}
end
def extract_from_script(<<@eight::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Eight{}, remaining}
end
def extract_from_script(<<@nine::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Nine{}, remaining}
end
def extract_from_script(<<@ten::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Ten{}, remaining}
end
def extract_from_script(<<@eleven::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Eleven{}, remaining}
end
def extract_from_script(<<@twelve::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Twelve{}, remaining}
end
def extract_from_script(<<@thirteen::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Thirteen{}, remaining}
end
def extract_from_script(<<@fourteen::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Fourteen{}, remaining}
end
def extract_from_script(<<@fifteen::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Fifteen{}, remaining}
end
def extract_from_script(<<@sixteen::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Constants.Sixteen{}, remaining}
end
def extract_from_script(
<<@push_data_1::8, remaining::bitstring>>,
_whole_script
) do
if byte_size(remaining) >= 1 do
<<data_byte_size::8, remaining::bitstring>> = remaining
remaining_size = byte_size(remaining)
if data_byte_size <= remaining_size do
<<data::bitstring-size(data_byte_size * 8), remaining::bitstring>> = remaining
{:opcode, %Constants.PushData1{value: data}, remaining}
else
{
:error,
"OP_PUSHDATA1: trying to get #{data_byte_size} bytes out of a #{remaining_size} bytes binary",
remaining
}
end
else
{:error, "no data while trying to extract a OP_PUSHDATA1", remaining}
end
end
def extract_from_script(
<<@push_data_2::8, remaining::bitstring>>,
_whole_script
) do
if byte_size(remaining) >= 2 do
<<data_byte_size::little-16, remaining::bitstring>> = remaining
remaining_size = byte_size(remaining)
if data_byte_size <= remaining_size do
<<data::bitstring-size(data_byte_size * 8), remaining::bitstring>> = remaining
{:opcode, %Constants.PushData2{value: data}, remaining}
else
{
:error,
"OP_PUSHDATA2: trying to get #{data_byte_size} bytes out of a #{remaining_size} bytes binary",
remaining
}
end
else
{:error, "no data while trying to extract a OP_PUSHDATA2", remaining}
end
end
def extract_from_script(
<<@push_data_4::8, remaining::bitstring>>,
_whole_script
) do
if byte_size(remaining) >= 2 do
<<data_byte_size::little-32, remaining::bitstring>> = remaining
remaining_size = byte_size(remaining)
if data_byte_size <= remaining_size do
<<data::bitstring-size(data_byte_size * 8), remaining::bitstring>> = remaining
{:opcode, %Constants.PushData4{value: data}, remaining}
else
{
:error,
"OP_PUSHDATA4: trying to get #{data_byte_size} bytes out of a #{remaining_size} bytes binary",
remaining
}
end
else
{:error, "no data while trying to extract a OP_PUSHDATA4", remaining}
end
end
def extract_from_script(<<@nop::8, remaining::bitstring>>, _whole_script) do
{:opcode, %FlowControl.Nop{}, remaining}
end
def extract_from_script(<<@if::8, remaining::bitstring>>, _whole_script) do
{:opcode, %FlowControl.If{}, remaining}
end
def extract_from_script(<<@else_::8, remaining::bitstring>>, _whole_script) do
{:opcode, %FlowControl.Else{}, remaining}
end
def extract_from_script(<<@end_if::8, remaining::bitstring>>, _whole_script) do
{:opcode, %FlowControl.EndIf{}, remaining}
end
def extract_from_script(<<@verify::8, remaining::bitstring>>, _whole_script) do
{:opcode, %FlowControl.Verify{}, remaining}
end
def extract_from_script(<<@return::8, remaining::bitstring>>, _whole_script) do
{:opcode, %FlowControl.Return{}, remaining}
end
def extract_from_script(<<@to_alt_stack::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Stack.ToAltStack{}, remaining}
end
def extract_from_script(<<@from_alt_stack::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Stack.FromAltStack{}, remaining}
end
def extract_from_script(<<@if_dup::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Stack.IfDup{}, remaining}
end
def extract_from_script(<<@depth::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Stack.Depth{}, remaining}
end
def extract_from_script(<<@drop::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Stack.Drop{}, remaining}
end
def extract_from_script(<<@dup::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Stack.Dup{}, remaining}
end
def extract_from_script(<<@rot::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Stack.Rot{}, remaining}
end
def extract_from_script(<<@swap::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Stack.Swap{}, remaining}
end
def extract_from_script(<<@two_dup::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Stack.TwoDup{}, remaining}
end
def extract_from_script(<<@two_over::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Stack.TwoOver{}, remaining}
end
def extract_from_script(<<@two_swap::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Stack.TwoSwap{}, remaining}
end
def extract_from_script(<<@size::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Splice.Size{}, remaining}
end
def extract_from_script(<<@equal::8, remaining::bitstring>>, _whole_script) do
{:opcode, %BitwiseLogic.Equal{}, remaining}
end
def extract_from_script(<<@equal_verify::8, remaining::bitstring>>, _whole_script) do
{:opcode, %BitwiseLogic.EqualVerify{}, remaining}
end
def extract_from_script(<<@one_add::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Arithmetic.OneAdd{}, remaining}
end
def extract_from_script(<<@one_sub::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Arithmetic.OneSub{}, remaining}
end
def extract_from_script(<<@sub::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Arithmetic.Sub{}, remaining}
end
def extract_from_script(<<@bool_or::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Arithmetic.BoolOr{}, remaining}
end
def extract_from_script(<<@less_than::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Arithmetic.LessThan{}, remaining}
end
def extract_from_script(<<@greater_than::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Arithmetic.GreaterThan{}, remaining}
end
def extract_from_script(<<@negate::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Arithmetic.Negate{}, remaining}
end
def extract_from_script(<<@abs::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Arithmetic.Abs{}, remaining}
end
def extract_from_script(<<@not_::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Arithmetic.Not{}, remaining}
end
def extract_from_script(<<@min::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Arithmetic.Min{}, remaining}
end
def extract_from_script(<<@within::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Arithmetic.Within{}, remaining}
end
def extract_from_script(<<@sha1::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Crypto.Sha1{}, remaining}
end
def extract_from_script(<<@sha256::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Crypto.Sha256{}, remaining}
end
def extract_from_script(<<@ripemd160::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Crypto.Ripemd160{}, remaining}
end
def extract_from_script(<<@hash160::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Crypto.Hash160{}, remaining}
end
def extract_from_script(<<@hash256::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Crypto.Hash256{}, remaining}
end
def extract_from_script(<<@code_separator::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Crypto.CodeSeparator{}, remaining}
end
def extract_from_script(<<@check_sig::8, remaining::bitstring>>, whole_script) do
{:opcode, %Crypto.CheckSig{script: whole_script}, remaining}
end
def extract_from_script(<<@check_sig_verify::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Crypto.CheckSigVerify{}, remaining}
end
def extract_from_script(<<@check_multi_sig::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Crypto.CheckMultiSig{}, remaining}
end
def extract_from_script(<<@check_multi_sig_verify::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Crypto.CheckMultiSigVerify{}, remaining}
end
def extract_from_script(<<@nop1::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Reserved.Nop1{}, remaining}
end
def extract_from_script(<<@invalid_opcode::8, remaining::bitstring>>, _whole_script) do
{:opcode, %PseudoWords.InvalidOpcode{}, remaining}
end
def extract_from_script(<<@check_lock_time_verify::8, remaining::bitstring>>, _whole_script) do
{:opcode, %Locktime.CheckLockTimeVerify{}, remaining}
end
def extract_from_script(<<unknown_opcode::8, remaining::bitstring>> = script, _whole_script) do
case unknown_opcode do
opcode when opcode in 0x01..0x4B -> extract_and_return_data(script)
_ -> {:error, "trying to extract an unknown opcode: #{unknown_opcode}", remaining}
end
end
defp extract_and_return_data(script) do
%CompactInteger{value: data_length, remaining: remaining} =
CompactInteger.extract_from(script)
remaining_size = byte_size(remaining)
if data_length <= remaining_size do
bits_data_length = data_length * @byte
<<data::bitstring-size(bits_data_length), remaining::bitstring>> = remaining
{:data, data, remaining}
else
{
:error,
"trying to get #{data_length} bytes out of a #{remaining_size} bytes binary",
remaining
}
end
end
end
