Prova de Reserva

Prove que seus fundos são seguros, quando desejar.

Verifique a sua contaCadastre-se

Horário do instantâneo

Exibir relatório

BTC icon

BTC

Índice de reserva

100.3%

ETH icon

ETH

Índice de reserva

101.3%

SOL icon

SOL

Índice de reserva

101.1%

USDC icon

USDC

Índice de reserva

+105%

USDT icon

USDT

Índice de reserva

+105%

XRP icon

XRP

Índice de reserva

100.6%

ADA icon

ADA

Índice de reserva

102.2%

Prestação de contas e 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 revisões periódicas de Prova de Reserva facilitam para que os clientes verifiquem que seus saldos que estão dentro do escopo estã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.

Perguntas frequentes

O que é Prova de Reserva?

Uma revisão de Prova de Reserva (PoR) é um procedimento realizado por um contador independente externo. O objetivo é confirmar que o custodiante detém os ativos que alega ter em nome de seus clientes. Esse contador tira um snapshot anonimizado de todos os saldos mantidos e os agrega em uma Merkle Tree, uma estrutura de dados que preza pela privacidade que engloba todos os saldos dos clientes.

Merkle Root Hash

A partir disso, o contador obtém uma raiz da Merkle: 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 raiz da Merkle. Quaisquer alterações feitas no resto dos dados, ainda que pequenas, afetarão a raiz, evidenciando a adulteração.

Nosso relatório Prova de Reserva pode ser encontrado aqui.

O que a Prova de Reserva 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 em stake

Se você tiver saldos alocados para staking on-chain no momento do snapshot, o valor do seu saldo em stake será agregado ao seu saldo spot 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ê comprou 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 +1 BTC 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 + 15 ETH 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 está 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 Reserva 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 Lucros e Perdas 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 está em vigor a partir das revisões da Prova de Reserva de maio de 2023. 

Como faço para verificar se a minha conta foi incluída na análise 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 Reserva na interface do Kraken Pro (pro.kraken.com) (Ícone da Conta > Prova de Reserva). 

Kraken Proof of Reserves review list

2. Selecione a guia Prova de Reserva. Isso incluirá os nossos índices de reserva verificados mais recentes, bem como informações específicas da 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. 

Kraken Proof of Reserves review list

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

Kraken audit details

Verificar com o contador externo

  • Utilize o seu ID da Merkle Leaf - copie os primeiros 16 caracteres e insira-os nas ferramentas do contador externo para recuperar os seus saldos e revisar o seu ID no caminho da Merkle Tree. A ferramenta do contador externo 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.

Kraken audit details

Verificar 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 o seu ID de Merkle Leaf - siga os passos para recriar o 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 na Merkle Tree - confirme que seu ID pertence à Merkle Tree e valide o caminho para raiz da Merkle Tree, que é verificado por um contador externo e compartilhado por todos os clientes

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.

Kraken audit details
Kraken audit details
Kraken audit details

Verificação avançada

Clientes com conhecimento técnico podem desejar reconstruir de forma independente o hash do nó de sua Merkle Tree Leaf e consultar seus saldos na Merkle Tree programaticamente, em vez de usar as ferramentas visuais fornecidas pela Kraken ou pelo contador externo. 

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

  1. Você pode verificar a geração do seu ID da Merkle Tree Leaf para sua conta, com os passos descritos abaixo.  

  2. Você pode então verificar o caminho da Merkle Tree para o ID de leaf e reconstruir o caminho da sua posição para o nó da raiz. Oferecemos total transparência e também incluímos os IDs de leafs irmãs. 

As etapas necessárias, em pseudocódigo, para reconstruir o ID de registro e a Merkle Leaf a partir do seu Código de conta, IIBAN da kraken, 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.

  • ID de registro = 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 sua Merkle Leaf é identificada, você pode usar uma verificação SHA256 com valores HEX para reconstruir o caminho da Merkle Tree.

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

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

Limitações e melhorias futuras

No interesse de promover a transparência, gostaríamos de compartilhar algumas das limitações no processo de Prova de Reserva 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. 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

The reserve ratio figures marked with an asterisk (*) above may change materially when comparing Kraken's Proof of Reserves reports due to product changes and enhancements to our custodial infrastructure across time, which may affect the classification of certain of the assets held in these wallets. Consistent with current practice, an explanation of the precise Proof of Reserves methodology is included in all Reports.