Now we’ll try to set up the node using bitcoin. I followed the instructions to download the file. I would like to check the release signature before installing. First done:

someone@somewhere:~/Downloads$ gpg --recv-keys 01EA5486DE18A882D4C2684590C8019E36C2E964
gpg: key 90C8019E36C2E964: public key "Wladimir J. van der Laan (Bitcoin Core binary release signing key) <(email protected)>" imported
gpg: Total number processed: 1
gpg:               imported: 1

That seemed okay. I’d like to confirm that it was signed after this SHA256SUMS.asc This is the file I downloaded before, but I’ll get it.

someone@somewhere:~/Downloads$ gpg --verify SHA256SUMS.asc 
gpg: no signed data
gpg: can't hash datafile: No data

What am I doing wrong?

A lawyer in Hollidaysburg, Pennsylvania, pleaded guilty in federal court to forging the signature of a U.S. district judge. Michael Brandon Cohen, 41, did so twice after failing to file a lawsuit on behalf of a civil client. From a Department of Justice press release:

On May 18, 2022, and October 13, 2022, Cohen sent the victim fake court orders purportedly issued by Chief United States District Judge for the Middle District of Pennsylvania Matthew W. Brann in the victim’s favor against the healthcare company. The orders awarded the victim monetary sanctions and fees and bore the electronic signature of the Chief Judge. Chief Judge Brann never issued the orders and, therefore, did not authorize his electronic signature on the orders. Rather, Cohen forged Chief Judge Brann’s signature on the fake orders in an effort to authenticate their legitimacy to his victim client.

He had never filed the lawsuit against the defendant, a healthcare company, so Brann had never seen it, let alone issued any orders in the case. It’s hard to imagine how this could have worked out for Cohen, who faces years in prison and up to $500,000 in fines. The guilty plea could win him a lighter sentence when he’s sentenced in November.

Cohen was already disbarred in Pennsylvania and the Bedford Gazette reports that he also faces a third-degree felony county of theft after homeowners in Kimmel Township there accused him of misappropriating $60,000. Heather Koontz writes that Cohen was hired to deal with a lien on a property, was provided the money to settle the relevant debts, but did not do so.

According to court records, Cohen told the man that he settled with Wells Fargo, and if he and his wife would pay $60,000, they would own the property with no liens on it. … The victims later discovered their house listed for sheriff’s sale and contacted Cohen, who said he would have the sale reversed.

On Jan. 30, 2024, members of the Sheriff’s Department arrived on scene with a court order forcing the couple to vacate, which they did, before they again called Cohen about the issue. Cohen, according to reports, again ensured them he would get the sale reversed.

And so on, and so on. Reads like a case of “new story to cover the old story” until that’s not possible anymore. There’s some more details at the Altoona Mirror.

In a criminal complaint, police officers said Cohen told them that in 2022, he started feeling as though he was losing his mind and stopped going to work. Officers said he was advising clients that he would look into their matters or file something when he hadn’t. Officers said Cohen also spoke of how guilt had caused him to give away money held in escrow and his own money to clients who were told that he had resolved their cases.

When Haines quizzed Cohen about his work history, Cohen spoke of practicing law until April 2023. He said since fall 2023, he has been working as a marketing manager for a window and door replacement company.

Previously:
• ‘Dragon lawyer’ annoys judge with cartoon dragon watermark
• Judge fines lawyers $31k after they use AI to generate brief with made-up citations
• Lawyer in Florida who fought against helmet laws killed on motorcycle while not wearing a helmet

Plus: Conor McGregor’s Bitcoin plan

GM. We squeezed out the noise, filtered the pulp, and poured you a straight shot of what actually matters.

A risk that came with Ethereum Pectra.

News drops: Conor McGregor wants a national Bitcoin reserve for Ireland, Metaplanet surpasses El Salvador + more

Market flavor today

What a time to be in crypto

Everything’s green, Bitcoin flipped Amazon in market cap (and continues trading above $100K), and the vibes are moon-ready

One big reason for all that: the trade war is de-escalating.

Last week, the US and UK reached a trade deal.

Now, the US and China have agreed to take a few steps back with their tariffs for the next 90 days.

Here’s what’s gonna change by Wednesday:

Trade wars tend to drag down global markets: they raise costs, increase uncertainty, and usually put investors in defense mode. So when those tensions ease, it’s like ASMR for the crypto community, because riskier assets become way more attractive again.

That’s why economist Alex Krüger said we can probably stop worrying so much about macro stuff for now. The China-US trade war was one of the biggest market fears, and since it’s paused for the next 90 days, investors can focus on the fun things again.

… Like the fact that Bitcoin ETFs are crushing it: $581.1M in inflows at the end of last week alone.

Put all of this together, and we might be headed toward all-time highs soon.

But there’s one more thing to watch: CPI data drops tomorrow. Lower-than-expected inflation numbers could be the reason for the market to go full rocket mode

Fingers crossed.

Memecoin harvest

Sigma moves only

Data as of 05:00 AM EST.

Check out these memecoins and plenty more here.

Last week, we covered the Ethereum Pectra upgrade – what it changes and how it helps.

If you missed that edition, catch up here.

And now, Ethereum’s flexing hard – it outperformed every other major coin this week.

(Yes, I know, it’s been a while since “Ethereum” and “outperformed” were in the same sentence. ETH maxis, your time has come. Finally.)

This price increase wasn’t random – Pectra made Ethereum stronger, more scalable, and way easier to use. All great stuff.

But – and this is a big but (one T, you animal) – it also came with a pretty serious new risk in the security department

Before Pectra, a hacker would need you to approve an on-chain transaction to steal your crypto. That usually came with gas fees and a clear confirmation screen, so users had a good chance to catch anything suspicious.

After Pectra, tho’, your regular wallet can temporarily behave like a smart contract. And all it takes to activate that is signing a message – even if it’s off-chain.

This is where things get dangerous. If a hacker tricks you into signing one of these off-chain messages – say, through a fake website – they can use your signature to make your wallet run code they control. And that can give their contract full control of your funds.

No transaction approval. No gas fees to make you pause. No warning. Just one signature.

Even hardware wallets aren’t safe if a user signs one of these messages.

So yeah, NEVER sign an off-chain message unless you’re 100% sure what it does. If you’re unsure, DO NOT touch it.

Stay safe out there.

News drops

Conor McGregor’s got a new striking combo. Step 1: run for president of Ireland. Step 2: create a national Bitcoin reserve.

Ledger’s Discord was briefly hacked yesterday after a mod’s account got taken over. The issue was fixed quickly, and new security measures are now in place.

Metaplanet bought another 1,241 Bitcoin. They now hold 6,796 BTC – that’s more than El Salvador.

The new pope, Robert Prevost – now going by Pope Leo XIV – started his time in charge by talking about AI. He said all this new tech brings up big questions about fairness, jobs, and the value of human life.

Thinking about Pi Coin again? Same. Here’s the live price chart if you want to see where it’s at.

Juicy memes

I’m trying to put this in PSBT:

1. Alice pays to buy a BRC-20 quantity from Bob
2. Bob requests to occupy a BRC-20 transfer using his burner account
3. Burner carries the transfer of the BRC-20 and transfers to Bob
4. Bob transfers BRC-20 to Alice

Bob created and signed a Burner account with PSBT. Then send it to Alice, pay it and sign it. Alice Topup on Price covers network fees for all of the following transactions:

The problem I’m currently facing is how to get the required input UTXO PARAMS from the previous output? Could this have been using Bitcoinjs-Lib or the recommended library?

I have 3 Taproot addresses: one is 50 btc, one is RECEPIENT, and the other is for change

sender bcrt1p7d90fjh4k2uu7jjzw6hev8nnak2cultvcyjaj5zum696eqpwfausw79xuk
wif cULydXkHkv3h1jH7yVaGcNCvWHzbVsDiAxW76Mc8QrSqzNPU2sUG
recipient bcrt1p725t652m53g7j87n2ypm3x9pdl9f88c4c2hjyvymq78qhrc6tpsq5wp62r
change bcrt1pj5fle7sshyr04yershteu745zs2peguum7z575rydshtscmdjysq4eus02

I’m trying to send one BTC and create a raw transaction for the spend type of keypath

This is at the sender’s hands:

(
    {
        "txid": "6ee6185784989263847ebd3d2aadb83bdbe80ed0011821085975226ae994e259",
        "vout": 0,
        "address": "bcrt1p7d90fjh4k2uu7jjzw6hev8nnak2cultvcyjaj5zum696eqpwfausw79xuk",
        "label": "",
        "scriptPubKey": "5120f34af4caf5b2b9cf4a4276af961e73ed958e7d6cc125d9505cde8bac802e4f79",
        "amount": 50,
        "confirmations": 101,
        "spendable": true,
        "solvable": true,
        "desc": "rawtr(f34af4caf5b2b9cf4a4276af961e73ed958e7d6cc125d9505cde8bac802e4f79)#qrffuhzp",
        "parent_descs": (
            "addr(bcrt1p7d90fjh4k2uu7jjzw6hev8nnak2cultvcyjaj5zum696eqpwfausw79xuk)#cx2kp4mn"
        ),
        "safe": true
    }
)

1. Create a transaction object

     (CREATE TRANSACTION START)
    -- Amount to send (sats): 100000000
    -- Fee (sats): 1000000
    -- Get UTXO id for pay: 6ee6185784989263847ebd3d2aadb83bdbe80ed0011821085975226ae994e259
    -- Reversed UTXO id: 59e294e96a22755908211801d00ee8db3bb8ad2a3dbd7e84639298845718e66e
    -- Full generated tx: {
        "version":2,
        "inputs":
            ({
                "txid":"59e294e96a22755908211801d00ee8db3bb8ad2a3dbd7e84639298845718e66e",
                "vout":0,
                "scriptSig":"",
                "sequence":4294967295
            }),
        "outputs":({
                "value":100000000,
                "scriptPubKey":"51209545ea8add228f48fe9a881dc4c50b7e549cf8ae15791184d83c705c78d2c300"
            },{
                "value":4899000000,
                "scriptPubKey":"5120a89fe7d085c837d4991c2ebcf3d5a0a0a0e51ce6fc2a7a83236175c31b6c8900"
            }),
        "locktime":0}
    (CREATE TRANSACTION END)

2. Sign and Serialization

(SIGN AND SERIALIZE TRANSACTION START)
(INPUT 0)
-- txid (32 bytes): 59e294e96a22755908211801d00ee8db3bb8ad2a3dbd7e84639298845718e66e
-- Vout (4 bytes LE32): 00000000
-- ScriptSigLength (1 bytes Compact size): 00
-- ScriptSig (0 bytes):
-- Sequence (4 bytes LE32): ffffffff
-- (SIGHASH FOR 0 INPUT START)
---- Version (4 bytes LE32): 02000000
---- LockTime (4 bytes LE32): 00000000
---- InputIdx (4 bytes LE32): 00000000
---- SighashTypeBuf (1 bytes): 00
---- (HASH PREVOUTS (txid + LE32(vout)) START)
------ Prevout for 0 input (36 bytes): 59e294e96a22755908211801d00ee8db3bb8ad2a3dbd7e84639298845718e66e00000000
---- (HASH PREVOUTS END)
---- Finally hashPrevouts (32 bytes): 35bb28a690e32f668589a79a1b4f7ba82c00c08fe39b29672e861e90526991a9
---- (HASH AMOUNTS (LE64(amount))) START)
------ Amount for 0 input (8 bytes LE64): 3200000000000000
---- (HASH AMOUNTS END)
---- Finally hashAmounts (32 bytes): 0cbbab9d99fb661a1686f17ccaaf8a9d069aa8cb755925045a1d049c060b9e67
---- (HASH SCRIPT PUB KEYS (OP_1 + PUSH_32 + pubKeyHash) START)
------ ScriptPubKey for 0 input (34 bytes): 51209a57a657ad95ce7a5213b57cb0f39f6cac73eb66092eca82e6f45d6401727bc8
---- (HASH SCRIPT PUB KEYS END)
---- Finally hashScriptPubKeys (32 bytes): 96d403e277844293f22ba2b1914d646d8353adbe2c49a22a7f421a8c97221eaa
---- (HASH SEQUENCES (LE32(sequence)) START)
------ Sequence for 0 input (4 bytes LE32): ffffffff
---- (HASH SEQUENCES END)
---- Finally hashSequences (32 bytes): ad95131bc0b799c0b1af477fb14fcf26a6a9f76079e48bf090acb7e8367bfd0e
---- (HASH OUTPUTS (LE64(amount), CompactSize(size), scriptPubKey) START)
------ Amount of 0 out (8 bytes LE64): 00e1f50500000000
------ ScriptPubKey of 0 out (34 bytes): 51209545ea8add228f48fe9a881dc4c50b7e549cf8ae15791184d83c705c78d2c300
------ Size of 0 out (1 bytes CompactSize): 22
------ Output of 0 out (43 bytes): 00e1f505000000002251209545ea8add228f48fe9a881dc4c50b7e549cf8ae15791184d83c705c78d2c300
------ Amount of 1 out (8 bytes LE64): c0ce002401000000
------ ScriptPubKey of 1 out (34 bytes): 5120a89fe7d085c837d4991c2ebcf3d5a0a0a0e51ce6fc2a7a83236175c31b6c8900
------ Size of 1 out (1 bytes CompactSize): 22
------ Output of 1 out (43 bytes): c0ce002401000000225120a89fe7d085c837d4991c2ebcf3d5a0a0a0e51ce6fc2a7a83236175c31b6c8900
---- (HASH OUTPUTS END)
---- Finally hashOutputs (32 bytes): c74c74b357372c390436f57e6046707b88dc74a7199e9194922818188192de44
---- Preimage (174 bytes): 02000000000000000035bb28a690e32f668589a79a1b4f7ba82c00c08fe39b29672e861e90526991a90cbbab9d99fb661a1686f17ccaaf8a9d069aa8cb755925045a1d049c060b9e6796d403e277844293f22ba2b1914d646d8353adbe2c49a22a7f421a8c97221eaaad95131bc0b799c0b1af477fb14fcf26a6a9f76079e48bf090acb7e8367bfd0ec74c74b357372c390436f57e6046707b88dc74a7199e9194922818188192de440000000000
---- TaggedHash (32 bytes): 7f73f0e9137223806b5c6c4f157f30ed439949decb84b4ab1eff249fa61692c1
-- (SIGHASH FOR 0 INPUT END)
-- Sighash (32 bytes): 7f73f0e9137223806b5c6c4f157f30ed439949decb84b4ab1eff249fa61692c1
-- SignatureObject (64 bytes): 4227542a9daebfbf518e12b016f09f5f7feaae42bdf5874039dfd1ff7ec66b63b625e27be13a04b3d58c81891aca8908cd5ca548cfc3f080fd2d0bcfc0045138
-- Pubkey (32 bytes): f34af4caf5b2b9cf4a4276af961e73ed958e7d6cc125d9505cde8bac802e4f79
-- VALID? true
-- Witness count for 0 input (1 bytes Compact Size): 01
-- Signature len for 0 input (1 bytes Compact Size): 40
-- Signature for 0 input (64 bytes): 4227542a9daebfbf518e12b016f09f5f7feaae42bdf5874039dfd1ff7ec66b63b625e27be13a04b3d58c81891aca8908cd5ca548cfc3f080fd2d0bcfc0045138
(OUTPUT 0)
-- Value (8 bytes LE64): 00e1f50500000000
-- ScriptPubKey (34 bytes): 51209545ea8add228f48fe9a881dc4c50b7e549cf8ae15791184d83c705c78d2c300
-- ScriptPubKeySize (1 bytes Compact size): 22
(OUTPUT 1)
-- Value (8 bytes LE64): c0ce002401000000
-- ScriptPubKey (34 bytes): 5120a89fe7d085c837d4991c2ebcf3d5a0a0a0e51ce6fc2a7a83236175c31b6c8900
-- ScriptPubKeySize (1 bytes Compact size): 22
Locktime (4 bytes LE32): 00000000
Marker (1 bytes): 00
Flag (1 bytes): 01
Version (4 bytes LE32): 02000000
InputsLen (1 bytes Compact Size): 01
OutputsLen (1 bytes Compact Size): 02
Finally rawTx (205 bytes): 0200000000010159e294e96a22755908211801d00ee8db3bb8ad2a3dbd7e84639298845718e66e0000000000ffffffff0200e1f505000000002251209545ea8add228f48fe9a881dc4c50b7e549cf8ae15791184d83c705c78d2c300c0ce002401000000225120a89fe7d085c837d4991c2ebcf3d5a0a0a0e51ce6fc2a7a83236175c31b6c89000140eddd2049ece47dd2fea1fb2e5f9d0c475e32431a472c64d543160097359f266f13c3a409de8366d09b105741ecaee1cfac6542ed1e084cee58310d82da28775000000000
(SIGN AND SERIALIZE TRANSACTION END)

And in the end I got

Error creating RPC request: Required script-verify-flag-failed (invalid schnorr signature)

However, the transaction structure is valid, it is both a signature and a witness.

{
  "version": "02000000",
  "marker": "00",
  "flag": "01",
  "inputcount": "01",
  "inputs": (
    {
      "txid": "59e294e96a22755908211801d00ee8db3bb8ad2a3dbd7e84639298845718e66e",
      "vout": "00000000",
      "scriptsigsize": "00",
      "scriptsig": "",
      "sequence": "ffffffff"
    }
  ),
  "outputcount": "02",
  "outputs": (
    {
      "amount": "00e1f50500000000",
      "scriptpubkeysize": "22",
      "scriptpubkey": "51209545ea8add228f48fe9a881dc4c50b7e549cf8ae15791184d83c705c78d2c300"
    },
    {
      "amount": "c0ce002401000000",
      "scriptpubkeysize": "22",
      "scriptpubkey": "5120a89fe7d085c837d4991c2ebcf3d5a0a0a0e51ce6fc2a7a83236175c31b6c8900"
    }
  ),
  "witness": (
    {
      "stackitems": "01",
      "0": {
        "size": "40",
        "item": "4227542a9daebfbf518e12b016f09f5f7feaae42bdf5874039dfd1ff7ec66b63b625e27be13a04b3d58c81891aca8908cd5ca548cfc3f080fd2d0bcfc0045138"
      }
    }
  ),
  "locktime": "00000000"
}

Please help. Could there be something wrong with your bytes, data, or order? thank you very much!

HodlX Guest Post  Submit Your Post

Zero days without incidents in the DeFi space. This time the vulnerability was discovered in a widely used ‘elliptic library.’

What makes matters worse – its exploitation could lead to hackers taking control of users’ private keys and draining wallets.

All through a simple fraudulent message signed by a user. Is this a critical issue?

The first thing to consider is the fact that libraries like elliptic provide developers with ready-made code components.

This means that instead of writing the code from scratch and checking it as they go, developers just borrow the elements they need.

While it’s considered to be a safer practice, since the libraries are continuously used and tested, this also increases the risks if one vulnerability gets through.

Elliptic library is used extensively across the JavaScript ecosystem. It powers cryptographic functions in many well-known blockchain projects, web applications and security systems.

According to NPM statistics, the package containing the error is downloaded approximately 12–13 million times weekly, with over 3,000 projects directly listing it as a dependency.

This broad usage implies that the vulnerability potentially affects a vast number of applications – especially cryptocurrency wallets, blockchain nodes and electronic signature systems – as well as any service relying on ECDSA signatures through elliptic, especially when handling externally provided input.

This vulnerability allows remote attackers to fully compromise sensitive data without proper authorization.

That’s why the issue received an extremely high severity rating – approximately nine out of 10 on the CVSS scale.

It’s important to point out that exploiting this vulnerability requires a very specific sequence of actions and the victim must sign arbitrary data provided by the attacker.

That means that some projects may remain safe, for example, if an application only signs predetermined internal messages.

Still, many users don’t pay as much attention when signing messages via crypto wallets as they do when signing a transaction.

Whenever a Web 3.0 site asks users to sign terms of service, users often neglect to read them.

Similarly, users might quickly sign a message for an airdrop without fully understanding the implications.

Technical details

The problem comes from not handling errors properly during the creation of ECDSA (Elliptic Curve Digital Signature Algorithm) signatures.

ECDSA is commonly used to confirm that messages, like blockchain transactions, are genuine.

To create a signature, you need a secret key – only the owner knows it – and a unique random number called a ‘nonce.’

If the same nonce is used more than once for different messages, someone could figure out the secret key using math.

Normally, attackers can’t figure out the private key from one or two signatures because each one uses a unique random number (nonce).

But the elliptic library has a flaw – if it gets an odd type of input (like a special string instead of the expected format), it could create two signatures with the same nonce for different messages.

This mistake could reveal the private key, which should never happen in proper ECDSA use.

To exploit this vulnerability, an attacker needs two things.

• A valid message and its signature from the user – for instance, from any previous interactions
• The user to sign a second message explicitly created to exploit the vulnerability

With these two signatures, the attacker can compute the user’s private key, gaining full access to funds and actions associated with it. Detailed information is available in the GitHub Security Advisory.

Exploitation scenarios

Attackers may exploit this vulnerability through various methods, including the following.

• Phishing attacks that direct users to fake websites and request message signatures
• Malicious DApps (decentralized applications) disguised as harmless services, such as signing terms of use or participating in airdrops
• Social engineering convincing users to sign seemingly harmless messages
• Compromising servers’ private keys that sign messages from users

A particularly concerning aspect is users’ generally lax attitude toward signing messages compared to transactions.

Crypto projects frequently ask users to sign terms of service or airdrop participation messages, potentially making exploitation easier.

So, think about it – would you sign a message to claim free tokens? What if that signature could cost you your entire crypto balance?

Recommendations

Users must promptly update all applications and wallets that utilize the elliptic library for signatures to the latest secure version.

Exercise caution when signing messages, particularly from unfamiliar or suspicious sources.

Developers of wallets and applications should verify their elliptic library version.

If any users could be affected by the vulnerable version, developers must inform them about the urgent need for updating.

Gleb Zykov is the co-founder and CTO of HashEx Blockchain Security. He has more than 14 years of experience in the IT industry and over eight years in internet security, as well as a strong technical background in blockchain technology (Bitcoin, Ethereum and EVM-based blockchains).

Check Latest Headlines on HodlX

Follow Us on Twitter Facebook Telegram

Check out the Latest Industry Announcements  

Disclaimer: Opinions expressed at The Daily Hodl are not investment advice. Investors should do their due diligence before making any high-risk investments in Bitcoin, cryptocurrency or digital assets. Please be advised that your transfers and trades are at your own risk, and any loses you may incur are your responsibility. The Daily Hodl does not recommend the buying or selling of any cryptocurrencies or digital assets, nor is The Daily Hodl an investment advisor. Please note that The Daily Hodl participates in affiliate marketing.

Generated Image: DALLE3

I would like to send a raw transaction, but I have a problem. I’m using a RegTest node. P2PKH address was generated in seed breeding
mjnJj4TFyU4jYrTVUHMA632UmuUMssZHq4

Next, as usual, generateToAddress 101 block

I’ve never touched

(
    {
        "txid": "6481bbba699177c735c3e336735674641459bbbe2aba85a1b8be233df8f36938",
        "vout": 0,
        "address": "mjnJj4TFyU4jYrTVUHMA632UmuUMssZHq4",
        "label": "",
        "scriptPubKey": "76a9142ec7cc30ef662cf7c757e3460995f2682871207688ac",
        "amount": 50,
        "confirmations": 101,
        "spendable": true,
        "solvable": false,
        "parent_descs": (
            "addr(mjnJj4TFyU4jYrTVUHMA632UmuUMssZHq4)#rwelz9me"
        ),
        "safe": true
    }
)

And then I make a transaction. Just send a little Saturday to another empty address

My Step: 1. Create an empty transaction with one input and two outputs (one for change)

CREATE TRANSACTION START
== Amount to send (sats): 100000000
== Fee (sats): 1000000
== Get UTXO id for pay: 6481bbba699177c735c3e336735674641459bbbe2aba85a1b8be233df8f36938
== Reversed UTXO id: 3869f3f83d23beb8a185ba2abebb59146474567336e3c335c7779169babb8164
== Full generated tx: {"version":1,"inputs":({"txid":"3869f3f83d23beb8a185ba2abebb59146474567336e3c335c7779169babb8164","vout":0,"scriptSig":"76a9142ec7cc30ef662cf7c757e3460995f2682871207688ac","sequence":4294967295}),"outputs":({"value":100000000,"scriptPubKey":"76a914796e2d78cff63c21f8ee823052b5362bc2cc2af388ac"},{"value":4899000000,"scriptPubKey":"76a914929b53a5d57f12e924b9c6d58524faec5c5cfee788ac"}),"locktime":0}
CREATE TRANSACTION END

2. Next, serialize it

SERIALIZATION START
== Version (4 bytes LE):  01000000
== Input Count (1 bytes Compact Size): 01
==== TXID (32 bytes Natural Byte Order): 3869f3f83d23beb8a185ba2abebb59146474567336e3c335c7779169babb8164
==== VOut (4 bytes LE):  00000000
==== ScriptSig Size (1 bytes Compact Size): 19
==== ScriptSig (25 bytes): 76a9142ec7cc30ef662cf7c757e3460995f2682871207688ac
==== Sequence (4 bytes LE):  ffffffff
== Output Count: (1 bytes Compact Size): 02
==== Amount (8 bytes LE): 00e1f50500000000
==== ScriptPubKey Size (1 bytes Compact Size): 19
==== ScriptPubKey (25 bytes): 76a914796e2d78cff63c21f8ee823052b5362bc2cc2af388ac
==== Amount (8 bytes LE): c0ce002401000000
==== ScriptPubKey Size (1 bytes Compact Size): 19
==== ScriptPubKey (25 bytes): 76a914929b53a5d57f12e924b9c6d58524faec5c5cfee788ac
==== Locktime (4 bytes LE): 00000000
== SIGHASH_ALL (4 bytes LE):  01000000
== Final Buffer: 01000000013869f3f83d23beb8a185ba2abebb59146474567336e3c335c7779169babb8164000000001976a9142ec7cc30ef662cf7c757e3460995f2682871207688acffffffff0200e1f505000000001976a914796e2d78cff63c21f8ee823052b5362bc2cc2af388acc0ce0024010000001976a914929b53a5d57f12e924b9c6d58524faec5c5cfee788ac0000000001000000
SERIALIZATION END

3. Please sign

 SIGNING START
== WIF: cRcGtESEBF1ztuwtftM7Ds9Mcu1x6PtCK1TiXKTvShZF43ZtVYVY
== Private Key: 7828a7d17099c3d5baeaa4a8de47d97038e9cefd62d5d04e4736e47fe0a81779
== Public Key: 03a1dbe0aea6bf483bc00ed3d101f54e0b1e06e9c2e5103de5950b135ff055f107
== Double sha256 of serialized tx: 08b7c9af7310ff1dbeea59575dd851565b52046a03631351b5aec94100655b91
== Der signature with sighash: 304502210085016fb2b7cc850ca2560da9e5873c922643388af63ae5a496899acd6e94537c022077df3eba94465a22f764338a9200865a591c7998206c9fbcf22080d9152f45af01
== All size (1 bytes Compact Size): 6b
== Sig len (1 bytes Compact Size): 48
== Pub Key (1 bytes Compact Size): 21
== ScriptSig Size (1 bytes Compact Size): 6c
== ScriptSig (108 bytes): 6b48304502210085016fb2b7cc850ca2560da9e5873c922643388af63ae5a496899acd6e94537c022077df3eba94465a22f764338a9200865a591c7998206c9fbcf22080d9152f45af012103a1dbe0aea6bf483bc00ed3d101f54e0b1e06e9c2e5103de5950b135ff055f107
SIGNING END

what happened ? der signature? Does it have it in my data and Argo? please help me. I wrote the code to send raw transactions, investigation procedures, but I think I made a mistake somewhere

4. Final Hex and Command

bitcoin-cli -regtest \
       -rpcuser=bitcoin \
       -rpcpassword=ggbUUhXBbgUVDd2vdaMRb-KVYusRXbV-fVgjdMMdOWA \
       -rpcwallet="app_wallet" \
        sendrawtransaction 01000000013869f3f83d23beb8a185ba2abebb59146474567336e3c335c7779169babb8164000000006b48304502210085016fb2b7cc850ca2560da9e5873c922643388af63ae5a496899acd6e94537c022077df3eba94465a22f764338a9200865a591c7998206c9fbcf22080d9152f45af012103a1dbe0aea6bf483bc00ed3d101f54e0b1e06e9c2e5103de5950b135ff055f107ffffffff0200e1f505000000001976a914796e2d78cff63c21f8ee823052b5362bc2cc2af388acc0ce0024010000001976a914929b53a5d57f12e924b9c6d58524faec5c5cfee788ac00000000 0.10 200000
   

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?

I’m trying to create a child inscription in a Taproot transaction, but I’m running into the following error:

sendrawtransaction RPC error: {"code":-26,"message":"mandatory-script-verify-flag-failed (Invalid Schnorr signature)"}

I checked all the data, including transaction structure, signatures, TapRoot scripts, and more, but the error persists.

The input refers to the parent UTXO.

{
  "txid": "02cde20c6db772c9ddced410c52cb2bdcbf476016fa398cfa1ac5207f1ff462f",
  "vout": 0,
  "value": 546,
  "scriptPk": "5120932a0391d2ec13cb8f303ded9297ece089f739b3ced40bc98eebdd277fdb9c9d",
  "address": "tb1pjv4q8ywjasfuhres8hke99lvuzylwwdnem2qhjvwa0wjwl7mnjwsdqu3e0"
}

The output sends 546 Satoshis to the recipient address. The Taproot script for the child’s inscription includes:

Parent inscription data (InscriptionID). Child inscription metadata.

const childOrdinalStacks = (
  publicKey,
  bitcoin.opcodes.OP_CHECKSIG,
  bitcoin.opcodes.OP_FALSE,
  bitcoin.opcodes.OP_IF,
  Buffer.from("ord", "utf8"),
  1, 1,
  Buffer.from("text/plain;charset=utf-8", "utf8"),
  1, 2,
  pointerBuffer1,
  1, 3,
  Buffer.from(parentInscriptionId, "hex"),
  1, 5,
  cbor.encode(childMetadata),
  1, 7,
  Buffer.from("parcel.bitmap", "utf8"),
  bitcoin.opcodes.OP_0,
);

RAW TX Hash

020000000001022f46fff10752aca1cf98a36f0176f4cbbdb22cc510d4ceddc972b76d0ce2cd020000000000ffffffffc14499f6058bc6c6d5eed11c699c80007199690c12bee4a54fd46d5a9f5193e00100000000ffffffff022202000000000000225120932a0391d2ec13cb8f303ded9297ece089f739b3ced40bc98eebdd277fdb9c9d2202000000000000225120932a0391d2ec13cb8f303ded9297ece089f739b3ced40bc98eebdd277fdb9c9d01406fcbc5b6b63cb67c2289a5b4df1f3e1971b26ad4310b644da9a5a8488247f6ae44b50d7be59eecd8c58a268ce74eeb490b31bfda28cfeee6c101a914b54d613e03400058e04b9c6438f33f9a3541fe8d2a5c229794a00eb6c005aaedeb1b4622ca9c0c902d714b550e0b352578c761ac3853a5766078d7cded283f15070ef53b6c1ee8206705021108c86f6f7249e85d233414afa8eeaadaea2bad863b2ccce504126879ac0063036f7264010118746578742f706c61696e3b636861727365743d7574662d3801020222020103202f46fff10752aca1cf98a36f0176f4cbbdb22cc510d4ceddc972b76d0ce2cd02010528a264747970656b54657374204e46542023316b6465736372697074696f6e6954657374205465737401070d70617263656c2e6269746d6170003f68747470733a2f2f617277656176652e6e65742f4933326c517668673341514c583444632d334e48557773434e366e75382d6c78477352634e7765336372346821c06705021108c86f6f7249e85d233414afa8eeaadaea2bad863b2ccce50412687900000000

I’m using Tweaksigner to sign the input.

const signer = tweakSigner(wallet);
psbt.signInput(0, signer);
psbt.signInput(1, wallet.keyPair);


export function tweakSigner(wallet: Wallet, opts: any = {}) {
  let privateKey: any = wallet.keyPair.privateKey;
  if (!privateKey) {
    throw new Error('Private key is required for tweaking signer!');
  }
  if (wallet.keyPair.publicKey(0) === 3) {
    privateKey = ecc.privateNegate(privateKey);
  }
  const tweakedPrivateKey = ecc.privateAdd(privateKey, tapTweakHash(wallet.internalPubkey, opts.tweakHash));
  if (!tweakedPrivateKey) {
    throw new Error('Invalid tweaked private key!');
  }
  return ECPair.fromPrivateKey(Buffer.from(tweakedPrivateKey), {
    network: wallet.network,
  });
}


function tapTweakHash(pubKey: Buffer, h: Buffer | undefined): Buffer {
  return bitcoin.crypto.taggedHash(
    "TapTweak",
    Buffer.concat(h ? (pubKey, h) : (pubKey))
  );
}