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 non-public key
private_key = "non-public key that has been generated with earlier command"
# --------------------------
# Secp256k1 Curve Parameters
# --------------------------
# y^2 = x^3 + ax + b
$a = 0
$b = 7 # utilizing international 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 start line 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 # ensure that a is optimistic
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(ok, level = $g) # multiply the generator level by default
# create a duplicate the preliminary place to begin (to be used as well as in a while)
present = level
# convert integer to binary illustration (to be used within the double and add algorithm)
binary = ok.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
# -------------------------
# Personal Key To Public Key
# -------------------------
# convert non-public key to an integer
ok = private_key.to_i(16)
# multiply generator level by this non-public key
level = multiply(ok, $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 as of late, simply exhibiting the way it seems)
public_key_uncompressed = "04" + x + y
# compressed public key format (each x worth has a y that might be considered one of two attainable 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 complete 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 can not get better utilizing the 24 phrase seed phrase utilizing BlueWallet import operate. What am I doing mistaken?

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