Let's write the calculations on the Curve first. Define a new module. I see CP 256 K1 create a new file. We will use the ru-256 type we defined in the last video for the out and double algorithm. Import the bytes library so we can turn a number into a binary sequence. Before we define the curve itself, let's define a point. The points on an elliptic curve is a two-dimensional object point. Both coordinates will be Ru of the ru-256 type. Let's first define some utility functions. All right, I defined the from string and tostring utilities. For the from string utility, I chose to take two coordinates separately so to indicate that we're manipulating, we're constructing a two-dimensional object. The is zero point utility will determine if the point itself is the identity element. The identity element for addition on the elliptic curve is imaginary, it's in the infinity. We're using the zero zero point to denote this point. However, this point itself is not on the Curve. For operations related to the identity element, you need to check.

if it's a zero point at the start starting point of an operation. Now that the point struct is defined, let's define the actual curve. I'm going to get the specification for this curve from standards for efficient cryptography group. Here are the specific parameters recommended for the specific curves. Here I will find secp 256k1 right here. As you can see, these are the parameters. So I will write public struct SECU 256q1 and implement first. Define the constants. The G function is the generator on the Curve, the base Point G. As you can see here, we will use the uncompressed form to import these coordinates to construct the basis point G. The number n is the order of this point on the Curve and is right here. Okay, that's all the constants defined. We've also defined the zero point. This identity point will be used in our double and add algorithm as the basis point. Now that we've defined the constants, let's define the actual operations. There are only two operations at point and double a point. Before the implementation, it's a good

idea to add unit tests here. I've imported the two unit tests prefixed with secp 256k1. Let's run them: cargo test secp 256k1. As you can see, both functions are not even defined. Let me for now just return the zero point. For now, let's run the tests again to fail the tests as expected. Now let's implement the actual calculation for points addition. First of all, you want to ascertain that these two points are different. If they are the same and you're trying to calculate the slope, you will have a division by zero error. To avoid that, search this. This will prevent the division by zero. Then, if any of the points are the identity point, the zero point in the infinity by Theory, then we will return the other point. Any point added with the identity is the point itself. Okay, after that, let's get the prime value for the underlying Prime field. Let this is from the constant that we just defined above there. Then we simply start writing down the exact formula that I've shown you on the

PowerPoint. As you can see, we first calculate the Y difference. Then we calculate the X difference. Lambda, denoting the slope, is derived by dividing the Y difference by the X difference. Very straightforward. Add a comment to your slope or calculation. The resulting X coordinate is also very straightforward. Lambda multiplied with itself, Lambda squared, minus Sub sub with modulo, minus the X value of the first point, and also the X value for the second point. Then the Y coordinate is simply calculated as first you subtract X3 from X1, the X value for point, the for the first point. You multiply the result by Lambda and subtract the whole result by the Y value for the first point. That's all. All right, that is done. You simply return the endpoint as a result. Let's test this out. Cargo test. Okay, as you can see, one of the tests is now passing at points. The addition is now defined. By the way, I added unit tests for the two operations: adding the point and doubling a point. For the end result, we will write an

integration test against an actual production library to ascertain that our implementation evaluates to the same point from a private key as the production library. Now, let's write the double point doubling algorithm. As always, first to check if the point input is a zero point. If it's a zero point, if you double a zero point, it will give zero again. It will still be the identity, so you clone the zero point and return that. Next, we want to check if the Y value is zero. If the Y value is zero, it suggests that the point is actually the leftmost point tangent to the curve itself. If you draw a tangent line through this point, it will be completely vertical, shooting towards infinity. In that case, doubling this point will actually result in an imaginary intersection, which is the zero point identity. In that case, we will return the zero point identity right here as expected. Alright, like the addition case, first grab the p-value, the prime value, then I'll also define two constants, the formula we'll use. These are simply constant values 2 and

3. Wrapped around in the ru-256 struct so we can write the formula with them first. Calculate the slope. All right, done exactly as described. You calculate the 2y and also the numerator. Then you simply perform the division between them to get the final slope. Luckily, I just realized I don't have to rise this by hand. I can just copy it. Once you have the Lambda, the rest is quite simple. The main difference between calculating the addition between two different points and doubling a single point is the Lambda formula, the formula for the slope. Once you have the slope, you can say X3 is equal to Lambda multiplied Lambda squared 0.1. In this case, there's no point 1.2, it's just the point, and for Y3, the x value for the point and multiply it with the Y value for the point. Delete this line and you have it. That's the result. Let's test it. Cargo test CCP K1. All right, both tests pass. The two operations, adding two different points on a curve and also doubling a single

point both of these operations are now implemented. Now that point addition and doubling are both defined, let's define the final utility for these two operations, which is to derive the public key from a single scalar, which is 256 bits. Public function private to public. Now, just like the multiplication when we defined multiplication and exponentiation for the ru-256 struct, we will again use the ADD and double algorithm. In this case, the base operation is addition, so the algorithm will be called add and double. First, you want a sequence of bytes converted into a binary sequence. Use that binary sequence as a flag to add or double the base point to get to the final result. Okay, now we have the binary sequence. Let's define the base point and the adder. The adder is the generator generator Point specified in the documentation right here. This is the point we will perform add and double operation on. This Loop is almost exactly as you've seen it before. Depending on the binary sequence that's coming in, you will double and add points to the base point. The implementation that we just wrote is

not very performant, but it's very understandable. It's clear as daylight. It is very slow, so as the calculation progresses, let's print out something, the specific steps, so you can see the exact adding and doubling that's happening. All right, let's also instruct the program to print out the doubling and addition operation, so you can see the specific operations that are happening as we run the program. All right, now that the Curve library is completely implemented, before we write the integration test, let's write some trial logic in the main function. In the end, what we want is a binary file that can be used offline to generate wallet addresses. It doesn't hurt to write some trial logic in a main function for now, and we can see how exactly the algorithm runs. First of all, you need a private key, that private number. This is a 256 bits number, which we will write in 64 characters of hexadecimals. Then, oh, by the way, before we do that, import the relevant libraries. Use wallet.

cryptography imports the 256-bit struct to be defined and also the curve imports all of them so we can also use the point struct that's a private number. We will generate this private number. I will show you in a moment. Let public key be equal to secp this curve to public and passing and passing an ru-256. Okay, now we have our public key. Let's print it out. Print to hex string is what's defined on the point object. Now let's generate the random number that we're going to use for the private key. I found this website random.org, and one of the utilities is generating random colors. A hexadecimal color is six hex characters denoting three bytes. We need 32 bytes; therefore, I will generate 11 colors and take the 32 bytes that I need. Alright, we have our number. Let's put it right here. That's our private key. And let's run this cargo run and create CPU. What's the error? Are you parse error? Okay, this is pretty dumb. I encoded my base point constant for the curve around.

I didn't even notice I was so nervous that I didn't even notice that they are of different lengths. So let's do that again. The first coordinate, the x-coordinate, is all the way from seven nine all the way down to seven nine eight. The second coordinate is all the way from 483a to D4 B8. And let's clean this up again. All right, by the way, I also need to take off a byte from the input. I generated 33 bytes, and I only need 32. All right, let's do this. Cargo run. Okay, it's working. You can see that depending on the byte, on depending on in bit, it's doing the adding and the doubling. You can expect a result when the step reaches 256. As you can see, this is pretty slow, so I'll use this opportunity to introduce you to the production Library. The production Library we're going to use is called secp 256k1, written around this C library made by Peter Willa. He works for Bitcoin core and is quite

instrumental in the development of Bitcoin infrastructure. This library is C optimized and also contains some assembly code. I believe the Rust crate is a thin wrapper around that utility and is very fast as well. You can see that there are examples which we will use to construct this is the production library that we're going to use to construct the final binary, and we will use it to write the integration test. We will compare the point generation from our program to the point generation from this crate to make sure that our implementation is the same. It's just that it's not optimized on a low level. All right, we can see that it gave us a result, a result, and that's the two coordinates which we will compare to the production Library. I hope that it's going to be correct. I'm doing this live. I never seen this private key number before, and it will be a lot of trouble if this turns out to be different from the production. I also have my draft code on the side to help me, but uh, all right, let's import, let's

import the production Library sccp 256k1. The latest version is 0.26.0. Okay, CCP 256k1, zero point was the version 26.0. Okay, cargo build, and we're going to use what's the example. The example is right here, so we want these utilities, secpu 256. Okay, secret key, public key, or let's comment these out. Remember, this is the point that we're going after. Let's retain this secret key number. This is a private key, that's right. Let's first define a new curve one, create a new curve instance. Let private key, this library is optimized. It has strong, strong types, that's that are associated with this crate, specifically in this case. We only have a string, but to use the utilities in this crate, we need to convert it to this type called secret key from string. Fortunately, it implements the implements the from string trait. PRN expect private key conversion. Okay, the conversion is successful. Let's convert it to the public key now. Public key is equal to public key from secret key. Give

it the curve itself and also the private key. Both of these should be passed in as reference, and in the end, we will say um encode bytes. All right, I also need to write a base 16. Let's write the base 16 conversion library page 16 rust. We imported the hex Library, so the rest is quite simple. Oh, by the way, public Mars and base 16. There are too many libraries dealing with base 16. That's called X or hexadecimal. In this case, we will call it base 16 to avoid ambiguity. Use tax two functions. The first functional utility converts a string into bytes. The second one encodes bytes back into a hexadecimal string. Very straightforward. Let's import it. Use water cryptography base 16. Return base 16 in code bytes. This serialization function will give us a bunch of bunch of bytes. It won't be readable lies uncompressed. Uncompressed means you will get both of both of the coordinates expect to type string. Oh, I want to print it out. I don't want to return it.

I want to print out the result, not to return it to the Ming function. All right, so we have the same private key. We are generating the public key using the production library, and we are printing out the final result by serializing the uncompressed points. I hope that this will give the correct point. All right, cargo run. All right, as you can see, the prefix 0 4 denotes that this is an uncompressed concatenation between X and Y value. And if I can see F1 fbf99 F1 FB f99, the x value ends with 4 f c 1 8 for fc18. I can see right here the Y value starts with 614 a3c6143c and ends with c76b c76b. Okay, so what we have written, the library, the curve, like the elliptic curve cryptography calculations that we have defined, yields the exact same result from this as it is production Library, the formula. There's a lot of encapsulation happening with these very Advanced crates dealing with elliptic curve cryptography, a lot.

of the complexity underlying complexity is abstracted away from a very simple interface. But if you really want to know under the hood, it's nothing very difficult. It's just mathematical formulas to define the curve operation, current arithmetics, point arithmetics on a curve, and what they are doing is exactly what I have just defined for you right here. All right, that's all for this episode. We will forget about the curve library we've defined for now because it's very slow. In the starting from the next section, we will use the production library to finish defining the binary, which means not only generating the public key but also push it through a bunch of hashing conventions to get to the final address for both Bitcoin and Ethereum. All right, see you there. I was so excited that the program works that I forgot to show you the integration test here. I've moved the logic from the main file to an integration test called ECC. Here you can see instead of hard coding a random private key, I've delegated the test to the task to the rent crate.

which was added right here. First, I generate an array filled with 32 zeros. Then, I instruct the Rand generator to map each zero to an integer from 0 to 255. And in the end, I encoded using the hex crate to create the final private key. Afterwards, I use the two methods to generate the public key and compare them in the end. To make the comparison easier, I've modified the two hex string utility on the point struct. Now, I prefix it with zero four, indicating that this string is an uncompressed concatenation between the X and Y coordinates. I also removed the space between them. In addition, I added all of the comments for the curve implementation, including the formulas rationale. You can always find these nodes in the source code, just follow the GitHub link. Alright, let's run this test cargo test ECC. This will take quite a while. The last time I run it, it took about 150. Um, oh, because I have the ignore flag on. Alright, you can see the it's showing that the test is running. It will take out take a while. Okay, the

test has succeeded, and it shows. Okay, let's turn on the ignore flag again so we don't have to run this test again. All right, that's all for the elliptic curve cryptography. Starting next episode, we will use the production library only to continue writing the Bitcoin and Ethereum address derivation logics. All right, see you there.

[BTC/ETH, Ep. 3] Implementing ECC with Secp256K1 Curve Standardization and Point Operations

[BTC/ETH, Ep. 3] Implementing ECC with Secp256K1 Curve Standardization and Point Operations