Prova de Reserva

Nosso compromisso com a transparência

Prestação de contas, revisões regulares

Na Kraken, nós não oferecemos apenas a capacidade de negociar ativos digitais atuais, estamos trabalhando para aproveitar a transparência das blockchains de código aberto nas quais operam.

Nossas avaliações regulares de Prova de Reserva facilitam a verificação pelos clientes de que os saldos no escopo que possuem são respaldados por ativos reais, tudo com apenas alguns cliques em sua conta.

Um procedimento de contabilidade criptográfica avançada realizado regularmente por contadores de confiança, a Prova de Reserva permite que você verifique que a Kraken cumpre normas rigorosas de contabilização e excede a transparência oferecida por empresas financeiras legadas.

O que é prova de reservas?

Uma revisão de Prova de Reserva (PoR) é um procedimento realizado por um contador independente terceiro. Isto destina-se a confirmar que um custodiante detém os ativos aos quais reivindica em nome dos seus clientes. Esse contador tira um snapshot anonimizado de todos os saldos mantidos e os agrega em um Merkle Tree, uma estrutura de dados respeitadora da privacidade que engloba todos os saldos dos clientes.

A partir disso, o contador obtém um Merkle root: uma impressão digital criptográfica que identifica exclusivamente a combinação desses saldos no momento em que o snapshot foi criado.

Em seguida, o contador coleta assinaturas digitais produzidas pela Kraken, que provam a propriedade dos endereços on-chain com saldos verificáveis publicamente. Por fim, o contador compara e verifica se esses saldos excedem ou correspondem com os saldos do cliente representados na Merkle tree e, portanto, se os ativos do cliente estão no controle da Kraken.

Qualquer cliente pode verificar de forma independente se seu saldo foi incluído no procedimento de Prova de Reserva comparando partes de dados selecionadas com a Merkle root. Quaisquer alterações feitas no resto dos dados, ainda que pequenas, afetarão a root, evidenciando a adulteração.

O que a Prova de Reservas abrange?

Saldos spot

A revisão conterá todos os seus saldos nos ativos em escopo, mantidos no momento em que o snapshot foi realizado. Os seguintes ativos estão em escopo a partir da revisão mais recente: Bitcoin (BTC), Ether (ETH), Solana (SOL), USD Coin (USDC), Tether (USDT) e Ripple (XRP).

Saldos de staking

Se você tiver saldos alocados para staking on-chain no momento do instantâneo, o valor do seu saldo em stake será agregado ao seu saldo à vista em um único saldo.

Negociação com margem

Se você tinha posições com margem no momento, então seu saldo total será ajustado pelos valores positivos das posições.

Exemplo 1

Se você vendeu 1 BTC/USD à USD 30.000 com margem e sua posição está aberta, o saldo de Prova de Reserva refletirá um ajuste positivo de +1 BTC no seu saldo de BTC. Não haverá ajuste negativo no seu saldo de USD. Seu saldo de ativos BTC mantido sob custódia Kraken incluirá seu saldo BTC no momento, ajustado pelo ajuste positivo de BTC +1 para suas posições com margem. Seu saldo de ativos em USD permanecerá o mesmo.

Exemplo 2

Se você vendeu 1 BTC/ETH à 15 ETH com margem e sua posição está aberta, seu saldo de Prova de Reserva refletirá um ajuste positivo de +15 ETH no seu saldo de ETH. Não haverá ajuste negativo para o seu saldo de BTC. Seu saldo de ativos ETH mantido sob custódia Kraken incluirá seu saldo ETH no momento, ajustado pelo ajuste positivo de ETH 15 para suas posições com margem. Seu saldo de ativos de BTC mantido sob custódia da Kraken permanecerá o mesmo.

Observação: A metodologia de futuros descrita acima entra em vigor a partir das revisões da Prova de Reserva de maio de 2023.

Saldos futuros

Se você tinha saldos na sua carteira de Futuros no momento da revisão, um registro separado de Prova de Reservas existirá para os saldos colaterais dos seus futuros. Seus saldos são ajustados por lucro e perda não realizados para negociações de futuros de colateral único. Isso incluirá os mesmos ativos dentro do escopo tanto para spot quanto margem, e fará parte da mesma Merkle tree (com seu próprio ID de Merkle Leaf).

Exemplo 1

Se você tinha 1 BTC em sua carteira de futuros, e você abrir uma posição no BTC Perp Single Collateral, que tem um lucro e perda não realizados de -0,1 BTC, então seu saldo de BTC mantido sob custódia da Kraken será de 0,9 BTC (seu 1 BTC, ajustado em -0,1 BTC para L&P não realizado).

Exemplo 2

Se você tiver 1 BTC em sua carteira de futuros e abrir uma posição em BTC Perp Multi-Collateral, que possui um lucro e perda não realizado de USD -100,00, então seu saldo de BTC sob custódia da Kraken permanecerá 1 BTC (seu 1 BTC não é ajustado pelo L&P não realizado, pois isso é rastreado em USD, e USD não é um ativo em escopo para esta revisão).

Observação: A metodologia de futuros descrita acima entra em vigor a partir das revisões da Prova de Reserva de maio de 2023.

Verificar se a sua conta foi incluída na revisão de Prova de Reserva

Verificação simples

Siga os passos abaixo para verificar criptograficamente a inclusão do saldo da sua conta Kraken na revisão mais recente de Prova de Reserva.

Observação: Esta verificação só refletirá os saldos da sua conta nos ativos dentro do escopo no momento da revisão. Não refletirá quaisquer negociações ou transações subsequentes, nem refletirá saldos detidos em ativos que não estão dentro do escopo.

1. Inicie a sessão na sua conta Kraken e navegue até à página Prova de Reservas na interface do Kraken Pro (pro.kraken.com) (ícone da Conta Prova de Reserva).

2. Selecione a guia Prova de Reserva. Isso incluirá os nossos índices de reserva verificados mais recentes, bem como informações específicas da a sua conta. A sua conta irá apresentar relatórios de Prova de Reserva recentes nos quais o saldo da sua conta foi verificado, incluindo a data do relatório, o provedor e o escopo de avaliação.

3. Selecione a data e clique em Verifique-se. Aqui, você encontrará a confirmação dos saldos mantidos no momento da revisão, bem como um guia sobre como verificar suas informações.

Verificar com o contador terceiro

Utilize o seu ID Merkle Leaf - copie os primeiros 16 caracteres e insira-os nas ferramentas de contadores terceirizados para recuperar os seus saldos e revisar o seu ID no caminho Merkle Tree. A ferramenta de contadores terceirizados será aberta em uma janela separada.

Observação: Isto foi disponibilizado a partir das revisões de 2023. Para consultar as revisões anteriores, consulte a página online do nosso parceiro para encontrar as ferramentas de verificação.

Verifique com a Kraken

Verifique o ID do seu registro- siga os passos para recriar o ID do registro, que identifica exclusivamente os detalhes da sua conta e o ID de revisão (exclusivo para cada data de relatório)
Verifique a seu ID de Merkle Leaf - siga os passos para recriar a seu ID de Merkle Leaf, que identifica exclusivamente a sua conta, juntamente com os saldos mantidos no momento da revisão do snapshot
Confirme seu ID de Merkle Leaf no Merkle Tree - confirme que seu ID pertence ao Merkle Tree e valide o caminho para o Merkle Tree root, que é verificado por um contador terceiro e compartilhado por todos os clientes

Verificação avançada

Clientes com conhecimento técnico podem desejar reconstruir de forma independente o hash do node de sua Merkle tree leaf e consultar seus saldos na Merkle tree programaticamente, em vez de usar as ferramentas visuais fornecidas pela Kraken ou por contadores terceiro.

Você pode realizar as seguintes etapas de verificação no código:

Você pode verificar a geração do seu ID Merkle Tree Leaf para sua conta, com os passos descritos abaixo.
Você pode então verificar o Merkle Tree Path para o ID de leaf e reconstruir o caminho da sua posição para o root node. Oferecemos total transparência e também incluímos os IDs de leaf irmãs.

As etapas necessárias, em pseudocódigo, para reconstruir o ID de registro e o Merkle Leaf a partir do seu Código de conta, Kraken IIBAN, ID de revisão e saldos são descritos abaixo. Observe que os resultados são sensíveis à formatação de string específica dos saldos e à ordem dos ativos revisados, conforme exibido na página da Prova de Reserva.

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

Depois que seu Merkle Leaf é identificado, você pode usar uma verificação SHA256 com valores HEX para reconstruir o caminho do Merkle Tree.

Exemplos específicos também são demonstrados nos snippets de código abaixo. A folha de Merkle resultante também é visível nos detalhes da revisão para ajudar a confirmar que você reconstruiu isso corretamente.

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

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"
    );
}

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

#!/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

Deficiências e melhorias futuras

No interesse de promover a transparência, gostaríamos de compartilhar algumas das limitações no processo de Prova de Reservas que identificamos.

Uma Prova de Reserva envolve comprovar o controle sobre os fundos on-chain no momento da revisão, mas não pode provar a posse exclusiva das chaves privadas, que podem ter sido teoricamente duplicadas em um ataque.
O procedimento não pode identificar quaisquer ônus ocultos ou provar que os fundos não foram emprestados para fins de aprovação na revisão. No entanto, a movimentação de fundos é visível na blockchain, pois fornecemos transparência sobre os endereços onde nossos ativos estão localizados. Da mesma forma, as chaves podem ter sido perdidas ou os fundos roubados desde a última revisão.
O contador deve ser competente e independente para minimizar o risco de duplicidade por parte do examinador ou conluio entre as partes.
Buscamos mitigar algumas dessas limitações ao nos envolver com uma empresa independente respeitável para nossa Prova de Reserva e realizar essas revisões de forma regular. Também fornecemos transparência sobre esses dados diretamente em nossa plataforma de cliente.

Criar conta

Produtos

Negociação

Por que a Kraken?