use torba parsing for addresses too, erase old code

lbrynet/wallet/server/block_processor.py

@@ -10,7 +10,7 @@ from torba.server.block_processor import BlockProcessor
 from lbrynet.schema.uri import parse_lbry_uri
 from lbrynet.schema.claim import Claim
 
-from lbrynet.wallet.server.model import NameClaim, ClaimInfo, ClaimUpdate, ClaimSupport
+from lbrynet.extras.wallet.server.model import ClaimInfo
 
 
 class LBRYBlockProcessor(BlockProcessor):

lbrynet/wallet/server/coin.py

@@ -1,25 +1,22 @@
 import struct
 
-from torba.server.script import ScriptPubKey, _match_ops, OpCodes
+from lbrynet.extras.wallet.script import OutputScript
+from torba.server.script import ScriptPubKey, OpCodes
 from torba.server.util import cachedproperty
 from torba.server.hash import hash_to_hex_str, HASHX_LEN
 from hashlib import sha256
 from torba.server.coins import Coin, CoinError
 
-from lbrynet.wallet.server.opcodes import decode_claim_script, opcodes as lbry_opcodes
-
 
 class LBC(Coin):
     from .session import LBRYElectrumX
     from .block_processor import LBRYBlockProcessor
-    from .tx import LBRYDeserializer
     from .daemon import LBCDaemon
     from .db import LBRYDB
     DAEMON = LBCDaemon
     SESSIONCLS = LBRYElectrumX
     BLOCK_PROCESSOR = LBRYBlockProcessor
     DB = LBRYDB
-    DESERIALIZER = LBRYDeserializer
     NAME = "LBRY"
     SHORTNAME = "LBC"
     NET = "mainnet"
@@ -88,28 +85,14 @@ class LBC(Coin):
     def claim_address_handler(cls, script):
         '''Parse a claim script, returns the address
         '''
-        decoded = decode_claim_script(script)
+        output = OutputScript(script)
-        if not decoded:
+        if output.is_pay_pubkey_hash:
-            return None
+            return cls.P2PKH_address_from_hash160(output.values['pubkey_hash'])
-        ops = []
+        if output.is_pay_script_hash:
-        for op, data, _ in decoded[1]:
+            return cls.P2SH_address_from_hash160(output.values['script_hash'])
-            if not data:
+        if output.is_pay_pubkey:
-                ops.append(op)
+            return cls.P2PKH_address_from_pubkey(output.values['pubkey'])
-            else:
+        if output.is_return_data:
-                ops.append((op, data,))
-        match = _match_ops
-        TO_ADDRESS_OPS = [OpCodes.OP_DUP, OpCodes.OP_HASH160, -1,
-                          OpCodes.OP_EQUALVERIFY, OpCodes.OP_CHECKSIG]
-        TO_P2SH_OPS = [OpCodes.OP_HASH160, -1, OpCodes.OP_EQUAL]
-        TO_PUBKEY_OPS = [-1, OpCodes.OP_CHECKSIG]
-
-        if match(ops, TO_ADDRESS_OPS):
-            return cls.P2PKH_address_from_hash160(ops[2][-1])
-        if match(ops, TO_P2SH_OPS):
-            return cls.P2SH_address_from_hash160(ops[1][-1])
-        if match(ops, TO_PUBKEY_OPS):
-            return cls.P2PKH_address_from_pubkey(ops[0][-1])
-        if ops and ops[0] == OpCodes.OP_RETURN:
             return None
         return None
 
@@ -121,9 +104,9 @@ class LBC(Coin):
         if script and script[0] == OpCodes.OP_RETURN:
             return None
         if script[0] in [
-            lbry_opcodes.OP_CLAIM_NAME,
+            OutputScript.OP_CLAIM_NAME,
-            lbry_opcodes.OP_SUPPORT_CLAIM,
+            OutputScript.OP_UPDATE_CLAIM,
-            lbry_opcodes.OP_UPDATE_CLAIM
+            OutputScript.OP_SUPPORT_CLAIM,
         ]:
             return cls.address_to_hashX(cls.claim_address_handler(script))
         else:

lbrynet/wallet/server/model.py

@@ -1,6 +1,5 @@
 from collections import namedtuple
 import msgpack
-from torba.server.util import cachedproperty
 # Classes representing data and their serializers, if any.
 
 
@@ -14,34 +13,3 @@ class ClaimInfo(namedtuple("NameClaim", "name value txid nout amount address hei
     @property
     def serialized(self):
         return msgpack.dumps(self)
-
-
-class NameClaim(namedtuple("NameClaim", "name value")):
-    pass
-
-
-class ClaimUpdate(namedtuple("ClaimUpdate", "name claim_id value")):
-    pass
-
-
-class ClaimSupport(namedtuple("ClaimSupport", "name claim_id")):
-    pass
-
-
-class LBRYTx(namedtuple("Tx", "version inputs outputs locktime")):
-    '''Transaction that can contain claim, update or support in its outputs.'''
-
-    @cachedproperty
-    def is_coinbase(self):
-        return self.inputs[0].is_coinbase
-
-    @cachedproperty
-    def has_claims(self):
-        for output in self.outputs:
-            if output.claim:
-                return True
-        return False
-
-
-class TxClaimOutput(namedtuple("TxClaimOutput", "value pk_script claim")):
-    pass

lbrynet/wallet/server/opcodes.py

@@ -1,126 +0,0 @@
-import struct
-from torba.server.enum import Enumeration
-from lbrynet.wallet.server.model import NameClaim, ClaimSupport, ClaimUpdate
-# TODO: Take this to lbryschema (it's also on lbryum and lbryum-server)
-
-
-opcodes = Enumeration("Opcodes", [
-    ("OP_0", 0), ("OP_PUSHDATA1", 76), "OP_PUSHDATA2", "OP_PUSHDATA4", "OP_1NEGATE", "OP_RESERVED",
-    "OP_1", "OP_2", "OP_3", "OP_4", "OP_5", "OP_6", "OP_7",
-    "OP_8", "OP_9", "OP_10", "OP_11", "OP_12", "OP_13", "OP_14", "OP_15", "OP_16",
-    "OP_NOP", "OP_VER", "OP_IF", "OP_NOTIF", "OP_VERIF", "OP_VERNOTIF", "OP_ELSE", "OP_ENDIF",
-    "OP_VERIFY",
-    "OP_RETURN", "OP_TOALTSTACK", "OP_FROMALTSTACK", "OP_2DROP", "OP_2DUP", "OP_3DUP", "OP_2OVER",
-    "OP_2ROT", "OP_2SWAP",
-    "OP_IFDUP", "OP_DEPTH", "OP_DROP", "OP_DUP", "OP_NIP", "OP_OVER", "OP_PICK", "OP_ROLL",
-    "OP_ROT",
-    "OP_SWAP", "OP_TUCK", "OP_CAT", "OP_SUBSTR", "OP_LEFT", "OP_RIGHT", "OP_SIZE", "OP_INVERT",
-    "OP_AND",
-    "OP_OR", "OP_XOR", "OP_EQUAL", "OP_EQUALVERIFY", "OP_RESERVED1", "OP_RESERVED2", "OP_1ADD",
-    "OP_1SUB", "OP_2MUL",
-    "OP_2DIV", "OP_NEGATE", "OP_ABS", "OP_NOT", "OP_0NOTEQUAL", "OP_ADD", "OP_SUB", "OP_MUL",
-    "OP_DIV",
-    "OP_MOD", "OP_LSHIFT", "OP_RSHIFT", "OP_BOOLAND", "OP_BOOLOR",
-    "OP_NUMEQUAL", "OP_NUMEQUALVERIFY", "OP_NUMNOTEQUAL", "OP_LESSTHAN",
-    "OP_GREATERTHAN", "OP_LESSTHANOREQUAL", "OP_GREATERTHANOREQUAL", "OP_MIN", "OP_MAX",
-    "OP_WITHIN", "OP_RIPEMD160", "OP_SHA1", "OP_SHA256", "OP_HASH160",
-    "OP_HASH256", "OP_CODESEPARATOR", "OP_CHECKSIG", "OP_CHECKSIGVERIFY", "OP_CHECKMULTISIG",
-    "OP_CHECKMULTISIGVERIFY", "OP_NOP1", "OP_NOP2", "OP_NOP3", "OP_NOP4", "OP_NOP5",
-    "OP_CLAIM_NAME",
-    "OP_SUPPORT_CLAIM", "OP_UPDATE_CLAIM",
-    ("OP_SINGLEBYTE_END", 0xF0),
-    ("OP_DOUBLEBYTE_BEGIN", 0xF000),
-    "OP_PUBKEY", "OP_PUBKEYHASH",
-    ("OP_INVALIDOPCODE", 0xFFFF),
-])
-
-
-def script_GetOp(bytes):
-    i = 0
-    while i < len(bytes):
-        vch = None
-        opcode = bytes[i]
-        i += 1
-        if opcode <= opcodes.OP_PUSHDATA4:
-            nSize = opcode
-            if opcode == opcodes.OP_PUSHDATA1:
-                nSize = bytes[i]
-                i += 1
-            elif opcode == opcodes.OP_PUSHDATA2:
-                (nSize,) = struct.unpack_from('<H', bytes, i)
-                i += 2
-            elif opcode == opcodes.OP_PUSHDATA4:
-                (nSize,) = struct.unpack_from('<I', bytes, i)
-                i += 4
-            if i + nSize > len(bytes):
-                vch = "_INVALID_" + bytes[i:]
-                i = len(bytes)
-            else:
-                vch = bytes[i:i + nSize]
-                i += nSize
-        yield (opcode, vch, i)
-
-
-def decode_claim_script(bytes_script):
-    try:
-        decoded_script = [x for x in script_GetOp(bytes_script)]
-    except Exception as e:
-        print(e)
-        return None
-    if len(decoded_script) <= 6:
-        return False
-    op = 0
-    claim_type = decoded_script[op][0]
-    if claim_type == opcodes.OP_UPDATE_CLAIM:
-        if len(decoded_script) <= 7:
-            return False
-    if claim_type not in [
-        opcodes.OP_CLAIM_NAME,
-        opcodes.OP_SUPPORT_CLAIM,
-        opcodes.OP_UPDATE_CLAIM
-    ]:
-        return False
-    op += 1
-    value = None
-    claim_id = None
-    claim = None
-    if not 0 <= decoded_script[op][0] <= opcodes.OP_PUSHDATA4:
-        return False
-    name = decoded_script[op][1]
-    op += 1
-    if not 0 <= decoded_script[op][0] <= opcodes.OP_PUSHDATA4:
-        return False
-    if decoded_script[0][0] in [
-        opcodes.OP_SUPPORT_CLAIM,
-        opcodes.OP_UPDATE_CLAIM
-    ]:
-        claim_id = decoded_script[op][1]
-        if len(claim_id) != 20:
-            return False
-    else:
-        value = decoded_script[op][1]
-    op += 1
-    if decoded_script[0][0] == opcodes.OP_UPDATE_CLAIM:
-        value = decoded_script[op][1]
-        op += 1
-    if decoded_script[op][0] != opcodes.OP_2DROP:
-        return False
-    op += 1
-    if decoded_script[op][0] != opcodes.OP_DROP and decoded_script[0][0] == opcodes.OP_CLAIM_NAME:
-        return False
-    elif decoded_script[op][0] != opcodes.OP_2DROP and decoded_script[0][0] == opcodes.OP_UPDATE_CLAIM:
-        return False
-    op += 1
-    if decoded_script[0][0] == opcodes.OP_CLAIM_NAME:
-        if name is None or value is None:
-            return False
-        claim = NameClaim(name, value)
-    elif decoded_script[0][0] == opcodes.OP_UPDATE_CLAIM:
-        if name is None or value is None or claim_id is None:
-            return False
-        claim = ClaimUpdate(name, claim_id, value)
-    elif decoded_script[0][0] == opcodes.OP_SUPPORT_CLAIM:
-        if name is None or claim_id is None:
-            return False
-        claim = ClaimSupport(name, claim_id)
-    return claim, decoded_script[op:]

lbrynet/wallet/server/tx.py

@@ -1,5 +0,0 @@
-from torba.server.tx import Deserializer
-
-
-class LBRYDeserializer(Deserializer):
-    pass