From f0c7eab26598d5e965409c50c57c9a0a490a4405 Mon Sep 17 00:00:00 2001
From: jrakibi <j.errakibi@gmail.com>
Date: Mon, 17 Feb 2025 22:00:35 +0700
Subject: [PATCH] remove implement-OP_ADD-OP_HASH160.mdx

---
 decoding/implement-OP_ADD-OP_HASH160.mdx | 394 -----------------------
 1 file changed, 394 deletions(-)
 delete mode 100644 decoding/implement-OP_ADD-OP_HASH160.mdx

diff --git a/decoding/implement-OP_ADD-OP_HASH160.mdx b/decoding/implement-OP_ADD-OP_HASH160.mdx
deleted file mode 100644
index 58e8801..0000000
--- a/decoding/implement-OP_ADD-OP_HASH160.mdx
+++ /dev/null
@@ -1,394 +0,0 @@
----
-title: "Implement OP_ADD, OP_HASH160"
-date: 2024-01-05T15:32:14Z
-lastmod: "2024-10-06"
-draft: false
-category: Scripts
-layout: TopicBanner
-order: 4
-project: true
-images:
-    [
-        "/decoding-bitcoin/static/images/topics/thumbnails/project-stack-thumbnail.webp"
-    ]
-parent: project
----
-
-In Bitcoin script, OP_ADD adds the top two items on the stack, while OP_HASH160 computes the RIPEMD160(SHA256(x)) hash of the top stack item.
-
-## Task
-
-Complete the `OP_ADD` and `OP_HASH160` functions in `challenges/OpcodeFunctions.js`:
-
-1. Implement `OP_ADD` to add the top two stack items, handling Bitcoin's number encoding.
-2. Implement `OP_HASH160` to compute the RIPEMD160(SHA256(x)) hash of the top stack item.
-
-## Implementation
-
-<ExerciseSelector
-  sandpackConfig={{
-    files: {
-      "/challenges/OpcodeFunctions.js": {
-        code: `
-import CryptoJS from 'crypto-js';
-
-export function encodeNum(num) {
-    if (num === 0) return Buffer.alloc(0);
-
-    const absNum = Math.abs(num);
-    const negative = num < 0;
-    const result = [];
-    let currentNum = absNum;
-
-    while (currentNum) {
-        result.push(currentNum & 0xff);
-        currentNum >>>= 8;
-    }
-
-    if (result[result.length - 1] & 0x80) {
-        if (negative) {
-            result.push(0x80);
-        } else {
-            result.push(0);
-        }
-    } else if (negative) {
-        result[result.length - 1] |= 0x80;
-    }
-
-    return Buffer.from(result);
-
-}
-
-export function decodeNum(buffer) {
-    if (buffer.length === 0) return 0;
-
-    const bigEndian = Buffer.from(buffer).reverse();
-    let result = 0;
-    const negative = bigEndian[0] & 0x80;
-
-    if (negative) {
-        result = bigEndian[0] & 0x7f;
-    } else {
-        result = bigEndian[0];
-    }
-
-    for (let i = 1; i < bigEndian.length; i++) {
-        result <<= 8;
-        result += bigEndian[i];
-    }
-
-    if (negative) {
-        return -result;
-    } else {
-        return result;
-    }
-
-}
-
-export const OP_ADD = (stack) => {
-    // TODO: Implement OP_ADD
-}
-
-export const OP_HASH160 = (stack) => {
-    // TODO: Implement OP_HASH160
-}
-
-export const OP_CODE_FUNCTIONS = {
-    OP_ADD,
-    OP_HASH160
-    // Add more opcodes here
-}`,
-        active: true
-      },
-      "/OpcodeSimulator.js": {
-        code: `
-import React, { useState } from "react"
-import { motion, AnimatePresence } from "framer-motion"
-import { ArrowDownCircle, ArrowUpCircle, Info } from "lucide-react"
-import { OP_CODE_FUNCTIONS, decodeNum } from "./challenges/OpcodeFunctions"
-
-const OpcodeSimulator = () => {
-const [stack, setStack] = useState([]);
-const [input, setInput] = useState('0x');
-const [lastOperation, setLastOperation] = useState(null);
-const [showHexInfo, setShowHexInfo] = useState(false);
-const [scriptAsm, setScriptAsm] = useState('');
-
-    const handleInputChange = (e) => {
-        const value = e.target.value;
-        if (value.length < 2) {
-            setInput('0x');
-        } else if (value.startsWith('0x')) {
-            const hexPart = value.slice(2);
-            if (/^[0-9A-Fa-f]*$/.test(hexPart)) {
-                setInput(value);
-            }
-        }
-    };
-
-    const push = () => {
-        if (input.length > 2) {
-            const hexValue = input.slice(2);
-            setStack([...stack, Buffer.from(hexValue, 'hex')]);
-            setInput('0x');
-            setLastOperation("push");
-        }
-    };
-
-    const pop = () => {
-        if (stack.length > 0) {
-            setStack(stack.slice(0, -1));
-            setLastOperation("pop");
-        }
-    };
-
-    const executeOpcode = (opcodeName) => {
-        try {
-            const newStack = [...stack];
-            OP_CODE_FUNCTIONS[opcodeName](newStack);
-            setStack(newStack);
-            setLastOperation(opcodeName);
-        } catch (error) {
-            console.error("Error executing " + opcodeName + ":", error);
-            setLastOperation(opcodeName + " (failed)");
-        }
-    };
-
-    const getItemColor = (item) => {
-        if (item.toString().startsWith("Error:")) {
-            return "bg-red-500 text-white";
-        }
-        if (item.length === 1) {
-            const value = item[0];
-            if (value === 0x01) {
-                return "bg-green-500 text-white"; // Success (true)
-            } else if (value === 0x00) {
-                return "bg-red-500 text-white"; // Failure (false)
-            }
-        }
-        return "bg-purple-500 text-white"; // Default color
-    };
-
-    const formatStackItem = (item) => {
-        if (item.toString().startsWith("Error:")) {
-            return <span>{item.toString()}</span>;
-        }
-        if (item.length === 1) {
-            const value = item[0];
-            if (value === 0x01) {
-                return <span className="font-mono">true (0x01)</span>;
-            } else if (value === 0x00) {
-                return <span className="font-mono">false (0x00)</span>;
-            }
-        }
-        const hex = "0x" + item.toString('hex');
-        try {
-            const num = decodeNum(item);
-            return <span className="font-mono">{hex} ({num})</span>;
-        } catch {
-            return <span className="font-mono">{hex}</span>;
-        }
-    };
-
-    return (
-        <div className="w-full max-w-3xl mx-auto py-1">
-            <motion.div
-                className="bg-white dark:bg-gray-800 p-4 sm:p-6 rounded-lg text-sm sm:text-base shadow-md"
-                initial={{ opacity: 0, y: 20 }}
-                animate={{ opacity: 1, y: 0 }}
-                transition={{ duration: 0.5 }}
-            >
-                <div className="text-xl sm:text-2xl font-bold mb-4 text-gray-800 dark:text-white">
-                    Bitcoin Stack Evaluator
-                </div>
-
-                <div className="flex flex-col space-y-2 mb-4">
-                            <div className="relative w-full">
-                                <input
-                                    type="text"
-                                    value={input}
-                                    onChange={handleInputChange}
-                                    className="w-full px-3 py-2 border border-gray-300 rounded-md bg-gray-50 dark:bg-gray-700 text-gray-800 dark:text-white focus:outline-none focus:ring-2 focus:ring-orange-500"
-                                    placeholder="0x (enter hex value)"
-                                    onFocus={(e) => e.target.setSelectionRange(2, 2)}
-                                />
-                                <button
-                                    onClick={() => setShowHexInfo(!showHexInfo)}
-                                    className="absolute right-2 top-1/2 transform -translate-y-1/2 w-6 h-6 flex items-center justify-center text-gray-500 hover:text-gray-700 dark:text-gray-400 dark:hover:text-gray-300"
-                                >
-                                    <Info size={16} className="w-4 h-4" />
-                                </button>
-                            </div>
-                            <div className="flex space-x-2">
-                                <motion.button
-                                    onClick={push}
-                                    whileHover={{ scale: 1.05 }}
-                                    whileTap={{ scale: 0.95 }}
-                                    className="flex-1 px-4 py-2 bg-orange-500 text-white rounded-md hover:bg-orange-600 focus:outline-none focus:ring-2 focus:ring-orange-500 focus:ring-opacity-50"
-                                >
-                                    <ArrowDownCircle className="inline-block w-5 h-5 mr-1" />
-                                    Push
-                                </motion.button>
-                                <motion.button
-                                    onClick={pop}
-                                    whileHover={{ scale: 1.05 }}
-                                    whileTap={{ scale: 0.95 }}
-                                    className="flex-1 px-4 py-2 bg-gray-200 text-gray-800 rounded-md hover:bg-gray-300 focus:outline-none focus:ring-2 focus:ring-gray-400 focus:ring-opacity-50"
-                                >
-                                    <ArrowUpCircle className="inline-block w-5 h-5 mr-1" />
-                                    Pop
-                                </motion.button>
-                            </div>
-                        </div>
-
-                {showHexInfo && (
-                    <div className="mb-4 p-3 bg-blue-100 text-blue-800 rounded-md">
-                        <p className="text-sm">
-                            Enter values in hexadecimal format only (e.g., 0x01, 0xff).
-                            The '0x' prefix is fixed to indicate hex input.
-                            For arithmetic operations, the hex values will be interpreted as numbers.
-                        </p>
-                    </div>
-                )}
-
-                <div className="grid grid-cols-2 sm:grid-cols-3 md:grid-cols-4 lg:grid-cols-6 gap-2 mb-4">
-                    {Object.keys(OP_CODE_FUNCTIONS).map((opcodeName) => (
-                        <motion.button
-                            key={opcodeName}
-                            whileHover={{ scale: 1.05 }}
-                            whileTap={{ scale: 0.95 }}
-                            onClick={() => executeOpcode(opcodeName)}
-                            className="px-2 py-1 bg-gray-100 text-gray-800 rounded-md hover:bg-gray-200 focus:outline-none focus:ring-2 focus:ring-gray-400 focus:ring-opacity-50 text-sm w-full"
-                        >
-                            {opcodeName}
-                        </motion.button>
-                    ))}
-                </div>
-
-                <div className="border border-gray-300 rounded-md p-4 bg-gray-50 dark:bg-gray-700">
-                    <div className="font-semibold mb-2 text-gray-800 dark:text-white">
-                        Stack <span className="font-normal text-sm">(Last-In-First-Out)</span>:
-                    </div>
-                    <AnimatePresence>
-                        {stack.length === 0 ? (
-                            <motion.p
-                                initial={{ opacity: 0 }}
-                                animate={{ opacity: 1 }}
-                                exit={{ opacity: 0 }}
-                                className="text-gray-500 dark:text-gray-400 text-center py-2"
-                            >
-                                Stack is empty
-                            </motion.p>
-                        ) : (
-                            <div className="space-y-2">
-                                {stack.slice().reverse().map((item, index) => (
-                                    <motion.div
-                                        key={index + "-" + item.toString('hex')}
-                                        initial={{ opacity: 0, y: -20 }}
-                                        animate={{ opacity: 1, y: 0 }}
-                                        exit={{ opacity: 0, y: 20 }}
-                                        transition={{ duration: 0.2 }}
-                                        className={"p-2 rounded-md " + getItemColor(item) + " overflow-hidden"}
-                                    >
-                                        <div className="truncate">
-                                            {formatStackItem(item)}
-                                        </div>
-                                    </motion.div>
-                                ))}
-                            </div>
-                        )}
-                    </AnimatePresence>
-                </div>
-
-                {lastOperation && (
-                    <div className="mt-4 text-center text-gray-600 dark:text-gray-400">
-                        Last operation: {lastOperation}
-                    </div>
-                )}
-            </motion.div>
-        </div>
-    );
-
-};
-
-export default OpcodeSimulator`,
-        hidden: false
-      },
-      "/App.js": {
-        code: `
-import React from "react"
-import OpcodeSimulator from "./OpcodeSimulator"
-
-const App = () => {
-return (
-
-<div className="p-4">
-    <h1 className="text-2xl font-bold mb-4">Bitcoin Opcode Challenge</h1>
-    <OpcodeSimulator />
-</div>
-); };
-
-export default App;
-`,
-        hidden: false
-      }
-    },
-    options: {
-      externalResources: ['https://cdn.tailwindcss.com'],
-      showLineNumbers: true,
-      showInlineErrors: true,
-      editorHeight: 500
-    },
-    customSetup: {
-      dependencies: {
-        "react": "^18.0.0",
-        "react-dom": "^18.0.0",
-        "lucide-react": "^0.390.0",
-        "framer-motion": "^11.3.21",
-        "crypto-js": "^4.1.1"
-      },
-    }
-  }}
-  trinketUrl="https://trinket.io/embed/python3/12cf9af5968a"
-/>
-
-## Hints
-
-<Hint
-    title="Implementation Tips"
-    hints={[
-        "Use the provided encodeNum and decodeNum functions for OP_ADD",
-        "For OP_HASH160, use CryptoJS.SHA256 and CryptoJS.RIPEMD160",
-        "Remember to handle edge cases like insufficient stack items",
-        "The stack contains Buffer objects, not plain numbers"
-    ]}
-/>
-
-## Solution
-
-<ExpandableAlert
-  title="Solution Code"
-  type="solution"
-  expandable={true}
-  initialLines={0}
->
-```javascript
-export function OP_ADD(stack) {
-    if (stack.length < 2) throw new Error("Insufficient items for OP_ADD");
-    const b = decodeNum(stack.pop());
-    const a = decodeNum(stack.pop());
-    stack.push(encodeNum(a + b));
-}
-
-export function OP_HASH160(stack) {
-    if (stack.length < 1) throw new Error("Insufficient items for OP_HASH160");
-    const item = stack.pop();
-    const sha256 = CryptoJS.SHA256(CryptoJS.lib.WordArray.create(item));
-    const ripemd160 = CryptoJS.RIPEMD160(sha256);
-    stack.push(Buffer.from(ripemd160.toString(), 'hex'));
-}
-```
-
-</ExpandableAlert>
-
-Test your implementation using the Bitcoin Opcode Simulator above. Try various inputs to ensure your opcodes handle different scenarios correctly.