personal key – Command line generated deal with cannot get better with seed phrase, what am I lacking?

I’ve generated a bitcoin deal with utilizing the next instructions together with a ruby script for compression.

First I generate a key utilizing echo "24 phrase seed phrase BIP 39" | openssl sha256

Then run the beneath Ruby script to compress the important thing

# instance personal key
private_key = "personal key that has been generated with earlier command"

# --------------------------
# Secp256k1 Curve Parameters
# --------------------------
# y^2 = x^3 + ax + b
$a = 0
$b = 7 # utilizing world variables for comfort

# prime modulus
$p = 2 ** 256 - 2 ** 32 - 2 ** 9 - 2 ** 8 - 2 ** 7 - 2 ** 6 - 2 ** 4 - 1

# variety of factors on the curve
$n = 115792089237316195423570985008687907852837564279074904382605163141518161494337

# generator level (the place to begin on the curve used for all calculations)
$g = {
  x: 55066263022277343669578718895168534326250603453777594175500187360389116729240,
  y: 32670510020758816978083085130507043184471273380659243275938904335757337482424,
}

# --------------------------
# Elliptic Curve Arithmetic
# --------------------------
# Modular Inverse - Ruby would not have a built-in operate for locating modular inverses, so here is one utilizing the prolonged Euclidean algorithm.
def modinv(a, m = $p)
  a = a % m if a < 0 # be sure a is constructive
  prevy, y = 0, 1
  whereas a > 1
    q = m / a
    y, prevy = prevy - q * y, y
    a, m = m % a, a
  finish
  return y
finish

# Double - Add some extent on the curve to itself.
def double(level)
  # slope = (3x^2 + a) / 2y
  slope = ((3 * level[:x] ** 2) * modinv((2 * level[:y]))) % $p # utilizing modular inverse to carry out "division"

  # new x = slope^2 - 2x
  x = (slope ** 2 - (2 * level[:x])) % $p

  # new y = slope * (x - new x) * y
  y = (slope * (level[:x] - x) - level[:y]) % $p

  # return x, y coordinates of level
  return { x: x, y: y }
finish

# Add - Add two factors collectively.
def add(point1, point2)
  # double if each factors are the identical
  return double(point1) if point1 == point2

  # slope = (y1 - y2) / (x1 - x2)
  slope = ((point1[:y] - point2[:y]) * modinv(point1[:x] - point2[:x])) % $p

  # new x = slope^2 - x1 - x2
  x = (slope ** 2 - point1[:x] - point2[:x]) % $p

  # new y = slope * (x1 - new x) - y1
  y = ((slope * (point1[:x] - x)) - point1[:y]) % $p

  # return x, y coordinates of level
  return { x: x, y: y }
finish

# Multiply - Use the double and add operations to shortly multiply some extent by an integer (e.g. a non-public key).
def multiply(okay, level = $g) # multiply the generator level by default
  # create a replica the preliminary place to begin (to be used as well as afterward)
  present = level

  # convert integer to binary illustration (to be used within the double and add algorithm)
  binary = okay.to_s(2)

  # double and add algorithm for quick multiplication
  binary.break up("").drop(1).every do |char| # ignore first binary character
    # 0 = double
    present = double(present)

    # 1 = double and add
    if char == "1"
      present = add(present, level)
    finish
  finish

  # return the ultimate level
  return present
finish

# -------------------------
# Non-public Key To Public Key
# -------------------------
# convert personal key to an integer
okay = private_key.to_i(16)

# multiply generator level by this personal key
level = multiply(okay, $g) # this level is the general public key

# convert x and y values of this level to hexadecimal
x = level[:x].to_s(16).rjust(64, "0")
y = level[:y].to_s(16).rjust(64, "0")

# uncompressed public key format (not used a lot today, simply exhibiting the way it seems to be)
public_key_uncompressed = "04" + x + y

# compressed public key format (each x worth has a y that could possibly be certainly one of two doable factors)
if (level[:y] % 2 == 0)
  prefix = "02" # if y is even
else
  prefix = "03" # if y is odd
finish

public_key_compressed = prefix + x # solely makes use of the total x coordinate

# -------
# Outcomes
# -------
places private_key           #=> ef235aacf90d9f4aadd8c92e4b2562e1d9eb97f0df9ba3b508258739cb013db2
places public_key_compressed

Then hashing the important thing once more with
echo compressed key from ruby script | xxd -r -p | openssl sha256

Then echo hashed key | xxd -r -p | openssl ripemd160

And at last including 00 to the important thing
echo 00key | xxd -p -r | base58 -c && echo

The deal with I get is ready to receiving funds, however I am unable to get better utilizing the 24 phrase seed phrase utilizing BlueWallet import operate. What am I doing incorrect?

https://learnmeabitcoin.com/technical/public-key Hyperlink to Ruby Script

https://medium.com/coinmonks/how-to-generate-a-bitcoin-address-step-by-step-9d7fcbf1ad0b Hyperlink to Openssl Instructions