satkas 0.1.0__py3-none-any.whl

satkas/__init__.py

@@ -0,0 +1,30 @@
+
+__name__ = 'satkas'
+__version__ = '0.1.0'
+__author__ = 'LordStapy'
+__license__ = 'LGPLv3'
+__url__ = 'https://github.com/LordStapy/satkas'
+__description__ = 'Bitcoin-Kaspa Atomic Swap Utility'
+__keywords__ = 'btc kas atomic-swap kivy p2p'
+__classifiers__ = [
+    'Development Status :: 3 - Alpha',
+    'Intended Audience :: Developers',
+    'License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)',
+    'Programming Language :: Python :: 3',
+    'Programming Language :: Python :: 3 :: Only',
+    'Programming Language :: Python :: 3.10',
+]
+__all__ = [
+    'main',
+    'core',
+    'ui',
+    'cli',
+    __name__,
+    __version__,
+    __author__,
+    __license__,
+    __url__,
+    __description__,
+    __keywords__,
+    __classifiers__
+]

satkas/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

satkas/cli/__init__.py

@@ -0,0 +1 @@
+from .cli import main

satkas/cli/cli.py

@@ -0,0 +1,41 @@
+# satkas/cli/cli.py
+"""Console entry point for the SatKas GUI.
+
+Supports:
+  satkas
+  satkas --peer <onion>
+  MAKER_ENDPOINT=<onion> satkas
+"""
+import os
+import sys
+
+# Before logging.basicConfig and before importing satkas.main / Kivy.
+os.environ["KIVY_NO_CONSOLELOG"] = "1"
+os.environ["KCFG_KIVY_LOG_LEVEL"] = "error"
+
+import argparse
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+
+def main():
+    # Must run before importing satkas.main — Kivy parses sys.argv at
+    # import time and rejects unknown options like --peer.
+    parser = argparse.ArgumentParser(prog="satkas")
+    parser.add_argument(
+        "--peer",
+        default=None,
+        help="Force a maker onion endpoint (sets MAKER_ENDPOINT)",
+    )
+    args, remaining = parser.parse_known_args()
+    if args.peer:
+        os.environ["MAKER_ENDPOINT"] = args.peer
+    sys.argv = [sys.argv[0]] + remaining
+
+    from satkas.main import main as satkas_main
+    satkas_main()
+
+
+if __name__ == "__main__":
+    main()

satkas/core/__init__.py

@@ -0,0 +1,9 @@
+
+__all__ = [
+    'blib',
+    'db',
+    'klib',
+    'p2p',
+    'services',
+    'swapper'
+]

satkas/core/blib/baddress.py

@@ -0,0 +1,12 @@
+
+import os
+
+from bitcoinutils.keys import PublicKey
+from bitcoinutils.setup import setup as btc_network_setup
+
+
+def p2wpkh_address(pubkey):
+    assert len(pubkey) == 33  # only compressed keys for P2WPKH
+    btc_network_setup(os.getenv('BTC_NETWORK', 'mainnet'))
+    pubkey = PublicKey(hex_str=pubkey.hex())
+    return pubkey.get_segwit_address()

satkas/core/blib/brpc.py

@@ -0,0 +1,225 @@
+import asyncio
+import datetime
+import logging
+import os
+import json
+import aiohttp
+
+logger = logging.getLogger('brpc')
+
+
+class BrpcError(Exception):
+    """Raised when a bitcoind JSON-RPC call returns an error object."""
+
+    def __init__(self, error):
+        self.error = error
+        if isinstance(error, dict):
+            message = error.get('message', str(error))
+            code = error.get('code')
+            super().__init__(f"RPC error {code}: {message}" if code is not None else message)
+        else:
+            super().__init__(str(error))
+
+
+def raise_for_error(res):
+    """Raise BrpcError if the RPC response contains an error. Returns res unchanged otherwise."""
+    if res is None:
+        raise BrpcError({'message': 'empty RPC response'})
+    error = res.get('error')
+    if error is not None:
+        raise BrpcError(error)
+    return res
+
+
+async def base_req(method, *args, **kwargs):
+    server = kwargs.pop('server', None)
+    if server is None:
+        host = os.getenv('BITCOIND_HOST', '127.0.0.1')
+        port = os.getenv('BITCOIND_PORT', '8332')
+        server = f"{host}:{port}"
+    user = kwargs.pop('user', None)
+    if user is None:
+        user = os.getenv('BTC_RPC_USER', '')
+    password = kwargs.pop('password', None)
+    if password is None:
+        password = os.getenv('BTC_RPC_PASS', '')
+
+    endpoint = f"http://{server}"
+
+    wallet = kwargs.pop('rpcwallet', None)
+    if wallet is not None:
+        endpoint += f"/wallet/{wallet}"
+    verbose = kwargs.pop('verbose_print', False)
+
+    payload = {
+        'jsonrpc': '2.0',
+        'id': '0',
+        'method': method,
+        'params': list(args) if args else kwargs
+    }
+
+    headers = {
+        'Content-Type': 'application/json'
+    }
+
+    auth = aiohttp.BasicAuth(user, password)
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(endpoint, auth=auth, data=json.dumps(payload), headers=headers) as response:
+            res = await response.json()
+            if verbose:
+                logger.debug(res)
+            return res
+
+
+async def createwallet(
+    name,
+    disable_private_keys=True,
+    blank=False,
+    passphrase='',
+    avoid_reuse=False,
+    descriptors=True,
+    load_on_startup=True,
+    **kwargs
+):
+    return await base_req(
+        'createwallet',
+        name,
+        disable_private_keys,
+        blank,
+        passphrase,
+        avoid_reuse,
+        descriptors,
+        load_on_startup,
+        **kwargs
+    )
+
+
+async def loadwallet(name, load_on_startup=True, **kwargs):
+    return await base_req('loadwallet', name, load_on_startup, **kwargs)
+
+
+async def listwallets(**kwargs):
+    return await base_req('listwallets', **kwargs)
+
+
+async def getwalletinfo(**kwargs):
+    return await base_req('getwalletinfo', **kwargs)
+
+
+async def walletpassphrase(passphrase, timeout=60, **kwargs):
+    return await base_req('walletpassphrase', passphrase, timeout, **kwargs)
+
+
+async def walletlock(**kwargs):
+    return await base_req('walletlock', **kwargs)
+
+
+async def getbalance(*args, **kwargs):
+    return await base_req('getbalance', *args, **kwargs)
+
+
+async def getnewaddress(label='', address_type=None, **kwargs):
+    if address_type is not None:
+        return await base_req('getnewaddress', label, address_type, **kwargs)
+    return await base_req('getnewaddress', label, **kwargs)
+
+
+async def scantxoutset(action, descriptors):
+    return await base_req('scantxoutset', action, descriptors)
+
+
+async def importdescriptors(descriptors, ts=None, **kwargs):
+    if not isinstance(descriptors, list):
+        descriptors = [descriptors]
+    if ts is None:
+        ts = int((datetime.datetime.now() - datetime.timedelta(hours=1)).timestamp())
+    payload = [
+        {
+            'desc': desc,
+            'timestamp': ts
+        }
+        for desc in descriptors
+    ]
+    return await base_req('importdescriptors', payload, **kwargs)
+
+
+async def listunspent(addresses=None, minconf=1, maxconf=9999999, include_unsafe=True, query_options=None, **kwargs):
+    if addresses is None:
+        addresses = []
+    if not isinstance(addresses, list):
+        addresses = [addresses]
+    if query_options is None:
+        query_options = {}
+    payload = (minconf, maxconf, addresses, include_unsafe, query_options)
+    return await base_req('listunspent', *payload, **kwargs)
+
+
+async def getdescriptorinfo(descriptor, **kwargs):
+    return await base_req('getdescriptorinfo', descriptor, **kwargs)
+
+
+async def deriveaddresses(descriptor, **kwargs):
+    return await base_req('deriveaddresses', descriptor, **kwargs)
+
+
+async def getaddressinfo(address, **kwargs):
+    return await base_req('getaddressinfo', address, **kwargs)
+
+
+async def listtransactions(label=None, count=10, skip=0, include_watchonly=True, **kwargs):
+    if label is None:
+        label = '*'
+    return await base_req('listtransactions', label, count, skip, include_watchonly, **kwargs)
+
+
+async def gettransaction(txid, include_watchonly=True, verbose=True, **kwargs):
+    return await base_req('gettransaction', txid, include_watchonly, verbose, **kwargs)
+
+
+async def getrawtransaction(txid, verbose=True, blockhash=None, **kwargs):
+    if blockhash is not None:
+        return await base_req('getrawtransaction', txid, verbose, blockhash, **kwargs)
+    return await base_req('getrawtransaction', txid, verbose, **kwargs)
+
+
+async def gettxout(txid, vout, include_mempool=True, **kwargs):
+    return await base_req('gettxout', txid, vout, include_mempool, **kwargs)
+
+
+async def gettxspendingprevout(outputs, **kwargs):
+    """
+    Scan mempool (and confirmed chain if -txspenderindex) for txs spending the given outputs.
+    outputs: list of {"txid": "...", "vout": n}
+    """
+    return await base_req('gettxspendingprevout', outputs, **kwargs)
+
+
+async def getblockchaininfo(**kwargs):
+    return await base_req('getblockchaininfo', **kwargs)
+
+
+async def sendtoaddress(address, amount, *args, **kwargs):
+    # TODO: manage encrypted wallets, need to call walletpassphrase before submitting this command
+    return await base_req('sendtoaddress', address, amount, *args, **kwargs)
+
+
+async def generatetoaddress(address, nblocks=1, **kwargs):
+    return await base_req('generatetoaddress', nblocks, address, **kwargs)
+
+
+async def sendrawtransaction(raw_transaction, **kwargs):
+    res = await base_req('sendrawtransaction', raw_transaction, **kwargs)
+    if res.get('error'):
+        logger.error(f"sendrawtransaction failed: {res['error']}")
+    else:
+        logger.info(f"sendrawtransaction succeeded: txid={res.get('result')}")
+    return res
+
+
+async def getblockcount(**kwargs):
+    return await base_req('getblockcount', **kwargs)
+
+
+async def estimatesmartfee(conf_target, estimate_mode='CONSERVATIVE', **kwargs):
+    return await base_req('estimatesmartfee', conf_target, estimate_mode, **kwargs)

satkas/core/blib/btx_size.py

@@ -0,0 +1,4 @@
+# 1 p2wpkh in, p2wsh contract + p2wpkh change. Sig 71–73 all ceil to 153.
+BTC_FUNDING_VSIZE = 153
+# 1 p2wsh HTLC in, 1 p2wpkh out (redeem; refund is 134). Height locktime, script 96.
+BTC_SPEND_VSIZE = 143

satkas/core/blib/scripting.py

@@ -0,0 +1,92 @@
+
+import struct
+
+from bitcoinutils.script import Script
+
+# define few opcodes
+OP_IF = b'\x63'
+OP_SIZE = b'\x82'
+OP_32 = b'\x20'
+OP_EQUAL_VERIFY = b'\x88'
+OP_SHA256 = b'\xa8'
+OP_DUP = b'\x76'
+OP_HASH160 = b'\xa9'
+OP_ELSE = b'\x67'
+OP_CHECK_LOCK_TIME_VERIFY = b'\xb1'
+OP_DROP = b'\x75'
+OP_ENDIF = b'\x68'
+OP_CHECK_SIG = b'\xac'
+
+
+def build_contract_descriptor(sender, receiver, timelock, secret_hash):
+    # not working, can't use pkh without the actual key, keyhash alone is not enough
+    # even addr is bad, problem is probably the or_i block entirely
+    sender = f"addr({sender})"
+    receiver = f"addr({receiver})"
+    redeem_path = f"and_v(sha256({secret_hash.hex()}),{receiver})"
+    refund_path = f"and_v(after({timelock}),{sender})"
+    descriptor = f"wsh(or_i({redeem_path},{refund_path}))"
+    return descriptor
+
+
+def build_btc_contract_script_old(sender_pkh, receiver_pkh, locktime, secret_hash):
+    script = b''
+    script += OP_IF
+    script += OP_SIZE
+    script += b'\x01'
+    script += OP_32
+    script += OP_EQUAL_VERIFY
+    script += OP_SHA256
+    script += b'\x20'
+    script += secret_hash
+    script += OP_EQUAL_VERIFY
+    script += OP_DUP
+    script += OP_HASH160
+    script += b'\x14'
+    script += receiver_pkh
+    script += OP_ELSE
+    script += b'\x02'  # <- hardcoded locktime len, working with test values, but will break
+    script += struct.pack('<h', locktime)
+    script += OP_CHECK_LOCK_TIME_VERIFY
+    script += OP_DROP
+    script += OP_DUP
+    script += OP_HASH160
+    script += b'\x14'
+    script += sender_pkh
+    script += OP_ENDIF
+    script += OP_EQUAL_VERIFY
+    script += OP_CHECK_SIG
+    return script
+
+
+def build_btc_contract_script(sender_pkh, receiver_pkh, locktime, secret_hash):
+    redeem_script = Script(
+        [
+            "OP_IF",
+            "OP_SIZE", 0X20, "OP_EQUALVERIFY",
+            "OP_SHA256", secret_hash.hex(), "OP_EQUALVERIFY",
+            "OP_DUP", "OP_HASH160", receiver_pkh,
+            "OP_ELSE",
+            locktime, "OP_CHECKLOCKTIMEVERIFY", "OP_DROP",
+            "OP_DUP", "OP_HASH160", sender_pkh,
+            "OP_ENDIF",
+            "OP_EQUALVERIFY",
+            "OP_CHECKSIG"
+        ]
+    )
+    return redeem_script
+
+
+def build_btc_spend_script(signature, pubkey, contract, refund=False, secret=None):
+    payload = list()
+    payload.append(signature)
+    payload.append(pubkey.to_hex())
+    if refund:
+        payload.append('')
+    else:
+        if isinstance(secret, bytes):
+            secret = secret.hex()
+        payload.append(secret)
+        payload.append('01')
+    payload.append(contract)
+    return payload

satkas/core/db/models.py

@@ -0,0 +1,185 @@
+
+import datetime
+import os
+import logging
+import sys
+import json
+
+from peewee import DateTimeField, Model, CharField, BooleanField, IntegerField, TextField
+from playhouse.migrate import SqliteDatabase
+
+
+def resource_path(relative_path):
+    # this is used to get the path to the database file, when the app is packaged with Pyinstaller (or other bundlers, maybe?)
+    try:
+        base_path = sys._MEIPASS
+    except Exception:
+        base_path = os.path.abspath(os.path.dirname(__file__))
+    return os.path.join(base_path, relative_path)
+
+
+# set peewee logger to warning
+logging.getLogger('peewee').setLevel(logging.WARNING)
+db_path = os.getenv('SATKAS_DB_PATH', None)
+if db_path is None:
+    db_path = resource_path('satkas.db')
+db = SqliteDatabase(db_path, timeout=10)
+
+
+class BaseModel(Model):
+    class Meta:
+        database = db
+
+    created_at = DateTimeField(default=datetime.datetime.now)
+    updated_at = DateTimeField(default=datetime.datetime.now)
+
+
+class Swap(BaseModel):
+    swap_type = CharField(default='')
+    # Indexed because a swap's key index is its row's position among its own
+    # side's rows, so every derivation counts rows filtered by this.
+    side = CharField(default='', index=True)  # maker / taker
+    remote_pubkey = CharField(default='')
+    ln_invoice = CharField(default=None, unique=True, null=True)
+    payment_hash = CharField(default='')
+    secret_hash = CharField(default='')
+    sender_address = CharField(default='')
+    receiver_address = CharField(default='')
+    btc_sender_address = CharField(default='', null=True)
+    btc_receiver_address = CharField(default='', null=True)
+    contract = CharField(default='')
+    btc_contract = CharField(default='', null=True)
+    p2sh_address = CharField(default='')
+    btc_p2sh_address = CharField(default='', null=True)
+    dwork_amount = IntegerField(default=0)
+    sat_amount = IntegerField(default=0)
+    kas_locktime = IntegerField(null=True)  # daa score (on-chain) or ms timestamp (LN)
+    btc_locktime = IntegerField(null=True)  # bitcoin block height
+    dag_checkpoint_hash = CharField(null=True)  # virtual-chain start hash at OPENED
+    # INIT → OPENED → FUNDED → COMPLETING|REFUNDING → COMPLETED|REFUNDED
+    #                              ↘ EXPIRED | FAILED
+    # OPENED = contracts ready, our pay not yet submitted.
+    # FUNDED = our on-chain fund or LN pay submitted (capital at risk).
+    status = CharField(default='INIT')
+    txid = CharField(default=None, null=True)
+    btc_txid = CharField(default=None, null=True)
+    secret = CharField(default=None, null=True)
+    output_address = CharField(null=True)  # kas redeem/refund destination
+    btc_output_address = CharField(null=True)
+    extra_info = TextField(null=True)  # JSON object for non-core / plugin data
+
+    def get_extra(self):
+        if not self.extra_info:
+            return {}
+        try:
+            return json.loads(self.extra_info)
+        except (TypeError, ValueError):
+            return {}
+
+    def set_extra(self, key, value):
+        extra = self.get_extra()
+        extra[key] = value
+        self.extra_info = json.dumps(extra)
+
+
+class WalletModel(BaseModel):
+    mnemonic = CharField()
+    is_encrypted = BooleanField(default=False)
+    address_counter = IntegerField(default=0)
+    next_address = CharField()
+    # next_btc_address = CharField(default=None, null=True)
+
+
+class MakerWallet(WalletModel):
+    pass
+
+
+class TakerWallet(WalletModel):
+    pass
+
+
+# not using p2p table yet
+class P2PNode(BaseModel):
+    pubkey = CharField()
+    p2p_endpoint = CharField()
+    swap_endpoint = CharField()
+
+
+class Setting(BaseModel):
+    """Application settings table for storing all app configuration."""
+    name = CharField(unique=True, index=True)  # e.g., "service.kaspad.host"
+    value = CharField(null=True)  # Store as string, cast when retrieving
+    value_type = CharField(default='str')  # 'str', 'int', 'bool', 'json', 'float'
+
+    def get_typed_value(self):
+        """Return the value cast to the appropriate Python type."""
+        if self.value is None:
+            return None
+
+        if self.value_type == 'int':
+            return int(self.value)
+        elif self.value_type == 'bool':
+            return self.value.lower() in ('true', '1', 'yes', 'on')
+        elif self.value_type == 'float':
+            return float(self.value)
+        elif self.value_type == 'json':
+            import json
+            return json.loads(self.value)
+        else:  # 'str' or unknown
+            return self.value
+
+    @classmethod
+    def set_value(cls, name, value, value_type='str'):
+        """Set or update a setting value."""
+        # Convert value to string for storage
+        if value is None:
+            str_value = None
+        elif value_type == 'bool':
+            str_value = 'true' if value else 'false'
+        elif value_type == 'json':
+            str_value = json.dumps(value)
+        else:
+            str_value = str(value)
+
+        # Upsert the setting
+        setting, created = cls.get_or_create(
+            name=name,
+            defaults={
+                'value': str_value,
+                'value_type': value_type
+            }
+        )
+
+        if not created:
+            setting.value = str_value
+            setting.value_type = value_type
+            setting.save()
+
+        return setting
+
+    @classmethod
+    def get_value(cls, name, default=None):
+        """Get a setting value with optional default."""
+        try:
+            setting = cls.get(cls.name == name)
+            return setting.get_typed_value()
+        except cls.DoesNotExist:
+            return default
+
+    @classmethod
+    def get_all_settings(cls):
+        """Get all settings as a dictionary."""
+        settings = {}
+        for setting in cls.select():
+            settings[setting.name] = setting.get_typed_value()
+        return settings
+
+
+def initialize_db():
+    db.connect()
+    db.create_tables([
+        Swap, MakerWallet, TakerWallet, Setting
+    ], safe=True)
+
+
+initialize_db()

satkas/core/klib/kaddress.py

@@ -0,0 +1,38 @@
+
+import os
+import hashlib
+
+from satkas.core.klib.kbech32 import encode_address, decode_address
+
+
+
+def get_script_hash(script):
+    script_hash = hashlib.blake2b(script, digest_size=32).digest()
+    return script_hash
+
+
+def p2sh_address_from_script_hash(script_hash):
+    if isinstance(script_hash, bytes):
+        script_hash = [i for i in script_hash]
+    version = 8
+    return encode_address(os.getenv('KAS_NETWORK_PREFIX', 'kaspa'), script_hash, version)
+
+
+def p2sh_address_from_script(script):
+    if isinstance(script, list):
+        script = bytes(script)
+    script_hash = get_script_hash(script)
+    return p2sh_address_from_script_hash(script_hash)
+
+
+def get_pubkey_hash(pubkey):
+    pubkey_hash = hashlib.blake2b(pubkey, digest_size=32).digest()
+    return pubkey_hash
+
+
+def p2pk_address(pubkey):
+    if isinstance(pubkey, bytes):
+        pubkey = [i for i in pubkey]
+    version = 0
+    return encode_address(os.getenv('KAS_NETWORK_PREFIX', 'kaspa'), pubkey, version)
+