Proof of Reserves

Il nostro impegno per la trasparenza

Revisioni regolari per garantire affidabilità

Noi di Kraken non ci limitiamo a offrirti la possibilità di fare trading con asset digitali all'avanguardia, ma facciamo tutto il possibile per sfruttare la trasparenza delle blockchain open-source su cui sono basati.

Le nostre revisioni periodiche Proof of Reserves consentono ai clienti di verificare, con pochi e semplici clic nel loro account, che i saldi in loro possesso siano supportati da asset reali.

Proof of Reserves è una procedura di contabilità crittografica avanzata condotta regolarmente da revisori contabili di fiducia, che consente di verificare che Kraken rispetti standard rigorosi di responsabilità e offra maggiore trasparenza rispetto alle società finanziarie tradizionali.

Cosa è Proof of Reserves?

Una revisione Proof of Reserves (PoR) è una procedura eseguita da uno studio contabile indipendente, con lo scopo di confermare che il custode detiene effettivamente gli asset che dichiara di conservare per conto dei suoi clienti. Il revisore contabile scatta un'istantanea anonima di tutti i saldi detenuti e li aggrega in un Merkle tree, una struttura di dati che racchiude tutti i saldi dei clienti senza violarne la privacy.

Merkle Root Hash

Da qui, il revisore contabile ottiene una Merkle Root, ovvero un'impronta digitale crittografica che identifica in modo univoco la combinazione di questi saldi al momento della creazione dell'istantanea.

Il revisore raccoglie quindi le firme digitali prodotte da Kraken, che attestano la proprietà degli indirizzi on-chain con saldi verificabili pubblicamente. Infine, confronta e verifica che questi saldi corrispondano o superino i saldi dei clienti rappresentati nel Merkle tree, dimostrando che gli asset dei clienti siano sotto il controllo di Kraken.

Ogni cliente può verificare autonomamente che il proprio saldo sia stato incluso nella procedura di Proof of Reserves confrontando determinati dati con la Merkle Root. Qualsiasi modifica apportata al resto dei dati, per quanto piccola, si ripercuoterà sulla Merkle Root, rendendo evidente la manomissione.

Quali aspetti vengono presi in considerazione durante le revisioni Proof of Reserves?

Saldi spot

La revisione contiene tutti i tuoi saldi per gli asset che risultavano inclusi nell'ambito nel momento in cui è stata catturata l'istantanea. Gli asset riportati di seguito rientravano nell'ambito dell'ultima revisione: Bitcoin (BTC), Ether (ETH), Cardano (ADA), Polkadot (DOT), USD crypto (USDC), Tether (USDT) e Ripple (XRP).

Saldi staking

Se al momento dell'istantanea i tuoi saldi erano allocati allo staking on-chain, vedrai una voce separata per tali saldi, con una convenzione di denominazione che prevede un suffisso ".S" (ad esempio, DOT.S)

Trading con margine

Se in quel momento detenevi posizioni con margine, il tuo saldo totale verrà rettificato con i valori delle posizioni positive.

Esempio 1

Se acquisti 1 BTC/USD a 30.000 USD con margine e la tua posizione è aperta, al tuo saldo Proof of Reserves in BTC verrà applicata una rettifica positiva di positive +1 BTC. Non verrà applicata alcuna rettifica negativa al tuo saldo in USD. Il saldo dei tuoi asset BTC in custodia presso Kraken includerà il saldo in BTC del momento con una rettifica positiva di + 1 BTC per le tue posizioni con margine. Il saldo dei tuoi asset USD rimarrà invariato.

Esempio 2

Se vendi 1 BTC/ETH a 15 ETH con margine e la tua posizione è aperta, al tuo saldo Proof of Reserves in ETH verrà applicata una rettifica positiva di +15 ETH. Non ci sarà nessuna rettifica negativa per il tuo saldo in BTC. Il saldo dei tuoi asset ETH in custodia presso Kraken includerà il saldo in ETH del momento con una rettifica positiva di + 15 ETH per le tue posizioni con margine. Il saldo dei tuoi asset BTC in custodia presso Kraken rimarrà invariato.

Nota: La metodologia per i futures descritta sopra entrerà in vigore con le revisioni Proof of Reserves del maggio 2023.

Saldi di Futures

Se al momento della revisione il tuo wallet Futures aveva uno o più saldi, sarà disponibile un record Proof of Reserves separato per i saldi delle garanzie collaterali sui tuoi futures. I tuoi saldi vengono rettificati in base ai profitti e alle perdite non realizzati per i trade di futures con garanzia collaterale singola. Verranno inclusi gli stessi asset che rientrano nell'ambito per le operazioni spot e con margine, che faranno parte dello stesso Merkle tree e avranno un proprio Merkle Leaf ID. 

Esempio 1

Se hai 1 BTC nel tuo wallet futures e apri una posizione in BTC Perp con garanzia collaterale singola, che ha un saldo Profitti e perdite non realizzato di -0,1 BTC, il saldo dei tuoi BTC in custodia presso Kraken sarà di 0,9 BTC (1 BTC rettificato applicando il saldo Profitti e perdite non realizzato di -0,1 BTC).

Esempio 2

Se hai 1 BTC nel tuo wallet futures e apri una posizione in BTC Perp con garanzia collaterale multipla, che ha un saldo Profitti e perdite non realizzato di -100,0 USD, il saldo dei tuoi BTC in custodia presso Kraken sarà di 1 BTC (il valore di 1 BTC non viene rettificato in base al saldo Profitti e perdite non realizzato, che viene monitorato in USD e gli asset USD non rientrano nell'ambito di questa revisione).

Nota: La metodologia per i futures descritta sopra entrerà in vigore con le revisioni Proof of Reserves del maggio 2023. 

Verifica che il tuo account sia stato incluso nella revisione Proof of Reserves

Verifica semplice

Per verificare crittograficamente l'inclusione del saldo del tuo account di Kraken nell'ultima revisione Proof of Reserves, segui la procedura illustrata sotto.

Nota: Questa verifica riguarda solo i saldi del tuo account per gli asset inclusi nell'ambito al momento della revisione. Non rispecchia gli eventuali trade o transazioni eseguiti successivamente, né i saldi disponibili per gli asset che non sono inclusi nell'ambito.

1. Accedi al tuo account di Kraken e naviga fino alla pagina Proof of Reserves nell'interfaccia di Kraken Pro (pro.kraken.com) (Icona dell'account > Proof of Reserves). 

Kraken Proof of Reserves review list

2. Seleziona la scheda Proof of Reserves. Verranno visualizzati i nostri ultimi coefficienti di riserva verificati, oltre a informazioni specifiche del tuo account. Nella pagina del tuo account verranno visualizzati gli ultimi report Proof of Reserves in cui è stato verificato il saldo del tuo account, che includono la data del report, il provider e l'ambito della valutazione. 

Kraken Proof of Reserves review list

3. Seleziona la data e clicca su Verifica tu stesso. Qui troverai la conferma dei saldi disponibili al momento della revisione, oltre a una guida per la verifica dei tuoi dati.

Kraken audit details

Verifica il revisore contabile di terza parte

  • Usa il tuo Merkle Leaf ID - Copia i primi 16 caratteri e inseriscili nello strumento contabile di terze parti, per recuperare i tuoi salti e verificare il tuo ID per percorso del Merkle tree. Lo strumento contabile di terze parti verrà aperto in una finestra separata. 

Nota: Questo servizio è disponibile a partire dalle revisioni del 2023. Per le revisioni precedenti, puoi cercare gli strumenti di verifica nella pagina Web del nostro partner.

Kraken audit details

Verifica con Kraken

  • Verifica il tuo Record ID - Segui la procedura per ricostruire il tuo Record ID, che identifica univocamente i dati del tuo account e l'ID della revisione (univoco per ogni data di report)
  • Verifica il tuo Merkle Leaf ID - Segui la procedura per ricostruire il tuo Merkle Leaf ID, che identifica univocamente il tuo account insieme ai saldi disponibili nel momento in cui è stata acquisita l'istantanea per la revisione 
  • Verifica il tuo Merkle Leaf ID nel Merkle tree - Verifica che il tuo ID appartenga al Merkle tree e convalida il percorso della radice del Merkle tree, che viene verificato dal nostro studio contabile indipendente e condiviso con tutti i clienti

Nota: Questo servizio è disponibile a partire dalle revisioni del 2023. Per le revisioni precedenti, puoi cercare gli strumenti di verifica nella pagina Web del nostro partner.

Kraken audit details
Kraken audit details
Kraken audit details

Verifica avanzata

I clienti esperti di tecnologia potrebbero avvertire l'esigenza di ricostruire autonomamente l'hash specifico del nodo foglia del Merkle tree ed esaminare i saldi del loro Merkle tree a livello di programmazione, anziché utilizzare gli strumenti grafici forniti da Kraken o da uno studio contabile esterno. 

Le verifiche riportate di seguito possono essere eseguite nel codice:

  1. La procedura che segue consente di verificare la generazione del tuo Merkle Tree Leaf ID per il tuo account.  

  2. Successivamente puoi verificare il percorso del tuo Merkle tree per l'ID foglia e ricostruire il percorso dalla tua posizione al nodo radice. Per garantire trasparenza completa, forniamo anche gli ID delle foglie di pari livello. 

I passaggi da eseguire nello pseudocodice per ricostruire l'ID del record e la Merkle Leaf a partire dal codice del tuo account, dall'IIBAN di Kraken, dall'ID della revisione e dai saldi sono riportati di seguito. Ricorda che i risultati dipendono dalla formattazione specifica della stringa dei saldi e dall'ordine degli asset inclusi nella revisione, visualizzato nella pagina Proof of Reserves.

  • Record ID = SHA256(concatenate(Account Code, Kraken IIBAN, Review ID))
  • Balances = ""
  • ForEach Asset:
    • Balances = concatenate(Asset, ":", AssetBalances[asset])
  • Merkle Hash = concatenate(Record ID, “,”, Balances)
  • Merkle Leaf = substring(SHA256(Merkle Hash), 0, 16)

Dopo l'identificazione della tua Merkle Leaf, puoi eseguire una verifica SHA256 con valori esadecimali per ricostruire il percorso del Merkle tree.

I frammenti di codice riportati di seguito contengono alcuni esempi specifici. Nei dettagli della revisione è visibile anche la Merkle Leaf, per consentirti di verificare se hai eseguito la ricostruzione correttamente.

python

Python

import hashlib

# Merkle Leaf ID calculation
account_code = "8dc20f34da8cea8dd0f46b001694f5123ecd30d786c5eb92ad1a013703a4f8d1"
iiban = "AB12C34DEFG5KSQI"
review_id = "PR30SEP24"
record_id = hashlib.sha256((account_code + iiban + review_id).encode('utf-8')).hexdigest()

balances = "BTC:0.00093799,ETH:0.0422125592,SOL:0.0,USDC:0.0,USDT:6.72754,XRP:0.0"

print("Record ID: {}".format(record_id))
print("Merkle Hash: {}".format((record_id + "," + balances)))
hash_result = hashlib.sha256((record_id + "," + balances).encode('utf-8')).hexdigest()
print("SHA Result: {}".format(hash_result))
print("Merkle Leaf: {}".format(hash_result[0:16]))

#Merkle Tree Path function 
def mix(x, y):
    a = bytes.fromhex(x)
    b = bytes.fromhex(y)

    d = hashlib.sha256()
    d.update(a)
    d.update(b)
    return d.hexdigest()
rust

Rust

use sha2::{Digest, Sha256};

//Merkle Leaf ID calculation
const ACCOUNT_CODE: &str = "8dc20f34da8cea8dd0f46b001694f5123ecd30d786c5eb92ad1a013703a4f8d1";
const IIBAN: &str = "AB12C34DEFG5KSQI";
const REVIEW_ID: &str = "PR30SEP24";
const BALANCES: &str = "BTC:0.00093799,ETH:0.0422125592,SOL:0.0,USDC:0.0,USDT:6.72754,XRP:0.0";

fn main() {
    let mut record_hasher: Sha256 = Default::default();

    record_hasher.update(ACCOUNT_CODE);
    record_hasher.update(IIBAN);
    record_hasher.update(REVIEW_ID);

    let record_id = format!("{:x}", record_hasher.finalize());
    let merkle_hash = format!("{},{}", record_id, BALANCES);

    let mut merkle_hasher: Sha256 = Default::default();
    merkle_hasher.update(&merkle_hash);
    let merkle_result = format!("{:x}", merkle_hasher.finalize());

    println!("Record ID: {}", record_id);
    println!("Merkle Hash: {}", merkle_hash);
    println!("SHA Result: {}", merkle_result);
    println!("Merkle Leaf: {}", &merkle_result[..16]);
}

//Merkle Tree Path function
fn mix(x: &str, y: &str) -> Result<String, hex::FromHexError> {
    let mut leaves_hasher: Sha256 = Default::default();
    let a = hex::decode(x)?;
    let b = hex::decode(y)?;
    leaves_hasher.update(&a);
    leaves_hasher.update(&b);
    Ok(hex::encode(leaves_hasher.finalize()))
}

fn main() {
    println!("{}", mix("f42372aeb1be7296", "dfcced6ec3235f5e").unwrap());
    assert_eq!(
        mix("f42372aeb1be7296", "dfcced6ec3235f5e").unwrap(),
        "ad86a5ee2f21347403ce07e365530604690454fa76787e76be9d2f6efdceeabf"
    );
}
go

Go

package main

import (
	"crypto/sha256"
	"fmt"
)

//Merkle Leaf ID Calculation
func main() {

	accountCode := "8dc20f34da8cea8dd0f46b001694f5123ecd30d786c5eb92ad1a013703a4f8d1"
	iiban := "AB12C34DEFG5KSQI"
	reviewId := "PR30SEP24"

	secret := accountCode + iiban + reviewId

	data := []byte(secret)
	hash := sha256.Sum256(data)
	recordId := string(hash[:])
	fmt.Printf("Record ID: %x\n", recordId)

	balances := "BTC:0.00093799,ETH:0.0422125592,SOL:0.0,USDC:0.0,USDT:6.72754,XRP:0.0"

	merkleHash := fmt.Sprintf("%x%s%s", recordId, ",", balances)
	fmt.Printf("Merkle Hash: %s\n", merkleHash)

	hashResult := sha256.Sum256([]byte(merkleHash))
	hashResultStr := string(hashResult[:])
	fmt.Printf("SHA Result: %x\n", hashResultStr)
	fmt.Printf("Merkle Leaf: %x\n", hashResultStr[0:8])

}

//Merkle Tree path hashing
func mix(x, y string) (string, error) {
        // Convert the hex strings to bytes
        a, err := hex.DecodeString(x)
        if err != nil {
                return "", err
        }

        b, err := hex.DecodeString(y)
        if err != nil {
                return "", err
        }

        h := sha256.New()

        h.Write(a)
        h.Write(b)

        // Get the final hash value as a byte slice
        hashed := h.Sum(nil)

        // Convert the hash to a hex string and return it
        return hex.EncodeToString(hashed), nil
}

func main() {
        result, _ := mix("f42372aeb1be7296", "dfcced6ec3235f5e")
        fmt.Println(result)
}
bash

Bash

#!/bin/bash

#Merkle Leaf ID calculation
ACCOUNT_CODE="8dc20f34da8cea8dd0f46b001694f5123ecd30d786c5eb92ad1a013703a4f8d1"
IIBAN="AB12C34DEFG5KSQI"
REVIEW_ID="PR30SEP24"
RECORD_ID=$(echo -n "${ACCOUNT_CODE}${IIBAN}${REVIEW_ID}" | sha256sum | head -c 64)
BALANCES="BTC:0.00093799,ETH:0.0422125592,SOL:0.0,USDC:0.0,USDT:6.72754,XRP:0.0"
MERKLE_HASH="${RECORD_ID},${BALANCES}"
HASH_RESULT=$(echo -n ${MERKLE_HASH} | sha256sum | head -c 64)

echo "Record ID: ${RECORD_ID}"
echo "Merkle Hash: ${MERKLE_HASH}"
echo "SHA Result: ${HASH_RESULT}"
echo "Merkle Leaf: $(echo -n ${HASH_RESULT} | head -c 16)"

#Merkle Tree Path function
hex_string1="f42372aeb1be7296"
hex_string2="dfcced6ec3235f5e"

# convert hex strings to binary, concatenate them and then hash
hash_result=$(echo -n "$(echo -n $hex_string1 | xxd -r -p)$(echo -n $hex_string2 | xxd -r -p)" | sha256sum | awk '{ print $1 }')

echo $hash_result

Carenze e miglioramenti futuri

Al fine di promuovere la massima trasparenza, vogliamo condividere alcune carenze che abbiamo rilevato nel processo Proof of Reserves.

  • Il processo Proof of Reserves prevede la verifica del controllo sui fondi on-chain nel momento specifico della revisione, ma non può dimostrare il possesso esclusivo delle chiavi private, che in teoria potrebbero essere state duplicate da un hacker.
  • La procedura non è in grado di identificare gli eventuali gravami nascosti, né di dimostrare che i fondi non sono stati presi in prestito al solo scopo di superare la revisione. In ogni caso, gli spostamenti dei fondi sono visibili sulla blockchain, perché noi garantiamo la trasparenza degli indirizzi a cui si trovano i nostri asset. Analogamente, è possibile che le chiavi vengano perse e che i fondi vengano rubati dopo l'ultima revisione.
  • Il contabile deve essere competente e indipendente, per ridurre al minimo il rischio di duplicazione da parte del candidato o di collusione fra le parti.
  • Noi stiamo cercando di colmare alcune di queste carenze, facendo eseguire le nostre revisioni Proof of Reserves a uno studio rinomato e indipendente, a intervalli regolari. Inoltre, forniamo la massima trasparenza su questi dati direttamente nella piattaforma per i clienti.