@btc-vision/btc-runtime 1.4.5 → 1.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.4.5",
+    "version": "1.4.7",
     "description": "Bitcoin Smart Contract Runtime",
     "main": "btc/index.ts",
     "scripts": {
@@ -43,7 +43,7 @@
     ],
     "dependencies": {
         "@assemblyscript/loader": "^0.27.30",
-        "@btc-vision/as-bignum": "^0.0.3",
+        "@btc-vision/as-bignum": "^0.0.4",
         "@eslint/js": "^9.10.0",
         "gulplog": "^2.2.0",
         "mocha": "^10.7.3",

package/runtime/buffer/BytesReader.ts

@@ -262,7 +262,7 @@ export class BytesReader {
     }
 
     public verifyEnd(size: i32): void {
-        if (this.currentOffset > this.buffer.byteLength) {
+        if (size > this.buffer.byteLength) {
             throw new Error(`Expected to read ${size} bytes but read ${this.currentOffset} bytes`);
         }
     }

package/runtime/contracts/DeployableOP_20.ts

@@ -19,6 +19,7 @@ import { OP_NET } from './OP_NET';
 import { sha256 } from '../env/global';
 import { ApproveStr, TransferFromStr, TransferStr } from '../shared-libraries/TransferHelper';
 
+const nonceMapPointer: u16 = Blockchain.nextPointer;
 const maxSupplyPointer: u16 = Blockchain.nextPointer;
 const decimalsPointer: u16 = Blockchain.nextPointer;
 const namePointer: u16 = Blockchain.nextPointer;
@@ -36,18 +37,20 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     protected readonly _name: StoredString;
     protected readonly _symbol: StoredString;
 
+    protected readonly _nonceMap: AddressMemoryMap<u256>;
+
     protected constructor(params: OP20InitParameters | null = null) {
         super();
 
+        // Initialize main storage structures
         this.allowanceMap = new MultiAddressMemoryMap<u256>(allowanceMapPointer, u256.Zero);
         this.balanceOfMap = new AddressMemoryMap<u256>(balanceOfMapPointer, u256.Zero);
         this._totalSupply = new StoredU256(totalSupplyPointer, u256.Zero, u256.Zero);
-
         this._maxSupply = new StoredU256(maxSupplyPointer, u256.Zero, u256.Zero);
         this._decimals = new StoredU256(decimalsPointer, u256.Zero, u256.Zero);
-
         this._name = new StoredString(namePointer, '');
         this._symbol = new StoredString(symbolPointer, '');
+        this._nonceMap = new AddressMemoryMap(nonceMapPointer, u256.Zero);
 
         if (params && this._maxSupply.value.isZero()) {
             this.instantiate(params, true);
@@ -62,25 +65,21 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
 
     public get maxSupply(): u256 {
         if (!this._maxSupply) throw new Revert('Max supply not set');
-
         return this._maxSupply.value;
     }
 
     public get decimals(): u8 {
         if (!this._decimals) throw new Revert('Decimals not set');
-
         return u8(this._decimals.value.toU32());
     }
 
     public get name(): string {
         if (!this._name) throw new Revert('Name not set');
-
         return this._name.value;
     }
 
     public get symbol(): string {
         if (!this._symbol) throw new Revert('Symbol not set');
-
         return this._symbol.value;
     }
 
@@ -104,52 +103,60 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     /** METHODS */
     public allowance(callData: Calldata): BytesWriter {
         const response = new BytesWriter(U256_BYTE_LENGTH);
-
         const resp = this._allowance(callData.readAddress(), callData.readAddress());
         response.writeU256(resp);
-
         return response;
     }
 
     public approve(callData: Calldata): BytesWriter {
-        // Define the owner and spender
         const owner = Blockchain.tx.sender;
         const spender: Address = callData.readAddress();
         const value = callData.readU256();
 
-        // Response buffer
-        const response = new BytesWriter(BOOLEAN_BYTE_LENGTH);
-
         const resp = this._approve(owner, spender, value);
-        response.writeBoolean(resp);
 
+        const response = new BytesWriter(BOOLEAN_BYTE_LENGTH);
+        response.writeBoolean(resp);
         return response;
     }
 
     public approveFrom(callData: Calldata): BytesWriter {
         const response = new BytesWriter(BOOLEAN_BYTE_LENGTH);
+
         const owner: Address = Blockchain.tx.origin;
         const spender: Address = callData.readAddress();
         const value: u256 = callData.readU256();
+        const nonce: u256 = callData.readU256();
 
         const signature = callData.readBytesWithLength();
         if (signature.length !== 64) {
             throw new Revert('Invalid signature length');
         }
 
-        const resp = this._approveFrom(owner, spender, value, signature);
+        const resp = this._approveFrom(owner, spender, value, nonce, signature);
         response.writeBoolean(resp);
 
         return response;
     }
 
+    /**
+     * Returns the current nonce for a given owner.
+     */
+    public nonceOf(callData: Calldata): BytesWriter {
+        const owner = callData.readAddress();
+        const currentNonce = this._nonceMap.get(owner);
+
+        const response = new BytesWriter(32);
+        response.writeU256(currentNonce);
+
+        return response;
+    }
+
     public balanceOf(callData: Calldata): BytesWriter {
         const response = new BytesWriter(U256_BYTE_LENGTH);
         const address: Address = callData.readAddress();
         const resp = this._balanceOf(address);
-
         response.writeU256(resp);
-
         return response;
     }
 
@@ -157,16 +164,13 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         const response = new BytesWriter(BOOLEAN_BYTE_LENGTH);
         const resp = this._burn(callData.readU256());
         response.writeBoolean(resp);
-
         return response;
     }
 
     public transfer(callData: Calldata): BytesWriter {
         const response = new BytesWriter(BOOLEAN_BYTE_LENGTH);
         const resp = this._transfer(callData.readAddress(), callData.readU256());
-
         response.writeBoolean(resp);
-
         return response;
     }
 
@@ -177,9 +181,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
             callData.readAddress(),
             callData.readU256(),
         );
-
         response.writeBoolean(resp);
-
         return response;
     }
 
@@ -211,7 +213,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
                 return this.allowance(calldata);
             case encodeSelector(ApproveStr):
                 return this.approve(calldata);
-            case encodeSelector('approveFrom(address,address,uint256,bytes)'):
+            case encodeSelector('approveFrom(address,uint256,uint64,bytes)'):
                 return this.approveFrom(calldata);
             case encodeSelector('balanceOf(address)'):
                 return this.balanceOf(calldata);
@@ -221,6 +223,10 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
                 return this.transfer(calldata);
             case encodeSelector(TransferFromStr):
                 return this.transferFrom(calldata);
+
+            case encodeSelector('nonceOf(address)'):
+                return this.nonceOf(calldata);
+
             default:
                 return super.execute(method, calldata);
         }
@@ -231,11 +237,16 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     /** REDEFINED METHODS */
     protected _allowance(owner: Address, spender: Address): u256 {
         const senderMap = this.allowanceMap.get(owner);
-
         return senderMap.get(spender);
     }
 
-    protected _approveFrom(owner: Address, spender: Address, value: u256, signature: Uint8Array): boolean {
+    protected _approveFrom(
+        owner: Address,
+        spender: Address,
+        value: u256,
+        nonce: u256,
+        signature: Uint8Array,
+    ): boolean {
         if (owner === Blockchain.DEAD_ADDRESS) {
             throw new Revert('Address can not be dead address');
         }
@@ -244,22 +255,36 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
             throw new Revert('Spender cannot be dead address');
         }
 
-        // Regenerate the hash
-        const writer = new BytesWriter(ADDRESS_BYTE_LENGTH * 2 + U256_BYTE_LENGTH);
+        // Ensure the nonce matches what we have stored on-chain
+        const storedNonce = this._nonceMap.get(owner);
+        if (!u256.eq(storedNonce, nonce)) {
+            throw new Revert('Invalid nonce (possible replay or out-of-sync)');
+        }
+
+        // Build the hash to match exactly what the user signed, including the nonce
+        const writer = new BytesWriter(
+            ADDRESS_BYTE_LENGTH * 2 + U256_BYTE_LENGTH + U256_BYTE_LENGTH,
+        );
+
         writer.writeAddress(owner);
         writer.writeAddress(spender);
         writer.writeU256(value);
+        writer.writeU256(nonce);
 
         const hash = sha256(writer.getBuffer());
         if (!Blockchain.verifySchnorrSignature(owner, signature, hash)) {
             throw new Revert('ApproveFrom: Invalid signature');
         }
 
+        // If valid, increment the nonce so this signature can't be reused
+        this._nonceMap.set(owner, SafeMath.add(storedNonce, u256.One));
+
+        // Update allowance
         const senderMap = this.allowanceMap.get(owner);
         senderMap.set(spender, value);
 
+        // Emit event
         this.createApproveEvent(owner, spender, value);
-
         return true;
     }
 
@@ -267,7 +292,6 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         if (owner === Blockchain.DEAD_ADDRESS) {
             throw new Revert('Address can not be dead address');
         }
-
         if (spender === Blockchain.DEAD_ADDRESS) {
             throw new Revert('Spender cannot be dead address');
         }
@@ -276,14 +300,11 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         senderMap.set(spender, value);
 
         this.createApproveEvent(owner, spender, value);
-
         return true;
     }
 
     protected _balanceOf(owner: Address): u256 {
-        const hasAddress = this.balanceOfMap.has(owner);
-        if (!hasAddress) return u256.Zero;
-
+        if (!this.balanceOfMap.has(owner)) return u256.Zero;
         return this.balanceOfMap.get(owner);
     }
 
@@ -293,7 +314,6 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         }
 
         if (onlyDeployer) this.onlyDeployer(Blockchain.tx.sender);
-
         if (this._totalSupply.value < value) throw new Revert(`Insufficient total supply.`);
         if (!this.balanceOfMap.has(Blockchain.tx.sender)) throw new Revert('No balance');
 
@@ -303,7 +323,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         const newBalance: u256 = SafeMath.sub(balance, value);
         this.balanceOfMap.set(Blockchain.tx.sender, newBalance);
 
-        // @ts-expect-error TODO: Fix the typing because this is valid assembly-script syntax
+        // @ts-expect-error This is valid AssemblyScript but can trip TS
         this._totalSupply -= value;
 
         this.createBurnEvent(value);
@@ -318,24 +338,20 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         } else {
             const toBalance: u256 = this.balanceOfMap.get(to);
             const newToBalance: u256 = SafeMath.add(toBalance, value);
-
             this.balanceOfMap.set(to, newToBalance);
         }
 
-        // @ts-expect-error TODO: Fix the typing because this is valid assembly-script syntax
+        // @ts-expect-error This is valid AssemblyScript but can trip TS
         this._totalSupply += value;
 
         if (this._totalSupply.value > this.maxSupply) throw new Revert('Max supply reached');
-
         this.createMintEvent(to, value);
         return true;
     }
 
     protected _transfer(to: Address, value: u256): boolean {
         const sender = Blockchain.tx.sender;
-
         if (this.isSelf(sender)) throw new Revert('Can not transfer from self account');
-
         if (u256.eq(value, u256.Zero)) {
             throw new Revert(`Cannot transfer 0 tokens`);
         }
@@ -348,10 +364,9 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
 
         const toBalance: u256 = this.balanceOfMap.get(to);
         const newToBalance: u256 = SafeMath.add(toBalance, value);
-
         this.balanceOfMap.set(to, newToBalance);
-        this.createTransferEvent(sender, to, value);
 
+        this.createTransferEvent(sender, to, value);
         return true;
     }
 
@@ -372,12 +387,10 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         } else {
             const toBalance: u256 = this.balanceOfMap.get(to);
             const newToBalance: u256 = SafeMath.add(toBalance, value);
-
             this.balanceOfMap.set(to, newToBalance);
         }
 
         this.createTransferEvent(from, to, value);
-
         return true;
     }
 
@@ -410,25 +423,21 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
 
     protected createBurnEvent(value: u256): void {
         const burnEvent = new BurnEvent(value);
-
         this.emitEvent(burnEvent);
     }
 
     protected createApproveEvent(owner: Address, spender: Address, value: u256): void {
         const approveEvent = new ApproveEvent(owner, spender, value);
-
         this.emitEvent(approveEvent);
     }
 
     protected createMintEvent(owner: Address, value: u256): void {
         const mintEvent = new MintEvent(owner, value);
-
         this.emitEvent(mintEvent);
     }
 
     protected createTransferEvent(from: Address, to: Address, value: u256): void {
         const transferEvent = new TransferEvent(from, to, value);
-
         this.emitEvent(transferEvent);
     }
 }

package/runtime/index.ts

@@ -45,7 +45,6 @@ export * from './math/abi';
 export * from './math/bytes';
 export * from './math/cyrb53';
 export * from './math/sha256';
-export * from './math/rnd';
 export * from './secp256k1/ECPoint';
 
 /** Memory */

package/runtime/math/bytes.ts

@@ -1,11 +1,20 @@
 import { u128, u256 } from '@btc-vision/as-bignum/assembly';
 
-export function bytes(number: u256[]): Uint8Array {
-    const result = new Uint8Array(32 * number.length);
-    for (let i: u8 = 0; i < 32; i++) {
-        const num: Uint8Array = number[31 - i].toUint8Array();
-        for (let j: u8 = 0; j < u8(number.length); j++) {
-            result[i + j * 32] = num[i];
+export function bytes(numbers: u256[]): Uint8Array {
+    const len = numbers.length;
+    const result = new Uint8Array(32 * len);
+
+    // Loop through the array in reverse order, so that the last element (index = len-1)
+    // becomes the first chunk in the output, and so on.
+    for (let i = 0; i < len; i++) {
+        // Reverse index to pick elements from the end
+        const rev = len - 1 - i;
+        const chunk: Uint8Array = numbers[rev].toUint8Array();
+
+        // Copy this 32-byte chunk into the output at offset i * 32.
+        const offset = i * 32;
+        for (let b: u32 = 0; b < 32; b++) {
+            result[offset + b] = chunk[b];
         }
     }
 
@@ -30,8 +39,13 @@ export function bytes8(number: Uint8Array): u64 {
 }
 
 export function bytes16(buffer: Uint8Array): u128 {
-    // Make sure that the buffer is 16 bytes long.
-    if (buffer.length !== 16) {
+    // Validate that the buffer is at least 16 bytes:
+    if (buffer.length < 16) {
+        throw new Error('bytes16: Buffer must be at least 16 bytes long');
+    }
+
+    // If it's larger than 16, slice it down:
+    if (buffer.length > 16) {
         buffer = buffer.slice(0, 16);
     }
 

package/runtime/secp256k1/ECPoint.ts

@@ -1,29 +1,37 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
 import { SafeMath } from '../types/SafeMath';
 
-// secp256k1 curve parameters (using little-endian byte arrays)
+// secp256k1 prime (little-endian): 0xFFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFF_FFFFFFFE_FFFFFC2F
 const P_BYTES: u8[] = [
-    0x2f, 0xfc, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-]; // P in little-endian
+    0x2f, 0xfc, 0xff, 0xff, 0xfe, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+];
 
+// Gx (little-endian) = 79BE667E...F81798 reversed
 const GX_BYTES: u8[] = [
-    0x98, 0x17, 0xf8, 0x16, 0xb1, 0x5b, 0x28, 0xd9, 0x59, 0x28, 0xce, 0x2d, 0xdb, 0xfc, 0x9b, 0x02,
-    0x70, 0xb0, 0x87, 0xce, 0x95, 0xa0, 0x62, 0x55, 0xac, 0xbb, 0xdc, 0xf9, 0xef, 0x66, 0xbe, 0x79,
-]; // Gx in little-endian
-
+    0x98, 0x17, 0xf8, 0x16, 0xb1, 0x5b, 0x28, 0xd9,
+    0x59, 0x28, 0xce, 0x2d, 0xdb, 0xfc, 0x9b, 0x02,
+    0x70, 0xb0, 0x87, 0xce, 0x95, 0xa0, 0x62, 0x55,
+    0xac, 0xbb, 0xdc, 0xf9, 0xef, 0x66, 0xbe, 0x79,
+];
+
+// Big-endian:  48 3A DA 77 26 A3 C4 65 5D A4 FB FC 0E 11 08 A8 FD 17 B4 48 A6 85 54 19 9C 47 D0 8F FB 10 D4 B8
+// Little-endian reversal:
 const GY_BYTES: u8[] = [
-    0xb8, 0xd4, 0x10, 0xfb, 0xff, 0x08, 0x7d, 0xc4, 0x19, 0x54, 0x85, 0xa6, 0x48, 0x44, 0x17, 0xfd,
-    0xa8, 0x08, 0xe1, 0x0e, 0xfc, 0x4b, 0xa4, 0x5d, 0x65, 0xc4, 0xa3, 0xa6, 0x77, 0xda, 0x3a, 0x48,
-]; // Gy in little-endian
-
-// Converting byte arrays to u256 using fromBytesLe (little-endian)
-const P = u256.fromBytesLE(P_BYTES);
-const GX = u256.fromBytesLE(GX_BYTES);
-const GY = u256.fromBytesLE(GY_BYTES);
-
-// Define a point on the elliptic curve
-class ECPoint {
+    0xb8, 0xd4, 0x10, 0xfb, 0x8f, 0xd0, 0x47, 0x9c,
+    0x19, 0x54, 0x85, 0xa6, 0x48, 0xb4, 0x17, 0xfd,
+    0xa8, 0x08, 0x11, 0x0e, 0xfc, 0xfb, 0xa4, 0x5d,
+    0x65, 0xc4, 0xa3, 0x26, 0x77, 0xda, 0x3a, 0x48,
+];
+
+export const P = u256.fromBytesLE(P_BYTES);
+export const GX = u256.fromBytesLE(GX_BYTES);
+export const GY = u256.fromBytesLE(GY_BYTES);
+
+// Representing a point (x, y) on secp256k1
+export class ECPoint {
     x: u256;
     y: u256;
 
@@ -32,90 +40,110 @@ class ECPoint {
         this.y = y;
     }
 
-    // Point doubling: P + P = 2P
+    // ----------------------------
+    // Point Doubling: 2P = P + P
+    // (for y^2 = x^3 + 7 with a=0)
+    // λ = (3*x^2) / (2*y) mod P
+    // x3 = λ^2 - 2x mod P
+    // y3 = λ*(x - x3) - y mod P
+    // ----------------------------
     static double(p: ECPoint): ECPoint {
+        // If y=0, return infinity
         if (p.y == u256.Zero) {
-            return new ECPoint(u256.Zero, u256.Zero); // Point at infinity
+            return new ECPoint(u256.Zero, u256.Zero); // "Point at infinity" convention
         }
 
         const two = u256.fromU64(2);
         const three = u256.fromU64(3);
 
-        // lambda = (3 * p.x^2) / (2 * p.y) mod P
-        const numerator = SafeMath.mod(SafeMath.mul(three, SafeMath.pow(p.x, two)), P);
-        const denominator = SafeMath.modInverse(SafeMath.mul(two, p.y), P);
-        const lambda = SafeMath.mod(SafeMath.mul(numerator, denominator), P);
+        // numerator = 3*x^2 mod P
+        const xSquared = SafeMath.pow(p.x, two);
+        const numerator = SafeMath.mod(SafeMath.mul(three, xSquared), P);
 
-        // xr = lambda^2 - 2 * p.x mod P
-        const xr = SafeMath.mod(SafeMath.sub(SafeMath.pow(lambda, two), SafeMath.mul(two, p.x)), P);
+        // denominator = (2*y)^-1 mod P
+        const twoY = SafeMath.mul(two, p.y);
+        const denominatorInv = SafeMath.modInverse(twoY, P);
 
-        // yr = lambda * (p.x - xr) - p.y mod P
-        const yr = SafeMath.mod(SafeMath.sub(SafeMath.mul(lambda, SafeMath.sub(p.x, xr)), p.y), P);
+        // λ = numerator * denominator^-1 mod P
+        const lambda = SafeMath.mod(SafeMath.mul(numerator, denominatorInv), P);
+
+        // xr = λ^2 - 2x mod P
+        const lambdaSquared = SafeMath.pow(lambda, two);
+        const twoX = SafeMath.mul(two, p.x);
+        const xr = SafeMath.mod(SafeMath.sub(lambdaSquared, twoX), P);
+
+        // yr = λ*(x - xr) - y mod P
+        const xMinusXr = SafeMath.sub(p.x, xr);
+        const lambdaTimesXDiff = SafeMath.mul(lambda, xMinusXr);
+        const yr = SafeMath.mod(SafeMath.sub(lambdaTimesXDiff, p.y), P);
 
         return new ECPoint(xr, yr);
     }
 
-    // Point addition: P + Q = R
+    // ----------------------------
+    // Point Addition: R = P + Q
+    // λ = (y2 - y1) / (x2 - x1) mod P
+    // x3 = λ^2 - x1 - x2 mod P
+    // y3 = λ*(x1 - x3) - y1 mod P
+    // ----------------------------
     static add(p: ECPoint, q: ECPoint): ECPoint {
+        // 1) Check for infinity cases
+        const isPInfinity = p.x.isZero() && p.y.isZero();
+        const isQInfinity = q.x.isZero() && q.y.isZero();
+
+        if (isPInfinity) return q; // ∞ + Q = Q
+        if (isQInfinity) return p; // P + ∞ = P
+
+        // 2) Check if P == Q => doubling
         if (p.x == q.x && p.y == q.y) {
-            return this.double(p); // If P == Q, perform doubling
+            return ECPoint.double(p);
+        }
+
+        // 3) Check if P == -Q => return infinity
+        // (x1 == x2, but y1 != y2 => P + Q = ∞)
+        if (p.x == q.x && p.y != q.y) {
+            return new ECPoint(u256.Zero, u256.Zero);
         }
 
-        const lambda = SafeMath.mod(
-            SafeMath.mul(SafeMath.sub(q.y, p.y), SafeMath.modInverse(SafeMath.sub(q.x, p.x), P)),
-            P,
-        );
-        const xr = SafeMath.mod(
-            SafeMath.sub(SafeMath.pow(lambda, u256.fromU64(2)), SafeMath.add(p.x, q.x)),
-            P,
-        );
-        const yr = SafeMath.mod(SafeMath.sub(SafeMath.mul(lambda, SafeMath.sub(p.x, xr)), p.y), P);
+        const numerator = SafeMath.sub(q.y, p.y);
+        const denominator = SafeMath.sub(q.x, p.x);
+        const denominatorInv = SafeMath.modInverse(denominator, P);
+        const lambda = SafeMath.mod(SafeMath.mul(numerator, denominatorInv), P);
+
+        // x3 = λ^2 - (x1 + x2) mod P
+        const lambdaSq = SafeMath.pow(lambda, u256.fromU64(2));
+        let xr = SafeMath.sub(lambdaSq, SafeMath.add(p.x, q.x));
+        xr = SafeMath.mod(xr, P);
+
+        // y3 = λ*(x1 - x3) - y1 mod P
+        const xDiff = SafeMath.sub(p.x, xr);
+        let yr = SafeMath.mul(lambda, xDiff);
+        yr = SafeMath.sub(yr, p.y);
+        yr = SafeMath.mod(yr, P);
 
         return new ECPoint(xr, yr);
     }
 
-    // Scalar multiplication: k * P
+    // ----------------------------
+    // Scalar Multiplication: k*P
+    // Double-and-add approach
+    // ----------------------------
     static scalarMultiply(p: ECPoint, k: u256): ECPoint {
-        let result = new ECPoint(u256.Zero, u256.Zero); // Point at infinity
+        let result = new ECPoint(u256.Zero, u256.Zero); // ∞
         let addend = p;
+        const two = u256.fromU64(2);
 
+        // While k != 0
         while (!k.isZero()) {
+            // If k is odd => add
             if (!SafeMath.isEven(k)) {
-                result = this.add(result, addend);
+                result = ECPoint.add(result, addend);
             }
-            addend = this.double(addend);
-            k = SafeMath.div(k, u256.fromU64(2)); // Right shift by 1
+            // Double the point
+            addend = ECPoint.double(addend);
+            // "Divide" k by 2 => shift right by 1
+            k = SafeMath.div(k, two);
         }
-
         return result;
     }
 }
-
-// Generate a valid elliptic curve point (public key) from a hash
-export function generatePublicKeyFromHash(scalar: u256): u8[] {
-    // Convert hash to u256 scalar
-    //const scalar = u256.fromBytes(hash);
-
-    // Define the generator point on secp256k1 curve
-    const G = new ECPoint(GX, GY);
-
-    // Perform scalar multiplication to get public key point
-    const publicKeyPoint = ECPoint.scalarMultiply(G, scalar);
-
-    // Convert the point to bytes (compressed format)
-    return pointToBytes(publicKeyPoint);
-}
-
-// Convert elliptic curve point to compressed byte array
-function pointToBytes(point: ECPoint): u8[] {
-    const prefix: u8 = SafeMath.isEven(point.y) ? 0x02 : 0x03; // Compressed format prefix
-    const xBytes = point.x.toUint8Array(); // Convert X coordinate to bytes
-
-    const result = new Array<u8>(33); // 1 byte prefix + 32 bytes X coordinate
-    result[0] = prefix;
-    for (let i = 0; i < 32; i++) {
-        result[i + 1] = xBytes[i];
-    }
-
-    return result;
-}