@btc-vision/btc-runtime 1.2.6 → 1.3.0

package/runtime/memory/MultiAddressMemoryMap.ts

@@ -1,13 +1,13 @@
 import { MemorySlotData } from './MemorySlot';
 import { u256 } from 'as-bignum/assembly';
-import { KeyMerger } from './KeyMerger';
+import { Uint8ArrayMerger } from './Uint8ArrayMerger';
 
 @final
 export class MultiAddressMemoryMap<
-    K extends string,
-    K2 extends string,
+    K extends Uint8Array,
+    K2 extends Uint8Array,
     V extends MemorySlotData<u256>,
-> extends Map<K, KeyMerger<K, K2, V>> {
+> extends Map<K, Uint8ArrayMerger<V>> {
     public pointer: u16;
 
     constructor(
@@ -19,7 +19,7 @@ export class MultiAddressMemoryMap<
         this.pointer = pointer;
     }
 
-    public get(key: K): KeyMerger<K, K2, V> {
+    public get(key: K): Uint8ArrayMerger<V> {
         this.createKeyMerger(key);
 
         return super.get(key);
@@ -36,7 +36,7 @@ export class MultiAddressMemoryMap<
         return this;
     }
 
-    public set(key: K, value: KeyMerger<K, K2, V>): this {
+    public set(key: K, value: Uint8ArrayMerger<V>): this {
         this.createKeyMerger(key);
 
         return <this>super.set(key, value);
@@ -56,7 +56,7 @@ export class MultiAddressMemoryMap<
 
     private createKeyMerger(key: K): void {
         if (!super.has(key)) {
-            super.set(key, new KeyMerger<K, K2, V>(key, this.pointer, this.defaultValue));
+            super.set(key, new Uint8ArrayMerger<V>(key, this.pointer, this.defaultValue));
         }
     }
 }

package/runtime/memory/MultiStringMemoryMap.ts

@@ -0,0 +1,62 @@
+import { MemorySlotData } from './MemorySlot';
+import { u256 } from 'as-bignum/assembly';
+import { KeyMerger } from './KeyMerger';
+
+@final
+export class MultiStringMemoryMap<
+    K extends string,
+    K2 extends string,
+    V extends MemorySlotData<u256>,
+> extends Map<K, KeyMerger<K, K2, V>> {
+    public pointer: u16;
+
+    constructor(
+        pointer: u16,
+        private readonly defaultValue: V,
+    ) {
+        super();
+
+        this.pointer = pointer;
+    }
+
+    public get(key: K): KeyMerger<K, K2, V> {
+        this.createKeyMerger(key);
+
+        return super.get(key);
+    }
+
+    public setUpperKey(key: K, key2: K2, value: V): this {
+        this.createKeyMerger(key);
+
+        const subMap = super.get(key);
+        if (subMap) {
+            subMap.set(key2, value);
+        }
+
+        return this;
+    }
+
+    public set(key: K, value: KeyMerger<K, K2, V>): this {
+        this.createKeyMerger(key);
+
+        return <this>super.set(key, value);
+    }
+
+    public has(key: K): bool {
+        return super.has(key);
+    }
+
+    public delete(key: K): bool {
+        return super.delete(key);
+    }
+
+    public clear(): void {
+        super.clear();
+    }
+
+    private createKeyMerger(key: K): void {
+        if (!super.has(key)) {
+            super.set(key, new KeyMerger<K, K2, V>(key, this.pointer, this.defaultValue));
+        }
+    }
+}

package/runtime/memory/StringMemoryMap.ts

@@ -0,0 +1,57 @@
+import { MemorySlotPointer } from './MemorySlotPointer';
+import { Blockchain } from '../env';
+import { encodePointer } from '../math/abi';
+import { MemorySlotData } from './MemorySlot';
+import { u256 } from 'as-bignum/assembly';
+import { BytesWriter } from '../buffer/BytesWriter';
+
+@final
+export class StringMemoryMap<K extends string, V extends MemorySlotData<u256>> {
+    public pointer: u16;
+
+    constructor(
+        pointer: u16,
+        private readonly defaultValue: V,
+    ) {
+        this.pointer = pointer;
+    }
+
+    public set(key: K, value: V): this {
+        const keyHash: MemorySlotPointer = this.encodePointer(key);
+        Blockchain.setStorageAt(keyHash, value);
+
+        return this;
+    }
+
+    public get(key: K): MemorySlotData<u256> {
+        const keyHash: MemorySlotPointer = this.encodePointer(key);
+
+        return Blockchain.getStorageAt(keyHash, this.defaultValue);
+    }
+
+    public has(key: K): bool {
+        const keyHash: MemorySlotPointer = this.encodePointer(key);
+
+        return Blockchain.hasStorageAt(keyHash);
+    }
+
+    @unsafe
+    public delete(key: K): bool {
+        this.set(key, this.defaultValue);
+
+        return true;
+    }
+
+    @unsafe
+    public clear(): void {
+        throw new Error('Method not implemented.');
+    }
+
+    private encodePointer(key: K): MemorySlotPointer {
+        const writer = new BytesWriter(key.length + 2);
+        writer.writeU16(this.pointer);
+        writer.writeString(key);
+
+        return encodePointer(writer.getBuffer());
+    }
+}

package/runtime/memory/Uint8ArrayMerger.ts

@@ -0,0 +1,67 @@
+import { MemorySlotData } from './MemorySlot';
+import { u256 } from 'as-bignum/assembly';
+import { Blockchain } from '../env';
+import { MemorySlotPointer } from './MemorySlotPointer';
+import { encodePointer } from '../math/abi';
+import { BytesWriter } from '../buffer/BytesWriter';
+
+@final
+export class Uint8ArrayMerger<V extends MemorySlotData<u256>> {
+    public parentKey: Uint8Array;
+
+    public pointer: u16;
+
+    constructor(
+        parent: Uint8Array,
+        pointer: u16,
+        private readonly defaultValue: V,
+    ) {
+        this.pointer = pointer;
+
+        this.parentKey = parent;
+    }
+
+    public set(key: Uint8Array, value: V): this {
+        const keyHash: MemorySlotPointer = this.getKeyHash(key);
+        Blockchain.setStorageAt(keyHash, value);
+
+        return this;
+    }
+
+    public get(key: Uint8Array): MemorySlotData<u256> {
+        const keyHash: MemorySlotPointer = this.getKeyHash(key);
+
+        return Blockchain.getStorageAt(keyHash, this.defaultValue);
+    }
+
+    public has(key: Uint8Array): bool {
+        const mergedKey: MemorySlotPointer = this.getKeyHash(key);
+
+        return Blockchain.hasStorageAt(mergedKey);
+    }
+
+    @unsafe
+    public delete(_key: Uint8Array): bool {
+        throw new Error('Method not implemented.');
+    }
+
+    @unsafe
+    public clear(): void {
+        throw new Error('Clear method not implemented.');
+    }
+
+    private getKeyHash(key: Uint8Array): MemorySlotPointer {
+        const writer: BytesWriter = new BytesWriter(key.byteLength + 2 + this.parentKey.byteLength);
+
+        writer.writeBytes(this.parentKey);
+        writer.writeBytes(key);
+
+        return this.encodePointer(writer);
+    }
+
+    private encodePointer(writer: BytesWriter): MemorySlotPointer {
+        writer.writeU16(this.pointer);
+
+        return encodePointer(writer.getBuffer());
+    }
+}

package/runtime/secp256k1/ECPoint.ts

@@ -0,0 +1,121 @@
+import { u256 } from 'as-bignum/assembly';
+import { SafeMath } from '../types/SafeMath';
+
+// secp256k1 curve parameters (using little-endian byte arrays)
+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
+
+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
+
+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 {
+    x: u256;
+    y: u256;
+
+    constructor(x: u256, y: u256) {
+        this.x = x;
+        this.y = y;
+    }
+
+    // Point doubling: P + P = 2P
+    static double(p: ECPoint): ECPoint {
+        if (p.y == u256.Zero) {
+            return new ECPoint(u256.Zero, u256.Zero); // Point at infinity
+        }
+
+        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);
+
+        // xr = lambda^2 - 2 * p.x mod P
+        const xr = SafeMath.mod(SafeMath.sub(SafeMath.pow(lambda, two), SafeMath.mul(two, p.x)), 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);
+
+        return new ECPoint(xr, yr);
+    }
+
+    // Point addition: P + Q = R
+    static add(p: ECPoint, q: ECPoint): ECPoint {
+        if (p.x == q.x && p.y == q.y) {
+            return this.double(p); // If P == Q, perform doubling
+        }
+
+        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);
+
+        return new ECPoint(xr, yr);
+    }
+
+    // Scalar multiplication: k * P
+    static scalarMultiply(p: ECPoint, k: u256): ECPoint {
+        let result = new ECPoint(u256.Zero, u256.Zero); // Point at infinity
+        let addend = p;
+
+        while (!k.isZero()) {
+            if (!SafeMath.isEven(k)) {
+                result = this.add(result, addend);
+            }
+            addend = this.double(addend);
+            k = SafeMath.div(k, u256.fromU64(2)); // Right shift by 1
+        }
+
+        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;
+}

package/runtime/storage/StorageBacked.ts

@@ -0,0 +1,5 @@
+import { u256 } from 'as-bignum/assembly';
+
+export interface StorageBacked {
+    serialize(): Array<u256>;
+}

package/runtime/storage/StorageLayout.ts

@@ -0,0 +1,7 @@
+import { Blockchain } from '../env';
+
+export class StorageLayout {
+    public next(): u16 {
+        return Blockchain.nextPointer;
+    }
+}

package/runtime/storage/StorageSlot.ts

@@ -0,0 +1,106 @@
+import { u256 } from 'as-bignum/assembly';
+import { BlockchainEnvironment } from '../env/BlockchainEnvironment';
+import { Sha256 } from '../math/sha256';
+import { MemorySlotPointer } from '../memory/MemorySlotPointer';
+import { Box, concat, fromArrayBuffer, toArrayBuffer } from '../utils';
+
+export function toBuffer<T>(v: T): ArrayBuffer {
+    const result = new ArrayBuffer(sizeof<T>());
+    store<T>(changetype<usize>(result), v);
+    return result;
+}
+
+export class StorageSlot {
+    public pointer: u16;
+    public subPointer: MemorySlotPointer;
+
+    constructor(pointer: u16, subPointer: MemorySlotPointer) {
+        this.pointer = pointer;
+        this.subPointer = subPointer;
+    }
+
+    public get pointerHash(): u256 {
+        return fromArrayBuffer(
+            Sha256.hash(
+                Uint8Array.wrap(
+                    Box.concat([
+                        Box.from(toBuffer(this.pointer)),
+                        Box.from(toArrayBuffer(this.subPointer)),
+                    ]),
+                ),
+            ),
+        );
+    }
+
+    public static wrap(v: ArrayBuffer): StorageSlot {
+        return new StorageSlot(0, fromArrayBuffer(Sha256.hash(Uint8Array.wrap(v))));
+    }
+
+    public static for(keyword: string): StorageSlot {
+        return StorageSlot.wrap(String.UTF8.encode(keyword));
+    }
+
+    public static at(pointer: u16): StorageSlot {
+        return new StorageSlot(pointer, u256.Zero);
+    }
+
+    public select(v: ArrayBuffer): StorageSlot {
+        return new StorageSlot(
+            this.pointer,
+            fromArrayBuffer(
+                Sha256.hash(
+                    Uint8Array.wrap(
+                        concat(toArrayBuffer(this.subPointer), Sha256.hash(Uint8Array.wrap(v))),
+                    ),
+                ),
+            ),
+        );
+    }
+
+    public keyword(key: string): StorageSlot {
+        return this.select(String.UTF8.encode(key));
+    }
+
+    public get(): u256 {
+        return changetype<BlockchainEnvironment>(0).getStorageAt(this.pointerHash, u256.Zero);
+    }
+
+    public set(v: u256): void {
+        changetype<BlockchainEnvironment>(0).setStorageAt(this.pointerHash, v);
+    }
+
+    public lengthKey(): StorageSlot {
+        return this.keyword('/length');
+    }
+
+    public length(): u32 {
+        return this.lengthKey().get().toU32();
+    }
+
+    public getList(): Array<u256> {
+        const result = new Array<u256>(<i32>this.length());
+        for (let i: i32 = 0; i < result.length; i++) {
+            result[i] = this.selectIndex(i).get();
+        }
+        return result;
+    }
+
+    public extend(): StorageSlot {
+        const lengthKey = this.lengthKey();
+        const length = lengthKey.get().toU32();
+        lengthKey.set(u256.from(length + 1));
+        return this.selectIndex(length);
+    }
+
+    public selectIndex(index: u32): StorageSlot {
+        return this.keyword('/' + index.toString(10));
+    }
+
+    public nullify(): void {
+        this.set(u256.Zero);
+    }
+
+    public append(v: u256): void {
+        this.extend().set(v);
+    }
+}

package/runtime/storage/StorageStruct.ts

@@ -0,0 +1,23 @@
+import { StorageSlot } from './StorageSlot';
+import { StorageBacked } from './StorageBacked';
+
+export class StorageStruct<T extends StorageBacked> {
+    public inner: T;
+    public slot: StorageSlot;
+
+    constructor(slot: StorageSlot, inner: T) {
+        this.slot = slot;
+        this.inner = inner;
+    }
+
+    public static load<T extends StorageBacked>(slot: StorageSlot): StorageStruct<T> {
+        return new StorageStruct<T>(slot, instantiate<T>(slot.getList()));
+    }
+
+    public save(): void {
+        const packed = this.inner.serialize();
+        for (let i = 0; i < packed.length; i++) {
+            this.slot.selectIndex(i).set(packed[i]);
+        }
+    }
+}

package/runtime/storage/StorageValue.ts

@@ -0,0 +1,36 @@
+import { u256 } from 'as-bignum/assembly';
+import { StorageSlot } from './StorageSlot';
+
+export class StorageValue<T> {
+    public value: u256;
+    public slot: StorageSlot;
+
+    constructor(slot: StorageSlot) {
+        this.slot = slot;
+        this.value = u256.Zero;
+    }
+
+    public static at<T>(slot: StorageSlot): StorageValue<T> {
+        return new StorageValue<T>(slot);
+    }
+
+    public save(): this {
+        this.slot.set(u256.from(this.value));
+        return this;
+    }
+
+    public set(v: T): this {
+        this.value = u256.from(v);
+        this.save();
+        return this;
+    }
+
+    public load(): this {
+        this.value = this.slot.get();
+        return this;
+    }
+
+    public unwrap(): T {
+        return load<T>(changetype<usize>(this.value.toUint8Array().buffer));
+    }
+}

package/runtime/storage/StoredAddress.ts

@@ -0,0 +1,47 @@
+import { u256 } from 'as-bignum/assembly';
+import { Blockchain } from '../env';
+import { encodePointer } from '../math/abi';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { Address } from '../types/Address';
+
+@final
+export class StoredAddress {
+    private readonly addressPointer: u256;
+    private readonly defaultValue: u256;
+
+    constructor(
+        public pointer: u16,
+        defaultValue: Address,
+    ) {
+        const writer = new BytesWriter(32);
+        writer.writeU16(pointer);
+
+        this.defaultValue = u256.fromBytes(defaultValue);
+        this.addressPointer = encodePointer(writer.getBuffer());
+    }
+
+    private _value: Address = new Address();
+
+    @inline
+    public get value(): Address {
+        this.ensureValue();
+
+        return this._value;
+    }
+
+    @inline
+    public set value(value: Address) {
+        if (value === this.value) {
+            return;
+        }
+
+        this._value = value;
+
+        Blockchain.setStorageAt(this.addressPointer, u256.fromBytes(this._value));
+    }
+
+    private ensureValue(): void {
+        const value = Blockchain.getStorageAt(this.addressPointer, this.defaultValue);
+        this._value.set(value.toBytes());
+    }
+}

package/runtime/storage/StoredU256.ts

@@ -46,6 +46,11 @@ export class StoredU256 {
         return this._value.toUint8Array(false);
     }
 
+    @inline
+    public toString(): string {
+        return this._value.toString();
+    }
+
     @inline
     @operator('+')
     public add(value: u256): this {

package/runtime/tests/assert.ts

@@ -1,8 +1,11 @@
 export function assert(condition: boolean, e: string): void {
-  if (!condition) throw new Error(e);
+    if (!condition) throw new Error(e);
 }
 
-export function assertEq<T>(a: T, b: T): void {
-  assert(a === b, "expected " + a.toString() + " to equal " + b.toString());
+interface WithToString {
+    toString(): string;
 }
 
+export function assertEq<T extends WithToString>(a: T, b: T): void {
+    assert(a === b, 'expected ' + a.toString() + ' to equal ' + b.toString());
+}

package/runtime/tests/env.ts

@@ -1,7 +1,7 @@
 // @ts-ignore
-@external("env", "logStatic")
+@external('env', 'logStatic')
 export declare function __logStatic(ptr: ArrayBuffer): void;
 
 export function log(v: string): void {
-  return __logStatic(String.UTF8.encode(v));
+    return __logStatic(String.UTF8.encode(v));
 }

package/runtime/tests/tests.ts

@@ -1,25 +1,27 @@
-import { BytesWriter } from "../buffer/BytesWriter";
-import { u256 } from "as-bignum/assembly";
-import { Blockchain } from "../env";
-import { Box } from "../utils/box";
-import { log } from "./env";
-import { assertEq } from "./assert";
+import { u256 } from 'as-bignum/assembly';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { Blockchain } from '../env';
+import { Box } from '../utils/box';
+import { assertEq } from './assert';
 
 export function test_encode(): void {
-  const writer = new BytesWriter(64);
-  writer.writeU256(u256.from(10));
-  writer.writeU256(u256.from(20));
-  const buffer = writer.getBuffer().buffer;
-  assertEq(Box.from(buffer).toHexString(), "0x0a000000000000000000000000000000000000000000000000000000000000001400000000000000000000000000000000000000000000000000000000000000");
+    const writer = new BytesWriter(64);
+    writer.writeU256(u256.from(10));
+    writer.writeU256(u256.from(20));
+    const buffer = writer.getBuffer().buffer;
+    assertEq(
+        Box.from(buffer).toHexString(),
+        '0x000000000000000000000000000000000000000000000000000000000000000a0000000000000000000000000000000000000000000000000000000000000014',
+    );
 }
 
 export function test_log(): void {
-  Blockchain.log("test logging test: OK!");
+    Blockchain.log('test logging test: OK!');
 }
 
 export function test_writeStringWithLength(): void {
-  const s = 'test write';
-  const writer = new BytesWriter(s.length + 2);
-  writer.writeStringWithLength(s);
-  assertEq(Box.from(writer.getBuffer().buffer).toHexString(), "0x0a0074657374207772697465");
+    const s = 'test write';
+    const writer = new BytesWriter(s.length + 2);
+    writer.writeStringWithLength(s);
+    assertEq(Box.from(writer.getBuffer().buffer).toHexString(), '0x0a0074657374207772697465');
 }