/api/wallet/fix-fracked

Description

The /api/wallet/fix-fracked endpoint is designed to automatically heal "fracked" coins - coins that have partial authentication (less than 13 out of 25 RAIDA servers passing, but not zero). The healing process uses a two-phase RAIDA protocol:

1. Get Ticket Phase (0x0228): Request authentication tickets from RAIDAs that successfully authenticated the coin
2. Fix Phase (0x0250): Present tickets to failing RAIDAs to prove coin authenticity and update their records

The process runs iteratively (up to 10 rounds) until all coins are either fully authenticated (moved to Bank), still partially failing (remain in Fracked), or determined to be counterfeit.

RAIDA Healing Protocol

The Fix operation uses a sophisticated two-command protocol:

Parameters

This endpoint does not require any parameters. It operates on all coins currently in the Fracked folder of the active wallet.

Response

Returns a JSON object with healing operation results.

{
  "status": "success",
  "operation": "fix-fracked",
  "message": "Fix fracked endpoint - implementation pending",
  "fixed": 0,
  "still_fracked": 0
}

{
  "status": "success",
  "operation": "fix-fracked",
  "message": "Fix operation completed",
  "initial_fracked": 5,
  "fixed": 3,
  "still_fracked": 2,
  "counterfeit": 0,
  "rounds": 4
}

POWN String Updates

The Fix operation updates POWN (Proof of Ownership) strings to reflect authentication results:

Authentication Threshold: 13+ 'p' characters out of 25 required for Bank status.

Examples

const API_HOST = 'http://localhost:8080';

async function fixFrackedCoins() {
    try {
        const response = await fetch(`${API_HOST}/api/wallet/fix-fracked`);
        const result = await response.json();

        if (result.status === 'success') {
            console.log('Fix Operation Results:');
            console.log(`Initial Fracked: ${result.initial_fracked || 'N/A'}`);
            console.log(`Fixed: ${result.fixed}`);
            console.log(`Still Fracked: ${result.still_fracked}`);
            console.log(`Counterfeit: ${result.counterfeit || 0}`);
            console.log(`Rounds: ${result.rounds || 'N/A'}`);
            console.log(`Message: ${result.message}`);
        } else {
            console.error('Fix operation failed:', result.message);
        }
    } catch (error) {
        console.error('Error fixing fracked coins:', error);
    }
}

fixFrackedCoins();

# Fix all fracked coins in active wallet
curl -X GET "http://localhost:8080/api/wallet/fix-fracked"

# Pretty print JSON output
curl -X GET "http://localhost:8080/api/wallet/fix-fracked" | jq

package main

import (
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

const ApiHost = "http://localhost:8080"

type FixFrackedResponse struct {
    Status          string `json:"status"`
    Operation       string `json:"operation"`
    Message         string `json:"message"`
    InitialFracked  int    `json:"initial_fracked,omitempty"`
    Fixed           int    `json:"fixed"`
    StillFracked    int    `json:"still_fracked"`
    Counterfeit     int    `json:"counterfeit,omitempty"`
    Rounds          int    `json:"rounds,omitempty"`
}

func main() {
    resp, err := http.Get(fmt.Sprintf("%s/api/wallet/fix-fracked", ApiHost))
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := ioutil.ReadAll(resp.Body)

    var result FixFrackedResponse
    if err := json.Unmarshal(body, &result); err != nil {
        panic(err)
    }

    if result.Status == "success" {
        fmt.Printf("Fix Operation Results:\n")
        fmt.Printf("Initial Fracked: %d\n", result.InitialFracked)
        fmt.Printf("Fixed: %d\n", result.Fixed)
        fmt.Printf("Still Fracked: %d\n", result.StillFracked)
        fmt.Printf("Counterfeit: %d\n", result.Counterfeit)
        fmt.Printf("Rounds: %d\n", result.Rounds)
        fmt.Printf("Message: %s\n", result.Message)
    } else {
        fmt.Printf("Error: %s\n", result.Message)
    }
}

Implementation Details

When this endpoint is fully implemented, it will execute the following workflow:

Error Responses

Common error responses when the endpoint is fully implemented:

{
  "status": "error",
  "operation": "fix-fracked",
  "message": "No active wallet set"
}

{
  "status": "success",
  "operation": "fix-fracked",
  "message": "No coins found in Fracked folder",
  "initial_fracked": 0,
  "fixed": 0,
  "still_fracked": 0,
  "counterfeit": 0,
  "rounds": 0
}

{
  "status": "error",
  "operation": "fix-fracked",
  "message": "No RAIDAs have 'p' (pass) status - coins need authentication first",
  "initial_fracked": 5,
  "fixed": 0,
  "still_fracked": 5,
  "counterfeit": 0,
  "rounds": 2
}

CLI Implementation Reference

The Fix command is fully implemented in the CLI version (CloudCoinConsole):

// From commands.c - cmd_fix_coins()
// Location: D:\code\C Language\CloudCoinConsole\src\commands.c:6648

cc_result_t cmd_fix_coins(void) {
    // 1. Read coins from Fracked folder
    // 2. For each RAIDA, build "needs fixing" list (non-'p' status)
    // 3. For each RAIDA, build "needs tickets" list ('p' status)
    // 4. Send Get Ticket (0x0228) requests in parallel
    // 5. Collect tickets from successful responses
    // 6. Send Fix (0x0250) requests with tickets
    // 7. Update POWN strings based on results
    // 8. Write coins to Grade folder
    // 9. Run Grade command to sort coins
    // 10. Repeat up to 10 rounds or until no changes

    // Returns: CC_SUCCESS or error code
}

Source File: D:\code\C Language\CloudCoinConsole\src\commands.c (line 6648)

API Handler: D:\code\C Language\CloudCoinConsole\src\api_handlers.c (line 693-704)