Bitcoin address: bc1pr7gwz35z9yf4ym8s040d2juxghp5ugz3xegvtl9zj4wzw685vpks9y9zdu

SHOWING: First 60

#54,130,130html

#54,120,307html transfer48.jble#53,464,898brc-20 mint48.jble#53,439,927brc-20

"⚠️⚠️ Be very careful sending your inscription particularly if the `offset` value is not `0`. It is not recommended to use this method if that is the case, as "
"doing so you could accidentally send your inscription to a bitcoin miner unless you know what you are doing."
msgstr ""
"⚠️⚠️ Будьте очень осторожны при отправке надписи, особенно если значение `offset` не равно `0`. Не рекомендуется использовать этот метод, так как в этом случае "
"вы можете случайно отправить надпись майнеру биткоинов, если вы не знаете, что делаете."

#: src/guides/collecting/sparrow-wallet.md:133
msgid "Sending your inscription"
msgstr "Отправка вашей надписи"

#: src/guides/collecting/sparrow-wallet.md:134
msgid "To send an inscription navigate to the `UTXOs` tab, and find the UTXO which you previously validated contains your inscription."
msgstr "Для отправки надписи перейдите на вкладку `UTXOs` и найдите UTXO, который, как вы ранее подтвердили, содержит вашу надпись."

#: src/guides/collecting/sparrow-wallet.md:136
msgid "If you previously froze the UXTO you will need to right-click on it and unfreeze it."

#44,983,044text

          break;
        }
      }
    });

    Ok(rx)
  }

  fn get_block_with_retries(
    client: &Client,
    height: u32,
    index_sats: bool,
    first_inscription_height: u32,
  ) -> Result<Option<Block>> {
    let mut errors = 0;
    loop {
      match client
        .get_block_hash(height.into())
        .into_option()
        .and_then(|option| {
          option
            .map(|hash| {
              if index_sats || height >= first_inscription_height {
                Ok(client.get_block(&hash)?)
              } else {
                Ok(Block {
                  header: client.get_block_header(&hash)?,
                  txdata: Vec::new(),
                })
              }
            })
            .transpose()
        }) {
        Err(err) => {
          if cfg!(test) {
            return Err(err);
          }

          errors += 1;
          let seconds = 1 << errors;
          log::warn!("failed to fetch block {height}, retrying in {seconds}s: {err}");

          if seconds > 120 {
            log::error!("would sleep for more than 120s, giving up");

#44,981,178text

        ..Default::default()
      }
      .pointer(),
      Some(0x0807060504030201),
    );
    assert_eq!(
      Inscription {
        pointer: Some(vec![1, 2, 3, 4, 5, 6, 7, 8, 0, 0, 0, 0, 1]),
        ..Default::default()
      }
      .pointer(),
      None,
    );
    assert_eq!(
      Inscription {
        pointer: Some(vec![1, 2, 3, 4, 5, 6, 7, 8, 1]),
        ..Default::default()
      }
      .pointer(),
      None,
    );
  }

  #[test]
  fn pointer_encode() {
    assert_eq!(
      Inscription {
        pointer: None,
        ..Default::default()
      }
      .to_witness(),
      envelope(&[b"ord"]),
    );

    assert_eq!(
      Inscription {
        pointer: Some(vec![1, 2, 3]),
        ..Default::default()
      }
      .to_witness(),
      envelope(&[b"ord", &[2], &[1, 2, 3]]),
    );
  }

  #[test]
  fn pointer_value() {
    let mut file = tempfile::Builder::new().suffix(".txt").tempfile().unwrap();

    write!(file, "foo").unwrap();

    let inscription =
      Inscription::from_file(Chain::Mainnet, file.path(), None, None, None, None, false).unwrap();

#44,981,177text

              if end == Some(self.height) {
                0
              } else {
                limit
              }
            } else {
              u128::max_value()
            } - balance,
            end,
            symbol,
            limit,
            timestamp: self.timestamp,
          }
          .store(),
        )?;

        let inscription_id = InscriptionId { txid, index: 0 };

        if let Some(sequence_number) = self
          .inscription_id_to_sequence_number
          .get(&inscription_id.store())?
        {
          self
            .sequence_number_to_rune
            .insert(sequence_number.value(), rune.0)?;
        }
      }
    }

    let mut burned: HashMap<u128, u128> = HashMap::new();

    if burn {
      for (id, balance) in unallocated {
        *burned.entry(id).or_default() += balance;
      }
    } else {
      // Assign all un-allocated runes to the first non OP_RETURN output
      if let Some((vout, _)) = tx
        .output
        .iter()
        .enumerate()
        .find(|(_, tx_out)| !tx_out.script_pubkey.is_op_return())

#44,981,176text