Hardening government bond yields, especially on U.S. treasury notes, have traditionally been viewed as a headwind for bitcoin (BTC) and other risk assets.

However, recent persistent resilience in treasury yields suggests a different story — one driven by factors that could be bullish for bitcoin, according to analysts.

The U.S. data released Tuesday showed the consumer price index (CPI) rose 0.2% month-on-month for both headline and core in April, below the 0.3% readings expected. That resulted in a headline year-on-year inflation reading of 2.3%, the lowest since February 2021.

Still, prices for the 10-year treasury yield, which is influenced by inflation, dropped, pushing the yield higher to 4.5%, the highest since April 11, according to data source TradingView.

The so-called benchmark yield is up 30 basis points in May alone and the 30-year yield has increased to 4.94%, sitting near the highest levels of the last 18 years.

This has been the theme of late: Yields remain elevated despite all the news about tariff pause, the U.S.-China trade deal and slower inflation. (The 10-year yield surged from 3.8% to 4.6% early last month as trade tensions saw investors sell U.S. assets)

The uptick in the so-called risk-free rate usually sparks fears of rotation of money out of stocks and other riskier investments such as crypto and into bonds.

The latest yield surge, however, stems from expectations for continued fiscal expansion during President Donald Trump’s tenure, according to Spencer Hakimian, founder of Tolou Capital Management.

“Bonds down on a weak CPI day is telling [of] fiscal expansion like crazy,” Hakimian said on X. “Everyone plays to win the midterm. Debt and deficits be damned. It’s great for Bitcoin, Gold, and Stocks. It’s terrible for Bonds.”

Hakimian explained that Trump’s tax plan would immediately add another $2.5 trillion to the fiscal deficit. In other words, the fiscal policy under Trump will likely be just as expansionary as under Biden, acting as a tailwind for risk assets, including bitcoin.

The details of the tax cut plan reported by Bloomberg early this week proposed $4 trillion in tax cuts and about $1.5 trillion in spending cuts, amounting to a fiscal expansion of $2.5 trillion.

Arif Husain, head of global fixed income and chief investment officer of the fixed income division at T. Rowe Price, noted that fiscal expansion will soon become the overriding focus for markets.

“Fiscal expansion may be growth supportive, but most importantly, it would likely put even more pressure on the treasury market. I am now even more convinced that the 10‑year U.S. treasury yield will reach 6% in the next 12–18 months,” Husain said in a blog post.

Sovereign risk

Per Pseudonymous observer EndGame Macro, the persistent elevated Treasury yields represent fiscal dominance, an idea first discussed by economist Russel Napier a couple of years ago and Maelstrom’s CIO and co-founder, Arthur Hayes, last year, and repricing of U.S. sovereign risk.

“When the bond market demands higher yields even as inflation falls, it’s not about the inflation cycle it’s about the sustainability of U.S. debt issuance itself,” EndGame Macro said on X.

The observer explained that higher yields create a self-reinforcing spiral of higher debt servicing costs, which call for more debt issuance (more bond supply) and even higher rates. All this ends up raising the risk of a sovereign debt crisis.

BTC, widely seen as an anti-establishment asset and an alternative investment vehicle, could gain more value in this scenario.

Moreover, as yields rise, the Fed and the U.S. government could implement yield curve control, or active buying of bonds to cap the 10-year yield from rising beyond a certain level, let’s assume 5%.

The Fed, therefore, is committed to buy more bonds every time the yield threatens to rise beyond 5%, which inadvertently boosts liquidity in the financial system, galvanizing demand for assets like bitcoin, gold and stocks.

I’m writing a Python program to reproduce wallet addresses from mnemonics, which sounds simple, but I can’t get an old Electrum (Pre-V2) address that matches the address I get from the official GUI wallet.

All the information is useful as it seems that you can’t find too much information about Electrum address generation before V2.

Does anyone have insight into what I’m doing wrong?

import hashlib, ecdsa, base58

def load_wordlist(filename):
    with open(filename, 'r') as f:
        return (word.strip() for word in f.readlines())

# Decoding mnemonic into Electrum v1 seed (entropy)
def mnemonic_to_entropy(mnemonic, wordlist):
    words = mnemonic.split()
    entropy_bits=""
    for word in words:
        index = wordlist.index(word)
        entropy_bits += bin(index)(2:).zfill(11)

    # Pading entropy_bits with zeros to make it byte-aligned
    extra_bits = len(entropy_bits) % 8
    if extra_bits != 0:
        entropy_bits = entropy_bits.ljust(len(entropy_bits) + (8 - extra_bits), '0')

    entropy_hex = hex(int(entropy_bits, 2))(2:).zfill(len(entropy_bits) // 4)
    return bytes.fromhex(entropy_hex)

# Generating private key from entropy + index
def electrum_v1_privkey(entropy, index):
    data = entropy + index.to_bytes(4, 'little')
    return hashlib.sha256(data).digest()

# Converting private key to compressed public key
def privkey_to_pubkey(privkey):
    sk = ecdsa.SigningKey.from_string(privkey, curve=ecdsa.SECP256k1)
    vk = sk.verifying_key
    prefix = b'\x02' if vk.to_string()(-1) % 2 == 0 else b'\x03'
    return prefix + vk.to_string()(:32)

# Converting public key to address
def pubkey_to_address(pubkey):
    sha256_pubkey = hashlib.sha256(pubkey).digest()
    ripemd160_pubkey = hashlib.new('ripemd160', sha256_pubkey).digest()
    prefixed_pubkey = b'\x00' + ripemd160_pubkey
    checksum = hashlib.sha256(hashlib.sha256(prefixed_pubkey).digest()).digest()(:4)
    return base58.b58encode(prefixed_pubkey + checksum).decode()

mnemonic = "sample mnemonic"
wordlist = load_wordlist('old_electrum_wordlist')

entropy = mnemonic_to_entropy(mnemonic, wordlist)

# Generating first 5 addresses
for index in range(5):
    privkey = electrum_v1_privkey(entropy, index)
    pubkey = privkey_to_pubkey(privkey)
    address = pubkey_to_address(pubkey)
    print(f'Address {index}: {address}')

Crypto analyst Joao predicted it correctly XRP Price crashrevealed Altcoin’s next target. Based on his latest predictions, there could be more pain beyond XRP, but this could still be under $1.

What’s next for XRP price after crashing under $2?

in TradingView PostJoao said the long-term distribution stage of XRP prices after a crash of less than $2 could be “the most confusing scenario.” Through his accompanying charts, the analyst said,Radical Distribution Scheme“It could potentially extend into the second half of 2025.

Related readings

Joao said the XRP price could first show signs of weaknesses. Covid dump level or belowprobably close to $0.10. As that happens, XRP can follow the trajectory of Scheme 1 or 2. For Scheme 1, analysts predict that XRP will drop to $0.1 and then return to $0.4. This is the last supply point.

On the other hand, if Scheme 2 is played, he predicts XRP prices could skyrocket between $5 and $6.8, with an average peak of around $5.5 to $5.7. Joao warned that this is one of the “inexplicable” possibilities and that XRP’s price action will depend heavily on Bitcoin, market makers, supply and demand, public interest, and macro markets.

Crypto analyst John also warned about it recently XRP Price Retracement Altcoin’s price level will be $0.3827, which could deepen in mid-2024. Analysts believe Altcoin can fall to these lows as they highlighted the bearish siege formed on XRP’s weekly charts in late March.

meanwhile, Crypto Analyst Egrag Crypto Based on the ascending spreading wedge, it states that the chances of a downside breakout are 70% and a 30% chance. He claimed that the measured movement of the XRP price downside breakout was $0.65.

$1.90 has become Altcoin’s resistance

x post, Crypto Analyst Castrades It revealed that $1.90 is a major resistance to XRP prices. She noted that the price of the altcoin fell to around $1.61 after the Black Monday crash on April 7th. This low is said to have created a new extreme with RSI across the market, which was shy with great support.

Related readings

The XRP price has since recovered to test the $1.90 level. This is the main resistance that Casitrades, as declared at this point. She said the next support was $1.55, a golden .618 retracement. Analysts added that this price measure sets exactly that wave 3. The best ever (As).

In line with this, Casitrades argued that if the XRP price is close to $1.55, it would actually bolster bullish lawsuits for a rally between $8 and $13 this month. She believes that XRP can easily destroy the resistance around this Wave 3 ATH, and perhaps send it to $13.

At the time of writing, XRP prices are trading at around $1.8, an increase of over 10% over the past 24 hours. data From CoinMarketCap.

Medium featured images, charts on tradingView.com

A new XRP price forecast has emerged, offering insights into the cryptocurrency’s next bearish move. A crypto analyst who previously predicted XRP‘s crash below $2 has provided a more comprehensive outlook, outlining key support and resistance areas that will determine XRP’s next target. 

According to TradingView crypto analyst, ‘MMBTrader,’ the XRP price is set to dump below the $2 threshold. As of writing, CoinMarketCap reports that XRP is trading at $2.2, reflecting a modest 3% increase in value in the last 24 hours. 

XRP Price Projected To Crash To $1.5

Related Reading

The TradingView crypto expert has identified a Head and Shoulder pattern on the XRP daily chart, consisting of three peaks: left shoulder, head, and right shoulder. Typically, a classic Head and Shoulder pattern is considered one of the most common indicators of a potential price breakdown, with the price of a cryptocurrency expected to reverse from bullish to bearish. 

Looking at the price chart, a break below the pattern’s neckline around the $1.95 price point would confirm XRP’s bearish position. If the cryptocurrency fails to hold the $1.95 support level, a sharp drop, possibly up to 50%, is expected. This massive crash would effectively place the price around the $1.5 level or even as low as $1.2.

While he expects a possible crash to $1.5, MMBTrader also projects an alternative bullish scenario in which the XRP price initiates a strong rebound. The analyst revealed that if the cryptocurrency consolidates near $2 without breaking lower, then a bounce to new highs could follow.

Additionally, the TradingView expert believes that the asset could also experience a significant rally toward $5 after its projected 50% price crash. He highlights that if XRP can hold the support level near $1.5, then a strong reversal could occur, potentially triggering a bullish move between $4 and $4.5.

Whales Scoop Up $385 Million Amid Market Downtrend

While XRP experiences slow momentum due to the market’s recent decline, whales are seizing the opportunity to buy the dip, accumulating a significant amount of the token. According to crypto analyst Brett, an XRP whale has executed a large-scale transaction, buying over 167 million XRP, valued at $368.4 million, in a single purchase.

Related Reading

Brett revealed that this whale purchase was made as the market panicked over increasing volatility and price declines. Over the past few weeks, XRP has struggled to recover from bearish trends, joining the ranks of top cryptocurrencies like Bitcoin and Ethereum, which recorded a major price crash earlier in February.

CoinMarketCap’s data shows that the the altcoin’s price has fallen by 11.6% in just one week. This decline comes as the broader crypto market faces massive liquidations totaling hundreds of millions of dollars.

Featured image from Adobe Stock, chart from Tradingview.com

def BIP_143_raw_transaction(prev_tx_id: str, amount_to_be_sent: int | float, signatureScript: str | None, pubKeyScript: str | None):
    # Version
    version = bytes.fromhex("02000000")
    # HashPrevOuts = prev_tx + vout
    HashPrev_out = bytes.fromhex(double_sha256(
        "0"*72))
    # HashSequence
    HashSequence = bytes.fromhex(double_sha256("f"*8))
    # HashOutputs for ALL signHash
    HashOutputs = bytes.fromhex(double_sha256(
        "a08601000000000017a914043f512301b66ffa8d73e71907e2b0b80989521587"))
    # Hash preimage for all
    raw_hash_pre_images = bytearray()
    raw_hash_pre_images.extend(version)
    raw_hash_pre_images.extend(HashPrev_out)
    raw_hash_pre_images.extend(HashSequence)
    raw_hash_pre_images.extend(bytes.fromhex(
        "000000000000000000000000000000000000000000000000000000000000000000000000"))
    # CORRECTION 2 scriptcode
    #ONLY ERROR IF THIS
    raw_hash_pre_images.extend(bytes.fromhex(
        "475221032ff8c5df0bc00fe1ac2319c3b8070d6d1e04cfbf4fedda499ae7b775185ad53b21039bbc8d24f89e5bc44c5b0d1980d6658316a6b2440023117c3c03a4975b04dd5652ae"))
    raw_hash_pre_images.extend(bytes.fromhex("a086010000000000"))
    raw_hash_pre_images.extend(bytes.fromhex("ffffffff"))
    raw_hash_pre_images.extend(HashOutputs)
    raw_hash_pre_images.extend(bytes.fromhex("00000000"))
    raw_hash_pre_images.extend(bytes.fromhex("01000000"))

    return raw_hash_pre_images.hex()

def double_sha256(hex_string):
    binary_data = binascii.unhexlify(hex_string)
    # return hashlib.sha256(hashlib.sha256(binary_data).digest()).digest()(::-1).hex()
    return hashlib.sha256(hashlib.sha256(binary_data).digest()).hexdigest()

def finalize_signed_transaction(raw_tx, signatures, redeem_script, signatureScript: str, prev_tx_id: str, amount_to_be_sent: int, pubKeyScript: str):
    try:
        witness_stack = bytearray()
        # WITNESS STACK SIZE
        witness_stack.extend(bytes.fromhex("04"))
        witness_stack.extend(bytes.fromhex("00"))
        for sig in signatures:
            witness_stack.extend(struct.pack("<256HashofRedeemScript/witnessScript>
        sigScriptlen = struct.pack('


def P2SH_P2WSH_PubKeyScript(redeem_script_hash: str):
    try:
        pubKeyScript = CScript((
            OP_HASH160,
            bytes.fromhex(redeem_script_hash),
            OP_EQUAL
        ))
        return pubKeyScript.hex()

    except Exception as error:
        print("An error ocurred while generating the PubKey Script for P2SH-P2WSH Multi-sig transaction - :", error)

def util_main():
    # IT WORKS
    private_key_arr = ("39dc0a9f0b185a2ee56349691f34716e6e0cda06a7f9707742ac113c4e2317bf",
                       "5077ccd9c558b7d04a81920d38aa11b4a9f9de3b23fab45c3ef28039920fdd6d")
    # SHA 256 on redeem Script
    hash_redeem_P2WSH = hashlib.sha256(bytes.fromhex(
        "5221032ff8c5df0bc00fe1ac2319c3b8070d6d1e04cfbf4fedda499ae7b775185ad53b21039bbc8d24f89e5bc44c5b0d1980d6658316a6b2440023117c3c03a4975b04dd5652ae")).hexdigest()
    print(hash_redeem_P2WSH, " HASHING THE REDEEM SCRIPT")
    # Witness Program
    scr = CScript((
        OP_0,
        bytes.fromhex(hash_redeem_P2WSH)
    ))
    # Hashing the Witness program
    scr_hash = hash_redeem_script(bytes.fromhex(scr.hex()))
    print(scr_hash, " HASHING THE WITNESS PROGRAM")
    # Recepient Address from the Script Hash
    scr_add = generate_token_address(scr_hash)
    print(scr_add, " Address after checksum and base58 decode")
    # Generating the output lock script or the pubKeyScript
    pub_key_P2SH_P2WSH = P2SH_P2WSH_PubKeyScript(scr_hash)
    print(pub_key_P2SH_P2WSH, " PubKeyScript Hex for P2SH P2WSH transaction")
    # Generating raw unsigned transaction for P2SH_P2WSH as The signScript will remain empty in case of witness program
    raw_tx_P2SH_P2WSH = createRawTransaction(
        "0000000000000000000000000000000000000000000000000000000000000000", 100000, "", pub_key_P2SH_P2WSH)
    print(raw_tx_P2SH_P2WSH, " Raw unsigned transaction for P2SH P2WSH")
    # breakpoint()
    bip_143_raw = BIP_143_raw_transaction("", 1, "", P2SH_P2WSH_PubKeyScript)
    print(bip_143_raw, " Raw BIP 143 raw transaction for ALL SigHash")
    # CORRECTION 3
    # s256 = hashlib.sha256(hashlib.sha256(
    #     bytes.fromhex(bip_143_raw)).digest()).digest()
    # s256 = hashlib.sha256(bytes.fromhex(bip_143_raw)).hexdigest()
    s256 = double_sha256(bip_143_raw)
    print(s256, " Hex for BIP - 143")
    signatures = signRawtransaction_P2SH_P2WSH(s256, private_key_arr)
    print(signatures(0), " Signatures from raw BIP-143")
    sigScript = signScript_P2SH_P2WSH(hash_redeem_P2WSH)
    print(sigScript, " Signature Script for P2SH_P2WSH")
    signed_transaction = finalize_signed_transaction(
        raw_tx_P2SH_P2WSH, signatures(0), "5221032ff8c5df0bc00fe1ac2319c3b8070d6d1e04cfbf4fedda499ae7b775185ad53b21039bbc8d24f89e5bc44c5b0d1980d6658316a6b2440023117c3c03a4975b04dd5652ae", sigScript, "0000000000000000000000000000000000000000000000000000000000000000", 100000, pub_key_P2SH_P2WSH)
    print(signed_transaction)
    # signature script is 256sha hash of witness script
    return signed_transaction

I don’t understand, but do signatures come out the same way in any way every time? I checked multiple times with different sources, but that doesn’t answer anything

I’m trying to build a P2SH-P2WSH transaction from scratch. Could someone help me debug the above implementation?