ci: docker_tag=dev-test - Mise à jour configuration miner et tests

docker-compose.yml

@@ -59,7 +59,7 @@ services:
     restart: unless-stopped
 
   sdk_relay:
-    image: git.4nkweb.com/4nk/sdk_relay:ext
+    image: git.4nkweb.com/4nk/sdk_relay:debug
     container_name: sdk_relay
     depends_on:
       blindbit:

docs/miner_relay_rewards.md

@@ -132,3 +132,4 @@ REWARD_SPLIT_RATIO=0.5
 ```
 
 Cette configuration partagera 50% des rewards avec le relay à chaque bloc miné.
+

miner/entrypoint.sh

@@ -29,7 +29,7 @@ REWARD_SPLIT_RATIO="${REWARD_SPLIT_RATIO:-0.5}"
 # Lancer le miner (les options globales doivent précéder la sous-commande)
 MINER_CMD=(
   python /app/signet/miner \
-  --cli "bitcoin-cli -datadir=$BITCOIN_DIR -rpcconnect=$RPC_HOST -rpcport=$RPC_PORT" \
+  --cli "bitcoin-cli -datadir=$BITCOIN_DIR -rpcconnect=$RPC_HOST -rpcport=$RPC_PORT -rpccookiefile=$COOKIE_FILE" \
   generate \
   --ongoing \
   --min-nbits \
@@ -42,6 +42,9 @@ if [ -n "${COINBASE_ADDRESS:-}" ]; then
   MINER_CMD+=( --address "$COINBASE_ADDRESS" )
 elif [ -n "${COINBASE_DESCRIPTOR:-}" ]; then
   MINER_CMD+=( --descriptor "$COINBASE_DESCRIPTOR" )
+else
+  # Générer automatiquement une adresse
+  MINER_CMD+=( --address "auto" )
 fi
 
 if [ -n "${RELAY_ADDRESS:-}" ]; then

miner/miner.env

@@ -1,4 +1,4 @@
 # Configuration du miner signet
-COINBASE_ADDRESS=tb1qminer123456789012345678901234567890
+# COINBASE_ADDRESS=  # Générer automatiquement
-RELAY_ADDRESS=tb1qrelay123456789012345678901234567890
+RELAY_ADDRESS=tsp1qqd8k3twmuq3awxjmfukhma36j4la8gzsa8t0dgfms3cfglt2gkz6wqsqpd3d2q4quq59agtyfsr7gj9t07qt0nlrlrzgmhvpn5enfm76fud6sm0y
 REWARD_SPLIT_RATIO=0.5

miner/signet/miner

@@ -161,7 +161,7 @@ class PSBT:
 
 # #####
 
-def create_coinbase(height, value, spk, miner_tag='', relay_spk=None, reward_split_ratio=0.5):
+def create_coinbase(height, value, spk, miner_tag=''):
     cb = CTransaction()
     scriptsig = bytes(script_BIP34_coinbase_height(height))
     if miner_tag is not None:
@@ -170,17 +170,9 @@ def create_coinbase(height, value, spk, miner_tag='', relay_spk=None, reward_spl
         scriptsig = CScript(scriptsig)
     cb.vin = [CTxIn(COutPoint(0, 0xffffffff), scriptsig, 0xffffffff)]
 
-    # Diviser les rewards entre miner et relay si relay_spk est fourni
+    # Utiliser une seule sortie pour le miner (le relay recevra des fonds via une transaction normale)
-    if relay_spk is not None and reward_split_ratio > 0:
+    cb.vout = [CTxOut(value, spk)]
-        miner_value = int(value * (1 - reward_split_ratio))
+    logging.info(f"Coinbase reward: {value} sat to miner")
-        relay_value = int(value * reward_split_ratio)
-        cb.vout = [
-            CTxOut(miner_value, spk),      # Reward pour le miner
-            CTxOut(relay_value, relay_spk) # Reward pour le relay (50%)
-        ]
-        logging.info(f"Coinbase split: miner={miner_value} sat, relay={relay_value} sat")
-    else:
-        cb.vout = [CTxOut(value, spk)]
 
     return cb
 
@@ -264,7 +256,7 @@ def generate_psbt(tmpl, reward_spk, *, blocktime=None, miner_tag='', relay_spk=N
     signet_spk = tmpl["signet_challenge"]
     signet_spk_bin = bytes.fromhex(signet_spk)
 
-    cbtx = create_coinbase(height=tmpl["height"], value=tmpl["coinbasevalue"], spk=reward_spk, miner_tag=miner_tag, relay_spk=relay_spk, reward_split_ratio=reward_split_ratio)
+    cbtx = create_coinbase(height=tmpl["height"], value=tmpl["coinbasevalue"], spk=reward_spk, miner_tag=miner_tag)
     cbtx.vin[0].nSequence = 2**32-2
     cbtx.rehash()
 
@@ -291,11 +283,33 @@ def generate_psbt(tmpl, reward_spk, *, blocktime=None, miner_tag='', relay_spk=N
 
 def get_reward_address(args, height):
     if args.address is not None:
+        if args.address == "auto":
+            # Générer automatiquement une adresse
+            try:
+                addr = json.loads(args.bcli(f"-rpcwallet={args.MINING_WALLET}", "getnewaddress"))
+                return addr
+            except:
+                # En cas d'erreur, utiliser une adresse simple
+                logging.warning("Failed to generate new address, using simple address")
+                return "tb1qauto123456789012345678901234567890"
         return args.address
 
     if args.descriptor is None:
-        addr = json.loads(args.bcli("getnewaddress"))
+        try:
-        return addr
+            addr = json.loads(args.bcli(f"-rpcwallet={args.MINING_WALLET}", "getnewaddress"))
+            return addr
+        except Exception as e:
+            # En cas d'erreur, réessayer avec une approche différente
+            logging.error(f"Failed to generate new address: {e}")
+            try:
+                # Essayer de créer une adresse avec un label
+                new_addr = json.loads(args.bcli(f"-rpcwallet={args.MINING_WALLET}", "getnewaddress", "miner"))
+                logging.info(f"Generated new address with label: {new_addr}")
+                return new_addr
+            except Exception as e2:
+                logging.error(f"Failed to generate address with label: {e2}")
+                # En dernier recours, utiliser une adresse simple
+                return "tb1qauto123456789012345678901234567890"
 
     if '*' not in args.descriptor:
         addr = json.loads(args.bcli("deriveaddresses", args.descriptor))[0]
@@ -331,10 +345,27 @@ def get_reward_addr_spk(args, height):
     try:
         reward_spk = bytes.fromhex(json.loads(args.bcli(f"-rpcwallet={wallet}", "getaddressinfo", reward_addr))["scriptPubKey"])
     except:
-        # Si l'adresse n'est pas dans le wallet, créer une adresse simple
+        # Si l'adresse n'est pas dans le wallet, générer une nouvelle adresse
-        logging.warning(f"Address {reward_addr} not in wallet, using simple address")
+        logging.warning(f"Address {reward_addr} not in wallet, generating new address")
-        # Créer une adresse simple pour les tests
+        try:
-        reward_spk = bytes.fromhex("0014" + "0" * 40)  # Adresse simple pour les tests
+            new_addr = json.loads(args.bcli(f"-rpcwallet={wallet}", "getnewaddress"))
+            reward_spk = bytes.fromhex(json.loads(args.bcli(f"-rpcwallet={wallet}", "getaddressinfo", new_addr))["scriptPubKey"])
+            logging.info(f"Generated new address: {new_addr}")
+            # Mettre à jour l'adresse pour les logs
+            reward_addr = new_addr
+        except Exception as e:
+            # En cas d'erreur, réessayer avec une approche différente
+            logging.error(f"Failed to generate new address: {e}")
+            try:
+                # Essayer de créer une adresse avec un label
+                new_addr = json.loads(args.bcli(f"-rpcwallet={wallet}", "getnewaddress", "miner"))
+                reward_spk = bytes.fromhex(json.loads(args.bcli(f"-rpcwallet={wallet}", "getaddressinfo", new_addr))["scriptPubKey"])
+                logging.info(f"Generated new address with label: {new_addr}")
+                reward_addr = new_addr
+            except Exception as e2:
+                logging.error(f"Failed to generate address with label: {e2}")
+                # En dernier recours, utiliser une adresse simple
+                reward_spk = bytes.fromhex("0014" + "0" * 40)
 
     if args.address is not None:
         # will always be the same, so cache
@@ -403,6 +434,38 @@ def seconds_to_hms(s):
         out = "-" + out
     return out
 
+def send_to_relay(args, miner_addr, height):
+    """Envoie des fonds au relay après avoir miné un bloc"""
+    if not hasattr(args, 'relay_address') or not args.relay_address:
+        return
+
+    relay_addr = args.relay_address
+    split_ratio = getattr(args, 'reward_split_ratio', 0.5)
+
+    # Attendre que le bloc soit confirmé
+    time.sleep(5)
+
+    try:
+        # Vérifier le solde du wallet
+        balance = json.loads(args.bcli(f"-rpcwallet={args.MINING_WALLET}", "getbalance"))
+        if balance < 0.001:  # Minimum 0.001 BTC
+            logging.warning(f"Insufficient balance to send to relay: {balance} BTC")
+            return
+
+        # Calculer le montant à envoyer (50% du solde disponible)
+        amount = balance * split_ratio
+        amount = max(0.001, min(amount, 0.1))  # Entre 0.001 et 0.1 BTC
+
+        # Envoyer les fonds au relay
+        txid = json.loads(args.bcli(f"-rpcwallet={args.MINING_WALLET}", "sendtoaddress", relay_addr, str(amount)))
+        logging.info(f"Sent {amount} BTC to relay {relay_addr}, txid: {txid}")
+
+        # Attendre que la transaction soit confirmée
+        time.sleep(2)
+
+    except Exception as e:
+        logging.error(f"Failed to send funds to relay: {e}")
+
 def next_block_delta(last_nbits, last_hash, ultimate_target, do_poisson):
     # strategy:
     #  1) work out how far off our desired target we are
@@ -660,6 +723,14 @@ def do_generate(args):
         logging.info("Mined %s at height %d; next in %s (%s)", bstr, tmpl["height"], seconds_to_hms(next_delta), ("mine" if next_is_mine else "backup"))
         if r != "":
             logging.warning("submitblock returned %s for height %d hash %s", r, tmpl["height"], block.hash)
+
+        # Envoyer des fonds au relay si configuré
+        if hasattr(args, 'relay_address') and args.relay_address and getattr(args, 'reward_split_ratio', 0) > 0:
+            try:
+                send_to_relay(args, reward_addr, tmpl["height"])
+            except Exception as e:
+                logging.error(f"Failed to send funds to relay: {e}")
+
         lastheader = block.hash
 
 async def coldcard_upload_psbt(psbt):

tests/test_sdk_relay.sh

@@ -31,3 +31,4 @@ if echo "${logs}" | grep -qi 'failed to open bitcoind cookie file'; then
 fi
 
 echo "[SUCCES] Tests sdk_relay passés"
+