PSBT

• BIP 174: Partially Signed Bitcoin Transaction Format
• BIP 370: PSBT Version 2

Uma PSBT (Partially Signed Bitcoin Transaction — transação de bitcoin parcialmente assinada) é um formato de dados para passar transações adiante para assinatura.

Esse formato contém, essencialmente, os dados brutos de uma transação não assinada, junto com os dados extras necessários para assinar as entradas.

Então, se você exportar uma transação não assinada da sua carteira de bitcoin, ela provavelmente estará no formato PSBT. A maioria das carteiras modernas suporta a exportação e a assinatura de PSBTs, por exemplo:

• Electrum (carteira de desktop)
• Sparrow (carteira de desktop)
• Trezor (carteira de hardware)
• Coldcard (carteira de hardware)

Decodificador de PSBT

Decodificador básico para o formato de dados PSBT (BIP 174 / BIP 370).

Dados da PSBT

Exemplos [mostrar]

v0: P2WPKH

Creador Actualizador Firmante Finalizador de entrada

v0: Multifirma

Creador Actualizador Firmante 1 Firmante 2 Combinador Finalizador de entrada

v2: P2WPKH

Creador Constructor Actualizador Firmante Finalizador de entrada

v2: Multifirma

Creador Constructor Actualizador Firmante 1 Firmante 2 Combinador Finalizador de entrada

Hex Base64

0 bytes

Result

Maps Split

Propósito

Por que precisamos de PSBTs?

Para assinar uma transação de bitcoin, você na verdade precisa de algumas informações adicionais que não estão incluídas nos próprios dados brutos da transação não assinada.

Por exemplo, se você quer criar uma assinatura para destravar uma entrada P2WPKH, você precisa dos seguintes dados extras:

• O ScriptPubKey da saída sendo gasta.
• O valor da saída sendo gasta.

Essa informação fica armazenada na transação anterior que criou a saída (UTXO), mas não na transação atual que a gasta como entrada.

Ora, isso não é um problema se você está usando uma carteira com conexão à internet (ou seja, uma "hot wallet"), pois essa informação pode ser recuperada da blockchain ao procurar a transação anterior que criou a UTXO que você está gastando.

Porém, se você está usando uma carteira offline para assinar a sua transação (ex.: um dispositivo de hardware ou "cold wallet"), ela não terá uma cópia atualizada da blockchain. Então, mesmo que ela tenha a chave privada para assinar a entrada, ela não tem acesso à informação extra necessária para de fato criar a assinatura.

Portanto, o formato PSBT permite que você passe todos os dados necessários para assinar a transação em uma carteira/dispositivo separado.

Benefícios

Por que o formato PSBT foi criado?

Uma PSBT fornece um formato padrão para passar transações adiante para assinatura.

Antes das PSBTs, as carteiras implementavam o seu próprio formato para exportar os dados extras necessários para criar as assinaturas de uma transação. Isso funcionava, mas significava que o seu formato de transação não assinada provavelmente não era compatível com outras carteiras e dispositivos. Portanto, a pessoa que assinasse a PSBT precisaria usar o mesmo software que a pessoa que a criou.

Porém, com as PSBTs, uma transação não assinada pode ser exportada e assinada por diferentes carteiras e dispositivos.

Por exemplo, você poderia construir uma transação que gasta uma saída multisig (ex.: P2MS), exigindo assinaturas de 3 pessoas diferentes para destravá-la. Usando o formato PSBT, você pode enviar a cada signatário os dados da transação não assinada, e cada signatário pode usar a carteira/dispositivo que preferir para adicionar a sua assinatura, sem ter que se preocupar se o seu software entende o formato da transação não assinada.

Essas PSBTs separadas podem então ser combinadas para criar a transação final assinada.

Então, ter um formato comum para transações não assinadas (ou parcialmente assinadas) permite a compatibilidade entre diferentes carteiras e dispositivos de bitcoin.

Estrutura

Como é uma PSBT?

O formato PSBT é uma série de pares chave-valor contidos dentro de mapas separados.

Cabeçalho

Uma PSBT sempre começa com alguns bytes de cabeçalho para identificar os dados como uma PSBT:

• Cabeçalho – Os magic bytes 70736274 ('psbt' em ASCII) seguidos de um separador ff de 1 byte.

ASCII

ASCII

Converta entre bytes (em hexadecimal) e caracteres ASCII.

Exemplo Hex 0 bytes

Bytes

ASCII 0 caracteres

• Os bytes hex entre 0x20 e 0x7f contêm os caracteres imprimíveis.
• Qualquer valor 0x1f ou abaixo é um caractere de controle (não será exibido, ou exibirá um caractere estranho).
• Qualquer valor 0x80 ou acima não exibirá nada.

Veja o padrão de codificação ISO 646 para detalhes.

Mapas

Depois do cabeçalho, a PSBT contém três tipos de mapa (na seguinte ordem):

• Mapa Global — Informação geral sobre a transação não assinada.
  • Normalmente contém os dados da transação não assinada.
  • Há apenas um mapa global.
• Mapa(s) de Entrada — Dados relacionados a cada entrada da transação não assinada.
  • Normalmente contém os dados extras necessários para criar as assinaturas de cada entrada.
  • Pode haver vários mapas de entrada (um para cada entrada da transação não assinada).
• Mapa(s) de Saída — Dados relacionados a cada saída da transação não assinada.
  • Normalmente contém informações suplementares sobre as saídas da transação. Por exemplo, isso pode ser usado para ajudar a identificar as saídas de troco.
  • Pode haver vários mapas de saída (um para cada saída da transação não assinada).

O fim de cada mapa é indicado por um separador 00 de 1 byte.

Os mapas de entrada e de saída precisam estar na ordem correspondente às entradas e saídas da transação não assinada. Cada entrada e saída precisa ter o seu próprio mapa. Se você não precisa incluir nenhum par chave-valor para uma entrada ou saída, basta usar o separador 00 para indicar o fim do mapa.

Você precisa extrair a contagem de entradas e a contagem de saídas da transação não assinada a partir do mapa global, para determinar o número de mapas de entrada e de saída na PSBT.

Chave-Valor

Dentro de cada mapa há uma série de pares chave-valor.

Cada par chave-valor tem a seguinte estrutura:

• Chave:
  • Comprimento — Um campo compact size indicando o tamanho dos campos de tipo e dados a seguir.
  • Tipo — Um campo compact size indicando o tipo de dado armazenado (veja tipos de chave).
  • Dados — Alguns dados extras relacionados ao tipo. Esse campo nem sempre contém dados, mas, quando contém, permite múltiplas chaves do mesmo tipo em um mapa sem haver duplicatas.
• Valor:
  • Comprimento — Um campo compact size indicando o tamanho do campo de dados a seguir.
  • Dados — O dado principal associado à chave.

Esses pares chave-valor se repetem até o fim do mapa ser alcançado.

Código

Como decodificar e codificar uma PSBT

Aqui estão alguns trechos simples de código para decodificar e codificar PSBTs brutas.

Esses trechos de código não implementam todas as etapas necessárias para processar PSBTs (esse é o seu trabalho), nem detectam quaisquer erros, mas devem ser úteis para você pegar o jeito de desmontar e construir PSBTs para depuração e testes.

# ----
# PSBT
# ----

# psbt de exemplo em base64
base64 = "cHNidP8BAHcCAAAAAfdOPcmRewY2v88bQwUxucGsxSuXH0uEkKSNE80NzyiB
AAAAAAD9////AjU+AAAAAAAAGXapFD8wj0I2S+BXFbGa4wd7u8o36zxniKy2
WQAAAAAAABl2qRRjuoLSTMaSnO/tORKfAZa2RonLgYisf8kNAAABAL8CAAAA
AV4xZeLXJkrfKXk+fL6JBWhcMD/l0EPa78AWP1Pr4UpyAAAAAGpHMEQCIBS7
ZFI/kRlbC4oeDirf3uVy1EWPiNqSHhcwmkkiSwQ9AiAitN+1CQUHNCeY9dsc
ruF1U+B4Y+XtR5wXd83/YNy8ugEhAqAoKT0yVpnlt6sXX1Qz6eC2kO49L16M
A34ipmgeGZtl/f///wHNmAAAAAAAABl2qRSFdGbzr4xiIfOuLmEpSa4n414z
LYisf8kNACIGAxWaFXJLMzktDDpTbQAFCIllf+xM8nxjA86XolMXHogOGJwO
R5IsAACAAAAAgAAAAIAAAAAAAAAAAAAiAgKh3fjioSvCMeCiWW2YHs/jG7yf
7Ld4HzMyz/wF8fcKehicDkeSLAAAgAAAAIAAAACAAQAAAAAAAAAAAA=="

# converte base64 para string hex
require 'base64'
hex = Base64.decode64(base64).unpack("H*")[0]

# dica: se quiser decodificar a partir de hex em vez de base64, descomente a linha abaixo e coloque a string hex aqui
# hex = '70736274ff0100770200000001f74e3dc9917b0636bfcf1b430531b9c1acc52b971f4b8490a48d13cd0dcf28810000000000fdffffff02353e0000000000001976a9143f308f42364be05715b19ae3077bbbca37eb3c6788acb6590000000000001976a91463ba82d24cc6929cefed39129f0196b64689cb8188ac7fc90d00220603159a15724b33392d0c3a536d00050889657fec4cf27c6303ce97a253171e880e189c0e47922c0000800000008000000080000000000000000000220202a1ddf8e2a12bc231e0a2596d981ecfe31bbc9fecb7781f3332cffc05f1f70a7a189c0e47922c000080000000800000008001000000000000000000'

# mostra a PSBT em formato hex
puts hex
puts

# ---------
# Funções
# ---------
# Funções utilitárias para ajudar na decodificação

def read_compact_size(buffer)
  # lê o primeiro byte
  byte = buffer.read(1)

  # converte o byte em valor inteiro
  int = byte.unpack("C")[0] # C = inteiro [8 bits] (sem sinal)

  # obtém o valor contido no campo compact size
  if (int <= 0xFC)
    value = int # este byte
  elsif (int == 0xFD)
    value = buffer.read(2).unpack("v")[0] # próximos 2 bytes
  elsif (int == 0xFE)
    value = buffer.read(4).unpack("V")[0] # próximos 4 bytes
  elsif (int == 0xFF)
    value = buffer.read(8).unpack("Q")[0] # próximos 8 bytes
  end

  # retorna o valor
  return value
end

# ---------
# Tipos de Chave
# ---------
# Um array com todos os tipos de chave, útil para exibir o nome do tipo de chave

types = {
  'global' => {
    0 => 'PSBT_GLOBAL_UNSIGNED_TX',
    1 => 'PSBT_GLOBAL_XPUB',
    2 => 'PSBT_GLOBAL_TX_VERSION',
    3 => 'PSBT_GLOBAL_FALLBACK_LOCKTIME',
    4 => 'PSBT_GLOBAL_INPUT_COUNT',
    5 => 'PSBT_GLOBAL_OUTPUT_COUNT',
    6 => 'PSBT_GLOBAL_TX_MODIFIABLE',
    7 => 'PSBT_GLOBAL_SP_ECDH_SHARE',
    8 => 'PSBT_GLOBAL_SP_DLEQ',
    251 => 'PSBT_GLOBAL_VERSION',
    252 => 'PSBT_GLOBAL_PROPRIETARY'
  },
  'input' => {
    0 => 'PSBT_IN_NON_WITNESS_UTXO',
    1 => 'PSBT_IN_WITNESS_UTXO',
    2 => 'PSBT_IN_PARTIAL_SIG',
    3 => 'PSBT_IN_SIGHASH_TYPE',
    4 => 'PSBT_IN_REDEEM_SCRIPT',
    5 => 'PSBT_IN_WITNESS_SCRIPT',
    6 => 'PSBT_IN_BIP32_DERIVATION',
    7 => 'PSBT_IN_FINAL_SCRIPTSIG',
    8 => 'PSBT_IN_FINAL_SCRIPTWITNESS',
    9 => 'PSBT_IN_POR_COMMITMENT',
    10 => 'PSBT_IN_RIPEMD160',
    11 => 'PSBT_IN_SHA256',
    12 => 'PSBT_IN_HASH160',
    13 => 'PSBT_IN_HASH256',
    14 => 'PSBT_IN_PREVIOUS_TXID',
    15 => 'PSBT_IN_OUTPUT_INDEX',
    16 => 'PSBT_IN_SEQUENCE',
    17 => 'PSBT_IN_REQUIRED_TIME_LOCKTIME',
    18 => 'PSBT_IN_REQUIRED_HEIGHT_LOCKTIME',
    19 => 'PSBT_IN_TAP_KEY_SIG',
    20 => 'PSBT_IN_TAP_SCRIPT_SIG',
    21 => 'PSBT_IN_TAP_LEAF_SCRIPT',
    22 => 'PSBT_IN_TAP_BIP32_DERIVATION',
    23 => 'PSBT_IN_TAP_INTERNAL_KEY',
    24 => 'PSBT_IN_TAP_MERKLE_ROOT',
    26 => 'PSBT_IN_MUSIG2_PARTICIPANT_PUBKEYS',
    27 => 'PSBT_IN_MUSIG2_PUB_NONCE',
    28 => 'PSBT_IN_MUSIG2_PARTIAL_SIG',
    29 => 'PSBT_IN_SP_ECDH_SHARE',
    30 => 'PSBT_IN_SP_DLEQ',
    252 => 'PSBT_IN_PROPRIETARY'
  },
  'output' => {
    0 => 'PSBT_OUT_REDEEM_SCRIPT',
    1 => 'WPSBT_OUT_WITNESS_SCRIPT',
    2 => 'PSBT_OUT_BIP32_DERIVATION',
    3 => 'PSBT_OUT_AMOUNT',
    4 => 'PSBT_OUT_SCRIPT',
    5 => 'PSBT_OUT_TAP_INTERNAL_KEY',
    6 => 'PSBT_OUT_TAP_TREE',
    7 => 'PSBT_OUT_TAP_BIP32_DERIVATION',
    8 => 'PSBT_OUT_MUSIG2_PARTICIPANT_PUBKEYS',
    9 => 'PSBT_OUT_SP_V0_INFO',
    10 => 'PSBT_OUT_SP_V0_LABEL',
    53 => 'PSBT_OUT_DNSSEC_PROOF',
    252 => 'PSBT_OUT_PROPRIETARY'
  }
}

# ------
# Decodificação
# ------
# Decodifica a PSBT

# estas variáveis serão atualizadas ao percorrer o mapa global, e são necessárias para conseguir ler o mapa de entrada e o mapa de saída seguintes
inputcount = 0
outputcount = 0

# converte a string hex da psbt em bytes
bytes = [hex].pack("H*")

# usa StringIO para ler os bytes conforme avançamos
require "stringio"
buffer = StringIO.new(bytes)

# Cabeçalho
magic_bytes = buffer.read(4)
separator   = buffer.read(1)

# Mapa Global
puts "GLOBAL MAP:"
puts
while true do

  # keylen
  keylen = read_compact_size(buffer)

  # se keylen for 0x00, chegamos ao byte separador e estamos no fim do mapa global
  if (keylen == 0)
    break
  end

  # usa keylen para ler keytype e keydata
  keytype_and_keydata = StringIO.new(buffer.read(keylen)) # cria outro StringIO a partir do buffer para podermos ler bytes dele

  # lê o keytype
  keytype = read_compact_size(keytype_and_keydata)

  # lê o keydata, que são todos os bytes restantes após o keytype
  keydata = keytype_and_keydata.read

  # valuelen
  valuelen = read_compact_size(buffer)

  # valuedata
  valuedata = buffer.read(valuelen)

  # se keytype = 0x00 (TX), extrai inputcount e outputcount dos dados brutos da transação fornecidos
  if (keytype == 0)

    # converte os dados brutos da transação em StringIO para podermos ler bytes dele
    tx = StringIO.new(valuedata)
    version = tx.read(4) # ignora

    # campo de contagem de entradas
    inputcount = read_compact_size(tx)

    # pula as entradas para chegar ao campo outputcount
    inputcount.times do
      txid_vout = tx.read(36)
      scriptsig_size = read_compact_size(tx)
      scriptsig = tx.read(scriptsig_size)
      sequence = tx.read(4)
    end

    # campo de contagem de saídas
    outputcount = read_compact_size(tx)
  end

  # se keytype = 0x04, o inputcount é fornecido explicitamente
  if (keytype == 4)
    inputcount = read_compact_size(StringIO.new(valuedata)) # converte para StringIO para ler o campo compact size
  end

  # se keytype = 0x05, o outputcount é fornecido explicitamente
  if (keytype == 5)
    outputcount = read_compact_size(StringIO.new(valuedata)) # converte para StringIO para ler o campo compact size
  end

  # mostra os dados do par chave-valor
  puts "  key:   #{keytype} (#{types['global'][keytype]}) #{keydata.unpack('H*')[0]}"
  puts "  value: #{valuedata.unpack('H*')[0]}"
  puts
end

# Mapa(s) de Entrada
inputcount.times do |i|
  # percorre cada entrada
  puts "INPUT #{i} MAP:"
  puts

  # obtém os pares chave-valor de cada entrada
  while true do

    # keylen
    keylen = read_compact_size(buffer)

    # se keylen for 0x00, chegamos ao byte separador e estamos no fim dos pares chave-valor desta entrada
    if (keylen == 0)
      break
    end

    # usa keylen para ler keytype e keydata
    keytype_and_keydata = StringIO.new(buffer.read(keylen)) # cria outro StringIO a partir do buffer para podermos ler bytes dele

    # lê o keytype
    keytype = read_compact_size(keytype_and_keydata)

    # lê o keydata, que são todos os bytes restantes após o keytype
    keydata = keytype_and_keydata.read

    # valuelen
    valuelen = read_compact_size(buffer)

    # valuedata
    valuedata = buffer.read(valuelen)

    # mostra os dados do par chave-valor
    puts "  key:   #{keytype} (#{types['input'][keytype]}) #{keydata.unpack('H*')[0]}"
    puts "  value: #{valuedata.unpack('H*')[0]}"
    puts
  end
end

# Mapa(s) de Saída
outputcount.times do |i|
  # percorre cada saída
  puts "OUTPUT #{i} MAP:"
  puts

  # obtém os pares chave-valor de cada saída
  while true do

    # keylen
    keylen = read_compact_size(buffer)

    # se keylen for 0x00, chegamos ao byte separador e estamos no fim dos pares chave-valor desta saída
    if (keylen == 0)
      break
    end

    # usa keylen para ler keytype e keydata
    keytype_and_keydata = StringIO.new(buffer.read(keylen)) # cria outro StringIO a partir do buffer para podermos ler bytes dele

    # lê o keytype
    keytype = read_compact_size(keytype_and_keydata)

    # lê o keydata, que são todos os bytes restantes após o keytype
    keydata = keytype_and_keydata.read

    # valuelen
    valuelen = read_compact_size(buffer)

    # valuedata
    valuedata = buffer.read(valuelen)

    # mostra os dados do par chave-valor
    puts "  key:   #{keytype} (#{types['output'][keytype]}) #{keydata.unpack('H*')[0]}"
    puts "  value: #{valuedata.unpack('H*')[0]}"
    puts
  end
end

# ---------
# Constantes
# ---------

# Define constantes para os tipos de chave globais
PSBT_GLOBAL_UNSIGNED_TX = 0x00
PSBT_GLOBAL_XPUB = 0x01
PSBT_GLOBAL_TX_VERSION = 0x02
PSBT_GLOBAL_FALLBACK_LOCKTIME = 0x03
PSBT_GLOBAL_INPUT_COUNT = 0x04
PSBT_GLOBAL_OUTPUT_COUNT = 0x05
PSBT_GLOBAL_TX_MODIFIABLE = 0x06
PSBT_GLOBAL_SP_ECDH_SHARE = 0x07
PSBT_GLOBAL_SP_DLEQ = 0x08
PSBT_GLOBAL_VERSION = 0xFB
PSBT_GLOBAL_PROPRIETARY = 0xFC

# Define constantes para os tipos de chave de entrada
PSBT_IN_NON_WITNESS_UTXO = 0x00
PSBT_IN_WITNESS_UTXO = 0x01
PSBT_IN_PARTIAL_SIG = 0x02
PSBT_IN_SIGHASH_TYPE = 0x03
PSBT_IN_REDEEM_SCRIPT = 0x04
PSBT_IN_WITNESS_SCRIPT = 0x05
PSBT_IN_BIP32_DERIVATION = 0x06
PSBT_IN_FINAL_SCRIPTSIG = 0x07
PSBT_IN_FINAL_SCRIPTWITNESS = 0x08
PSBT_IN_POR_COMMITMENT = 0x09
PSBT_IN_RIPEMD160 = 0x0A
PSBT_IN_SHA256 = 0x0B
PSBT_IN_HASH160 = 0x0C
PSBT_IN_HASH256 = 0x0D
PSBT_IN_PREVIOUS_TXID = 0x0E
PSBT_IN_OUTPUT_INDEX = 0x0F
PSBT_IN_SEQUENCE = 0x10
PSBT_IN_REQUIRED_TIME_LOCKTIME = 0x11
PSBT_IN_REQUIRED_HEIGHT_LOCKTIME = 0x12
PSBT_IN_TAP_KEY_SIG = 0x13
PSBT_IN_TAP_SCRIPT_SIG = 0x14
PSBT_IN_TAP_LEAF_SCRIPT = 0x15
PSBT_IN_TAP_BIP32_DERIVATION = 0x16
PSBT_IN_TAP_INTERNAL_KEY = 0x17
PSBT_IN_TAP_MERKLE_ROOT = 0x18
PSBT_IN_MUSIG2_PARTICIPANT_PUBKEYS = 0x1A
PSBT_IN_MUSIG2_PUB_NONCE = 0x1B
PSBT_IN_MUSIG2_PARTIAL_SIG = 0x1C
PSBT_IN_SP_ECDH_SHARE = 0x1D
PSBT_IN_SP_DLEQ = 0x1E
PSBT_IN_PROPRIETARY = 0xFC

# Define constantes para os tipos de chave de saída
PSBT_OUT_REDEEM_SCRIPT = 0x00
PSBT_OUT_WITNESS_SCRIPT = 0x01
PSBT_OUT_BIP32_DERIVATION = 0x02
PSBT_OUT_AMOUNT = 0x03
PSBT_OUT_SCRIPT = 0x04
PSBT_OUT_TAP_INTERNAL_KEY = 0x05
PSBT_OUT_TAP_TREE = 0x06
PSBT_OUT_TAP_BIP32_DERIVATION = 0x07
PSBT_OUT_MUSIG2_PARTICIPANT_PUBKEYS = 0x08
PSBT_OUT_SP_V0_INFO = 0x09
PSBT_OUT_SP_V0_LABEL = 0x0A
PSBT_OUT_DNSSEC_PROOF = 0x35
PSBT_OUT_PROPRIETARY = 0xFC

# ---------
# Funções
# ---------
# Funções utilitárias para ajudar na codificação

# Converte um inteiro em um campo compact size
def compact_size(i)
  if (                     i <= 252)                  then compactsize =        [i].pack("C").unpack("H*")[0]
  elsif (i > 252        && i <= 65535)                then compactsize = 'fd' + [i].pack("S<").unpack("H*")[0]
  elsif (i > 65535      && i <= 4294967295)           then compactsize = 'fe' + [i].pack("L<").unpack("H*")[0]
  elsif (i > 4294967295 && i <= 18446744073709551615) then compactsize = 'ff' + [i].pack("Q<").unpack("H*")[0]
  end

  return compactsize
end

# ----
# PSBT
# ----
# Constrói um array de mapas e pares chave-valor para converter em uma PSBT hex

psbt = {
  global: {
    0 => [
      {
        key: {type: PSBT_GLOBAL_UNSIGNED_TX, data: ''},
        value: '0200000001f74e3dc9917b0636bfcf1b430531b9c1acc52b971f4b8490a48d13cd0dcf28810000000000fdffffff02353e0000000000001976a9143f308f42364be05715b19ae3077bbbca37eb3c6788acb6590000000000001976a91463ba82d24cc6929cefed39129f0196b64689cb8188ac7fc90d00', # 1 entrada, 1 saída
      },
    ]
  },
  inputs: {
    0 => [
      {
        key: {type: PSBT_IN_NON_WITNESS_UTXO, data: ''},
        value: '02000000015e3165e2d7264adf29793e7cbe8905685c303fe5d043daefc0163f53ebe14a72000000006a473044022014bb64523f91195b0b8a1e0e2adfdee572d4458f88da921e17309a49224b043d022022b4dfb5090507342798f5db1caee17553e07863e5ed479c1777cdff60dcbcba012102a028293d325699e5b7ab175f5433e9e0b690ee3d2f5e8c037e22a6681e199b65fdffffff01cd980000000000001976a914857466f3af8c6221f3ae2e612949ae27e35e332d88ac7fc90d00',
      },
      {
        key: {type: PSBT_IN_BIP32_DERIVATION, data: '03159a15724b33392d0c3a536d00050889657fec4cf27c6303ce97a253171e880e'},
        value: '9c0e47922c00008000000080000000800000000000000000',
      },
    ],
  },
  outputs: {
    0 => [
      {
        key: {type: PSBT_OUT_BIP32_DERIVATION, data: '02a1ddf8e2a12bc231e0a2596d981ecfe31bbc9fecb7781f3332cffc05f1f70a7a'},
        value: '9c0e47922c00008000000080000000800100000000000000',
      },
    ],
    1 => [], # use um array vazio se um mapa de entrada/saída é esperado mas nenhum par chave-valor é necessário para ele
  },
}

# ------
# Codificação
# ------

# buffer
hex = ""

# cabeçalho
hex += "70736274ff" # magic bytes + separador

# percorre cada seção de mapa (global, input, output)
psbt.each do |mapname, maplist|

  # percorre os mapas individuais de cada seção (um para global, pode haver vários mapas de entrada e de saída)
  maplist.each do |map_index, map|

  # percorre todos os pares chave-valor de um mapa
  map.each do |keypair|

    # extrai os campos do array
    keytype = keypair[:key][:type] # inteiro (será preciso convertê-lo em um campo compact size)
    keydata = keypair[:key][:data] # bytes
    valuedata = keypair[:value] # bytes

    # codifica a chave
    keytype = compact_size(keytype)
    keydata = keydata
    keylen = compact_size((keytype.length / 2) + (keydata.length / 2)) # tamanho de keytype+keydata em bytes
    # nota: estamos trabalhando com _strings_ hex, então é preciso dividir o tamanho delas por 2 para obter o tamanho em _bytes_
    # nota: idealmente você deveria trabalhar com os dados em bytes crus em vez de strings hex

    # codifica o valor
    valuelen = compact_size(valuedata.length / 2) # tamanho de valuedata em bytes
    valuedata = valuedata

    # adiciona chave+valor ao buffer
    hex += keylen + keytype + keydata + valuelen + valuedata
  end # fim dos pares chave-valor

  # adiciona separador no fim de cada mapa
  hex += '00'

  end # fim do mapa
end

# ------
# Resultado
# ------

# mostra o array de dados original
require 'json'
puts JSON.pretty_generate(psbt) # codifica em json para imprimir o array original formatado
puts

# mostra a PSBT em hex
puts "hex:"
puts hex
puts

# mostra a PSBT em base64
require 'base64'
base64 = Base64.encode64([hex].pack('H*')) # é preciso converter a string hex em bytes crus antes de converter para base64
puts "base64:"
puts base64

A única parte complicada de decodificar PSBTs é garantir que você pegue o número correto de entradas e saídas do mapa global (via a chave PSBT_GLOBAL_UNSIGNED_TX, ou as chaves PSBT_GLOBAL_INPUT_COUNT e PSBT_GLOBAL_OUTPUT_COUNT). Isso é necessário para que você consiga determinar corretamente se os mapas seguintes são mapas de entrada ou de saída.

Certifique-se de interpretar o keytype como um campo compact size em vez de um único byte. Normalmente ele tem apenas 1 byte, mas tecnicamente é um campo compact size que pode se expandir para incluir mais tipos de chave no futuro. Então você quer levar isso em conta.

Tipos de Chave

Os tipos de dados em cada mapa

Cada mapa dentro de uma PSBT usa uma variedade de tipos de chave para armazenar dados.

Esses tipos de chave são representados por inteiros e indicam o tipo de dado armazenado nos campos de dados da chave e de dados do valor de cada par chave-valor.

Abaixo está uma lista de todos os diferentes tipos de chave disponíveis para cada mapa, junto com descrições dos dados armazenados.

As chaves dentro de cada mapa não precisam estar em ordem numérica. Porém, é útil colocá-las em ordem numérica, se possível, para ajudar a comparar a estrutura das PSBTs conforme elas são atualizadas durante o uso.

Os inteiros dos tipos de chave são específicos de cada tipo de mapa. Mapas diferentes podem usar os mesmos inteiros, mas eles representam tipos de chave diferentes dependendo do mapa em que você está. Portanto, você não consegue determinar o tipo de chave exato apenas pelo inteiro — você também precisa saber em qual mapa está usando-o.

As descrições abaixo são retiradas diretamente do BIP 174.

Mapa Global (11)

Mapa de Entrada (31)

Mapa de Saída (13)

Uso

Como você usa as PSBTs?

Uma PSBT é processada por meio de vários passos antes de ser convertida na transação final assinada.

Você pensaria que seria apenas um processo de 2 passos, assim:

1. Criar — Criar a PSBT e adicionar todos os dados extras necessários para a assinatura.
2. Assinar — Assinar as entradas usando os dados extras e retornar a transação assinada.

Porém, esses dois passos podem ser desmembrados em passos adicionais (ou "papéis"), em que cada papel tem uma função específica para atualizar o estado da PSBT:

1. Criador (Creator) — Criar a PSBT inicial com os dados da transação não assinada.
   • Construtor (Constructor) — Um papel adicional para PSBTs v2, usado para adicionar entradas e saídas aos dados da transação não assinada.
2. Atualizador (Updater) — Adicionar os dados extras necessários para assinar as entradas.
3. Assinante (Signer) — Assinar as entradas usando os dados extras e adicionar as assinaturas brutas à PSBT.
4. Finalizador de Entradas (Input Finalizer) — Usar as assinaturas brutas para construir o código de destravamento completo das entradas.
5. Extrator de Transação (Transaction Extractor) — Converter a PSBT nos dados brutos da transação assinada, pronta para ser transmitida à rede.

Há também um útil papel de Combinador (Combiner), que pode ser usado em qualquer passo intermediário:

• Combinador (Combiner) — Combinar múltiplas PSBTs em uma só.

Os passos acima não precisam ser executados em uma única sequência. Por exemplo, você poderia Atualizar/Assinar/Finalizar uma entrada de uma PSBT, e então enviá-la a outra pessoa, que pode voltar e Atualizar/Assinar/Finalizar outra entrada.

Na maioria das vezes, uma única carteira/entidade desempenha vários papéis de uma vez. Por exemplo, ao usar um dispositivo de hardware para assinar uma PSBT v0, a carteira watch-only será o Criador/Atualizador, e o dispositivo de hardware será o Assinante/Finalizador de Entradas/Extrator de Transação (o papel de Combinador não é necessário).

Mesmo assim, cada papel individual é especializado, e esses papéis permitem dividir o trabalho entre múltiplas carteiras/entidades para máxima flexibilidade ao processar PSBTs.

Abaixo está uma lista dos papéis para PSBTs da versão 0 e da versão 2. Há pequenas variações, mas o processo geral é, em linhas gerais, o mesmo.

Versão 0

1. Criador

Um Criador cria uma nova PSBT.

Ele constrói os dados iniciais da transação não assinada e os armazena na seguinte chave:

• PSBT_GLOBAL_UNSIGNED_TX

Esses dados da transação não assinada devem ser uma transação serializada com os campos de ScriptSig e Testemunha vazios.

• Os mapas de entrada e de saída precisam estar vazios.
• O PSBT_GLOBAL_VERSION pode opcionalmente ser definido como 0. Porém, ele é 0 por padrão se não incluído.

2. Atualizador

Um Atualizador adiciona os dados extras necessários para criar as assinaturas dos dados da transação não assinada.

Isso quase sempre envolve incluir os dados necessários da(s) transação(ões) anterior(es) para cada entrada, por meio das seguintes chaves:

• PSBT_IN_NON_WITNESS_UTXO
• PSBT_IN_WITNESS_UTXO

Opcionalmente, o Atualizador também pode especificar um tipo de SIGHASH para cada entrada:

• PSBT_IN_SIGHASH_TYPE

Se uma entrada é um P2SH ou P2WSH, ela também deve incluir o script personalizado que foi usado (ou seja, o Redeem Script para um P2SH, ou o Witness Script para um P2WSH) para criar o Hash do Script colocado no ScriptPubKey da saída.

• PSBT_IN_REDEEM_SCRIPT
• PSBT_IN_WITNESS_SCRIPT

Esses scripts personalizados originais são necessários para conseguir destravar entradas P2SH e P2WSH. Eles devem ter sido armazenados pela carteira que criou o endereço para receber pagamentos.

Por fim, um Atualizador também pode adicionar informações úteis sobre as chaves públicas (e caminhos de derivação) usadas nas entradas e saídas.

• PSBT_IN_BIP32_DERIVATION
• PSBT_OUT_BIP32_DERIVATION

As chaves acima ajudam as carteiras a identificar quais entradas elas podem assinar, bem como quais saídas são usadas para troco. Uma carteira pode identificar ambas as coisas sem essas chaves, mas incluí-las ajuda a carteira a identificá-las mais rápido.

Carteiras de hardware podem depender dessas chaves para identificar as entradas que podem assinar, já que podem não ter o poder de processamento para fazê-lo sem elas.

Em resumo, um Atualizador deve adicionar à PSBT quaisquer dados extras a que tenha acesso. O objetivo principal de um Atualizador é adicionar todos os dados relevantes aos mapas de entrada, para que um Assinante tenha tudo o que precisa para assinar as entradas.

Uma PSBT pode ser passada entre múltiplos Atualizadores para obter todos os dados extras necessários para a assinatura (ex.: se um único Atualizador não tem acesso a todas as informações exigidas).

3. Assinante

Um Assinante usa os dados já fornecidos na PSBT para criar assinaturas para as entradas.

A assinatura resultante é colocada na seguinte chave de cada mapa de entrada:

• PSBT_IN_PARTIAL_SIG

Se uma entrada exige múltiplas assinaturas (ex.: um script de travamento estilo P2MS), os mapas de entrada acabarão com múltiplas chaves PSBT_IN_PARTIAL_SIG.

O campo de dados da chave PSBT_IN_PARTIAL_SIG contém a chave pública correspondente à assinatura. Isso evita chaves duplicadas se houver múltiplas assinaturas em um único mapa de entrada.

Os Assinantes devem assinar quantas entradas da PSBT puderem, supondo que tenham as chaves privadas para assiná-las.

Uma PSBT pode ser passada entre múltiplos Assinantes se múltiplas assinaturas forem necessárias de pessoas diferentes, com cada um adicionando chaves PSBT_IN_PARTIAL_SIG às entradas conforme avançam.

• Um Assinante deve verificar a transação para se certificar de que concorda com ela antes de adicionar a sua assinatura.
• Um Assinante pode usar as chaves PSBT_IN_BIP32_DERIVATION para detectar quais entradas assinar, e as chaves PSBT_OUT_BIP32_DERIVATION para ajudar a detectar as saídas de troco.
• Detectar saídas de troco pode ser útil ao exibir os detalhes da transação para o usuário da carteira antes da assinatura.

Verificações

Um Assinante deve realizar verificações antes de assinar uma entrada.

Essas verificações dependem dos dados fornecidos no mapa de entrada:

• PSBT_IN_NON_WITNESS_UTXO — O TXID dos dados fornecidos (transação anterior) precisa corresponder ao TXID especificado no prevout da transação não assinada.
• PSBT_IN_WITNESS_UTXO — Nenhuma assinatura não-testemunha pode ser criada se esta chave for fornecida.
• PSBT_IN_REDEEM_SCRIPT — O ScriptPubKey precisa ser para aquele Redeem Script (ou seja, corresponder ao hash na UTXO).
• PSBT_IN_WITNESS_SCRIPT — O ScriptPubKey ou o Redeem Script precisa ser para aquele Witness Script (ou seja, corresponder ao hash na UTXO ou no Redeem Script).
• PSBT_IN_SIGHASH_TYPE
  • Se fornecido, o assinante precisa verificar que o sighash é aceitável. Se inaceitável, precisa falhar.
  • Se não fornecido, o assinante deve assinar usando SIGHASH_ALL, mas pode usar qualquer tipo de sighash que desejar.

4. Finalizador de Entradas

Um Finalizador de Entradas pega as assinaturas das chaves PSBT_IN_PARTIAL_SIG (adicionadas pelo(s) Assinante(s)) e as usa para construir o código de destravamento completo de cada entrada.

Os scripts de destravamento resultantes são colocados em uma das seguintes chaves:

• PSBT_IN_FINAL_SCRIPTSIG
• PSBT_IN_FINAL_SCRIPTWITNESS

A chave que você usa depende de se a entrada é destravada pelo campo ScriptSig (ex.: P2PK, P2PKH, P2SH) ou pelo campo de Testemunha (ex.: P2WPKH, P2WSH, P2TR).

Todas as outras chaves (exceto PSBT_IN_NON_WITNESS_UTXO e PSBT_IN_WITNESS_UTXO) devem ser apagadas do mapa de entrada após o código de destravamento ser adicionado. As chaves de UTXO são mantidas para que o Extrator de Transação possa verificar que a transação final está correta.

Se um Finalizador de Entradas ainda não tem dados suficientes para criar o código que destrava uma entrada (ex.: assinaturas insuficientes para destravar um multisig), o mapa de entrada não deve ser atualizado.

5. Extrator de Transação

Um Extrator de Transação converte a PSBT na transação final assinada.

Ele pega os dados das chaves PSBT_IN_FINAL_SCRIPTSIG e PSBT_IN_FINAL_SCRIPTWITNESS de cada entrada e os insere nos dados brutos da transação não assinada em PSBT_GLOBAL_UNSIGNED_TX.

O resultado é uma transação serializada pronta para ser transmitida à rede.

Todo mapa de entrada precisa ter um PSBT_IN_FINAL_SCRIPTSIG ou PSBT_IN_FINAL_SCRIPTWITNESS para conseguir construir a transação final assinada.

Combinador

Um Combinador mescla múltiplas PSBTs em uma única PSBT.

A PSBT resultante precisa conter todos os pares chave-valor de cada uma das PSBTs individuais. Quaisquer duplicatas precisam ser removidas.

Se houver pares chave-valor com a mesma chave mas valores diferentes, o Combinador pode escolher qual par chave-valor manter. Porém, o Combinador pode se recusar a combinar as PSBTs se for provável que haja inconsistências ou conflitos na PSBT resultante.

PSBTs só devem ser combinadas se forem para a mesma transação não assinada. O identificador único de uma PSBT v0 são os dados da transação não assinada em PSBT_GLOBAL_UNSIGNED_TX.

Versão 2

Uma PSBT v2 divide os dados da transação não assinada e os armazena em chaves separadas pelos três mapas.

Essa mudança de design facilita adicionar e remover entradas da PSBT antes da assinatura.

Para acomodar essa mudança, um novo papel foi adicionado (Construtor), e alguns dos papéis existentes foram levemente modificados. Mas não há uma diferença enorme no geral, e o processo geral para trabalhar com PSBTs permanece o mesmo.

1. Criador

Um Criador v2 cria uma nova PSBT.

Porém, na v2, o Criador ainda não inclui os dados da transação não assinada. Em vez disso, ele simplesmente adiciona as configurações básicas da PSBT no mapa global.

Primeiro, o número de versão da PSBT precisa ser definido como 2 para indicar que você está usando a PSBT v2:

• PSBT_GLOBAL_VERSION

Em seguida, defina o número de versão da transação e defina um valor opcional de fallback para o locktime da transação:

• PSBT_GLOBAL_TX_VERSION
• PSBT_GLOBAL_FALLBACK_LOCKTIME

Por fim, o campo modificável deve ser definido para permitir que entradas e saídas sejam adicionadas à PSBT:

• PSBT_GLOBAL_TX_MODIFIABLE

Porém, este último campo pode ser omitido se o Criador também for um Construtor.

2. Construtor

Um Construtor v2 adiciona as entradas e saídas a serem incluídas nos dados da transação não assinada.

Para cada nova entrada, as seguintes chaves precisam ser adicionadas ao mapa da entrada:

• PSBT_IN_PREVIOUS_TXID
• PSBT_IN_OUTPUT_INDEX

Essas chaves permitem referenciar as saídas que você quer usar como entradas da transação.

Além disso, cada entrada pode especificar um locktime (se necessário):

• PSBT_IN_REQUIRED_TIME_LOCKTIME
• PSBT_IN_REQUIRED_HEIGHT_LOCKTIME

Você pode adicionar uma, ambas ou nenhuma.

Se você está adicionando uma entrada com apenas um desses tipos de chave de locktime, precisa verificar que ela não entra em conflito com os tipos de chave de locktime dos outros mapas de entrada. Por exemplo, se uma entrada já tem apenas PSBT_IN_REQUIRED_TIME_LOCKTIME, você não pode adicionar uma entrada com apenas PSBT_IN_REQUIRED_HEIGHT_LOCKTIME (e vice-versa).

Além disso, se a PSBT já foi assinada, você não pode adicionar uma entrada que especifique um locktime que mude o valor final de locktime da transação inteira. Veja a seção Cálculo do Locktime no papel Extrator de Transação para detalhes.

Para cada nova saída, as seguintes chaves precisam ser adicionadas ao mapa da saída:

• PSBT_OUT_AMOUNT
• PSBT_OUT_SCRIPT

Depois de adicionar uma nova entrada ou saída à PSBT, os campos de contagem no mapa global precisam ser incrementados:

• PSBT_GLOBAL_INPUT_COUNT
• PSBT_GLOBAL_OUTPUT_COUNT

Por fim, se nenhuma outra entrada ou saída deve ser adicionada à transação, isso deve ser declarado atualizando ou removendo a chave modificável no mapa global:

• PSBT_GLOBAL_TX_MODIFIABLE

Se a chave PSBT_GLOBAL_TX_MODIFIABLE tem a flag Has SIGHASH_SINGLE (bit 2) definida como Verdadeiro, você precisa iterar pelas entradas e encontrar as que têm assinaturas que usam SIGHASH_SINGLE. O mesmo número de entradas e saídas precisa ser adicionado antes dessas entradas e das suas saídas correspondentes.

3. Atualizador

Um Atualizador v2 funciona da mesma forma que um Atualizador v0.

Porém, ele também pode definir o número de sequence de cada entrada:

• PSBT_IN_SEQUENCE

Se esta chave não for definida, o número de sequence assume o padrão de 0xFFFFFFFF.

4. Assinante

Um Assinante v2 é o mesmo que um Assinante v0.

Porém, após assinar uma entrada, um Assinante v2 deve atualizar a chave modificável para refletir o estado da PSBT:

• PSBT_GLOBAL_TX_MODIFIABLE

Este campo precisa ser atualizado com base no tipo de SIGHASH que o Assinante adicionou à entrada:

• Se a assinatura não usa SIGHASH_ANYONECANPAY, a flag de Entradas Modificáveis (bit 0) precisa ser definida como Falso.
• Se a assinatura não usa SIGHASH_NONE, a flag de Saídas Modificáveis (bit 1) precisa ser definida como Falso.
• Se a assinatura usa SIGHASH_SINGLE, a flag Has SIGHASH_SINGLE (bit 2) precisa ser definida como Verdadeiro.

5. Finalizador de Entradas

Um Finalizador de Entradas v2 funciona da mesma forma que um Finalizador de Entradas v0.

Porém, após adicionar o PSBT_IN_FINAL_SCRIPTSIG ou PSBT_IN_FINAL_SCRIPTWITNESS relevante, as seguintes chaves v2 não devem ser removidas dos mapas de entrada (se presentes):

• PSBT_IN_PREVIOUS_TXID
• PSBT_IN_OUTPUT_INDEX
• PSBT_IN_SEQUENCE
• PSBT_IN_REQUIRED_TIME_LOCKTIME
• PSBT_IN_REQUIRED_HEIGHT_LOCKTIME

Essas chaves são necessárias para o Extrator de Transação construir a transação final assinada.

6. Extrator de Transação

Um Extrator de Transação v2 converte a PSBT em uma transação assinada bruta que pode ser transmitida à rede.

Porém, na v2 este passo é um pouco mais elaborado, pois você primeiro precisa construir os dados da transação não assinada a partir das chaves individuais adicionadas à PSBT pelo Criador v2 e pelo Construtor v2.

Você também precisará calcular o campo de locktime da transação olhando as chaves de locktime relevantes no mapa global e no(s) mapa(s) de entrada.

Por fim, os campos PSBT_IN_FINAL_SCRIPTSIG e PSBT_IN_FINAL_SCRIPTWITNESS (adicionados pelo Finalizador de Entradas) são mesclados aos dados da transação não assinada para formar a transação final assinada.

Na v0, os dados completos da transação não assinada já estão preparados no PSBT_GLOBAL_UNSIGNED_TX. Na v2, os dados da transação não assinada precisam ser construídos a partir dos dados armazenados nas chaves individuais pelo mapa global, mapa(s) de entrada e mapa(s) de saída.

Cálculo do Locktime

Para calcular o campo de locktime da transação, você precisa percorrer cada mapa de entrada para verificar os valores individuais de locktime que possam ter sido definidos para cada entrada.

O algoritmo básico é o seguinte:

1. Se uma ou mais entradas têm um valor de locktime especificado, use o valor de locktime mais alto presente entre as entradas.*
2. Se nenhuma entrada tem um valor de locktime especificado, use o valor de fallback no mapa global (PSBT_GLOBAL_FALLBACK_LOCKTIME).
3. Se um locktime de fallback não estiver definido, use o valor de locktime padrão de 0 (ou seja, sem locktime).

*Para cada entrada, há na verdade dois tipos de chave de locktime diferentes que podem ser especificados:

1. PSBT_IN_REQUIRED_TIME_LOCKTIME — Especifica o locktime desejado da transação em segundos (Unix Time).
2. PSBT_IN_REQUIRED_HEIGHT_LOCKTIME — Especifica o locktime desejado da transação como uma altura de bloco.

Para determinar qual tipo de locktime usar, você precisa verificar quais tipos são suportados por todas as entradas:

• Se um mapa de entrada especifica ambos os tipos (incluindo ambas as chaves), então ambos os tipos permanecem suportados para a transação.
• Se um mapa de entrada não especifica nenhum dos tipos (não incluindo nenhuma das chaves), então ambos os tipos permanecem suportados para a transação.
• Se um mapa de entrada especifica apenas um tipo, então apenas esse tipo é suportado para a transação.

Se ambos os tipos são suportados por todas as entradas (ou seja, você tem escolha entre os dois), você precisa usar o PSBT_IN_REQUIRED_HEIGHT_LOCKTIME de valor mais alto. Isso porque ele tem precedência sobre o PSBT_IN_REQUIRED_TIME_LOCKTIME (mesmo que este tenha um valor mais alto no geral).

Porém, se há um conflito em que um ou mais mapas de entrada suportam apenas um tipo de locktime, e um ou mais entradas suportam apenas o outro tipo de locktime, o campo de locktime da transação não pode ser calculado.

Idealmente, um Construtor não adicionará uma entrada com uma chave de locktime conflitante. Mas um Extrator de Transação ainda precisa verificar conflitos ao determinar o valor final do campo de locktime da transação.

Combinador

Um Combinador v2 funciona da mesma forma que um Combinador v0.

Formato

Qual formato de dados as PSBTs usam?

Há dois formatos "oficiais" para PSBTs:

1. Binário (Arquivo) — Usado para passar uma PSBT adiante como um arquivo (usando a extensão .psbt).
2. Base64 (Texto) — Usado para copiar/colar, ou armazenar uma PSBT como texto.

Então, se você exportar uma PSBT de uma carteira, deverá obter ou um arquivo binário ou uma string base64. Qualquer um serve, e ambos representam os mesmos dados subjacentes, então você pode converter diretamente entre os dois formatos:

# converte arquivo binário em string base64
base64 -w0 file.psbt
# nota: -w0 evita quebras de linha, que podem causar problemas na decodificação

# converte string base64 em arquivo binário
echo "base64psbtgoeshere" | base64 -d > file.psbt

Mas, às vezes, é mais fácil inspecionar PSBTs em formato hex, então pode ser útil converter uma PSBT de binário/base64 para formato hex, se necessário:

# converte arquivo binário em string hex (sem formatação)
xxd -p file.psbt | tr -d '\n' && echo ''

# converte string base64 em string hex (sem formatação)
echo "base64psbtgoeshere" | base64 -d | xxd -p | tr -d '\n' && echo ''

Formato Hex. Exibi os dados das PSBTs em formato hex ao longo desta página, pois geralmente é mais fácil de usar ao testar/depurar. Mas tecnicamente não é um formato no qual as PSBTs devam ser passadas adiante, e a maioria das carteiras não suporta exportar/importar uma PSBT em formato hex.

História

Quando as PSBTs foram introduzidas?

A ideia original de ter um formato padrão para exportar transações não assinadas foi proposta por Pieter Wuille (que também criou o nome "Partially Signed Bitcoin Transactions"). O formato PSBT em si foi então projetado e implementado por Ava Chow.

A primeira versão (PSBTv0) foi introduzida em 2017:

• 17 de julho de 2017 — BIP 174 publicado
• 03 de outubro de 2018 — Suporte ao PSBTv0 adicionado ao Bitcoin Core v0.17.0

A segunda versão (PSBTv2) foi introduzida em 2021:

• 28 de janeiro de 2021 — BIP 370 publicado
• 23 de fevereiro de 2021 — Pull request submetido para adicionar suporte ao PSBTv2 no Bitcoin Core

Essa segunda versão usa a mesma estrutura de dados de PSBT de antes, mas introduz novos tipos de chave e modifica alguns papéis para permitir que entradas e saídas sejam adicionadas aos dados da transação não assinada antes da assinatura. Então é basicamente uma versão um pouco mais flexível em comparação com a PSBTv0.

O Bitcoin Core ainda não oferece funcionalidade para suportar a PSBTv2, mas ela atualmente é suportada por outras carteiras de terceiros, como a Sparrow Wallet e a Coldcard.

Não existe PSBTv1. A primeira versão foi chamada de v0 e, como ela era comumente referida como a "primeira versão", a segunda versão foi chamada de v2 em vez de v1 para ajudar a evitar confusão (exceto, claro, pela confusão sobre por que não há uma "v1").

Resumo

Em poucas palavras

Uma PSBT é apenas uma transação que inclui todos os dados extras necessários para assiná-la.

A maioria das carteiras modernas entende o formato PSBT, então, se você está criando um software que pode exportar/importar transações não assinadas, vai querer pegar o jeito de lidar com PSBTs.

Elas podem parecer intimidadoras no início, por causa de todos os tipos de chave disponíveis, mas você não precisa entender todos eles para tirar proveito das PSBTs — você só precisa dos que são relevantes para as necessidades do seu software. O resto está lá apenas para o caso de você precisar.

Então, se você está começando com PSBTs, comece descobrindo como decodificá-las e codificá-las. A partir daí, você pode simplesmente usar as chaves de que precisa para assinar os tipos de entrada específicos que a sua carteira precisa lidar.

A maioria das carteiras só implementa a funcionalidade para lidar com um subconjunto de todos os tipos de chave possíveis. Por exemplo, para processar uma PSBT v0 para assinar um tipo de entrada simples como P2PKH, você só precisa trabalhar com os seguintes tipos de chave:

• PSBT_GLOBAL_UNSIGNED_TX
• PSBT_IN_NON_WITNESS_UTXO
• PSBT_IN_PARTIAL_SIG
• PSBT_IN_FINAL_SCRIPTSIG
• PSBT_IN_BIP32_DERIVATION (opcional, mas útil)
• PSBT_OUT_BIP32_DERIVATION (opcional, mas útil)

Então, como sempre, comece pela funcionalidade básica e siga a partir daí. Você pode descobrir como usar os outros tipos de chave conforme avança.

Divirta-se.

Recursos

• A. Chow: Partially Signed Bitcoin Transactions
• PSBT Decoder
• PSBT Howto for Bitcoin Core
• Bitcoin Dev Mailing List Discussion: BIP 174 thoughts
• Bitcoin Optech — Partially signed bitcoin transactions

Agradecimentos

• Obrigado ao Craig Raw (criador da Sparrow Wallet) por explicar os benefícios de incluir as chaves BIP32_DERIVATION em uma PSBT.