@btc-vision/btc-runtime 1.8.1 → 1.9.0

package/runtime/memory/KeyMerger.ts

@@ -1,7 +1,7 @@
 import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { encodePointerUnknownLength } from '../math/abi';
-
+import { Revert } from '../types/Revert';
 
 @final
 export class KeyMerger<K extends string, K2 extends string, V extends Uint8Array> {
@@ -22,24 +22,24 @@ export class KeyMerger<K extends string, K2 extends string, V extends Uint8Array
         return this;
     }
 
-    public get(key: K): Uint8Array {
+    public get(key: K2): Uint8Array {
         const mergedKey: string = this.mergeKey(key);
         return Blockchain.getStorageAt(this.encodePointer(mergedKey));
     }
 
-    public has(key: K): bool {
+    public has(key: K2): bool {
         const mergedKey: string = this.mergeKey(key);
         return Blockchain.hasStorageAt(this.encodePointer(mergedKey));
     }
 
     @unsafe
-    public delete(_key: K): bool {
-        throw new Error('Method not implemented.');
+    public delete(_key: K2): bool {
+        throw new Revert('Method not implemented.');
     }
 
     @unsafe
     public clear(): void {
-        throw new Error('Clear method not implemented.');
+        throw new Revert('Clear method not implemented.');
     }
 
     /**
@@ -49,7 +49,7 @@ export class KeyMerger<K extends string, K2 extends string, V extends Uint8Array
      *   parentKey = "ab",  key = "cdef" => "2:ab4:cdef"
      */
     @inline
-    private mergeKey(key: string): string {
+    private mergeKey(key: K2): string {
         return `${this.parentKey.length}:${this.parentKey}${key.length}:${key}`;
     }
 

package/runtime/memory/MapOfMap.ts

@@ -2,15 +2,10 @@ import { Address } from '../types/Address';
 import { Nested } from './Nested';
 
 @final
-export class MapOfMap<T> extends Map<
-    Address,
-    Nested<T>
-> {
+export class MapOfMap<T> extends Map<Address, Nested<T>> {
     public pointer: u16;
 
-    constructor(
-        pointer: u16,
-    ) {
+    constructor(pointer: u16) {
         super();
 
         this.pointer = pointer;

package/runtime/memory/Nested.ts

@@ -3,6 +3,7 @@ import { encodePointerUnknownLength } from '../math/abi';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { u256 } from '@btc-vision/as-bignum/assembly';
 import { Address } from '../types/Address';
+import { Revert } from '../types/Revert';
 
 @final
 export class Nested<T> {
@@ -10,10 +11,7 @@ export class Nested<T> {
 
     public pointer: u16;
 
-    constructor(
-        parent: Uint8Array,
-        pointer: u16,
-    ) {
+    constructor(parent: Uint8Array, pointer: u16) {
         this.pointer = pointer;
 
         this.parentKey = parent;
@@ -40,12 +38,12 @@ export class Nested<T> {
 
     @unsafe
     public delete(_key: Uint8Array): bool {
-        throw new Error('Method not implemented.');
+        throw new Revert('Method not implemented.');
     }
 
     @unsafe
     public clear(): void {
-        throw new Error('Clear method not implemented.');
+        throw new Revert('Clear method not implemented.');
     }
 
     /**
@@ -70,7 +68,7 @@ export class Nested<T> {
             return changetype<T>(String.UTF8.decode(value.buffer));
         }
 
-        throw new Error('Unsupported type');
+        throw new Revert('Unsupported type');
     }
 
     /**
@@ -95,7 +93,7 @@ export class Nested<T> {
             return Uint8Array.wrap(String.UTF8.encode(str));
         }
 
-        throw new Error('Unsupported type');
+        throw new Revert('Unsupported type');
     }
 
     private getKeyHash(key: Uint8Array): Uint8Array {

package/runtime/nested/PointerManager.ts

@@ -52,4 +52,4 @@ class _PointerManager extends Plugin {
 }
 
 export const PointerManager = new _PointerManager();
-Blockchain.registerPlugin(PointerManager);
+Blockchain.registerPlugin(PointerManager);

package/runtime/nested/codecs/AddressCodec.ts

@@ -16,4 +16,4 @@ class _AddressCodec implements ICodec<Address> {
 }
 
 export const idOfAddressCodec = idof<_AddressCodec>();
-export const AddressCodec = new _AddressCodec();
+export const AddressCodec = new _AddressCodec();

package/runtime/nested/codecs/BooleanCodec.ts

@@ -14,4 +14,4 @@ class _BooleanCodec implements ICodec<bool> {
 }
 
 export const idOfBoolCodec = idof<_BooleanCodec>();
-export const BooleanCodec = new _BooleanCodec();
+export const BooleanCodec = new _BooleanCodec();

package/runtime/nested/codecs/Ids.ts

@@ -7,4 +7,4 @@ export const idOfU128 = idof<u128>();
 export const idOfI128 = idof<i128>();
 export const idOfUint8Array = idof<Uint8Array>();
 export const idOfString = idof<string>();
-export const idOfAddress = idof<Address>();
+export const idOfAddress = idof<Address>();

package/runtime/nested/codecs/NumericCodec.ts

@@ -55,4 +55,4 @@ export class NumericCodec<T> implements ICodec<T> {
             }
         }
     }
-}
+}

package/runtime/nested/codecs/StringCodec.ts

@@ -21,4 +21,4 @@ class IStringCodec implements ICodec<string> {
 }
 
 export const idOfStringCodec = idof<IStringCodec>();
-export const StringCodec = new IStringCodec();
+export const StringCodec = new IStringCodec();

package/runtime/nested/codecs/VariableBytesCodec.ts

@@ -21,7 +21,7 @@ export class IVariableBytesCodec implements ICodec<Uint8Array> {
 
         // If remaining > 0, each chunk is 32 bytes.
         // So total chunks needed = 1 (for first chunk) + ceil(remaining / 32).
-        const additionalChunks: u32 = remaining == 0 ? 0 : ((remaining + 32 - 1) / 32);
+        const additionalChunks: u32 = remaining == 0 ? 0 : (remaining + 32 - 1) / 32;
         const totalChunks: u32 = 1 + additionalChunks;
 
         // 1) Allocate `totalChunks` from PointerManager
@@ -52,7 +52,7 @@ export class IVariableBytesCodec implements ICodec<Uint8Array> {
             for (let j: u32 = 0; j < chunkSize; j++) {
                 chunk[j] = value[offset + j];
             }
-            
+
             offset += chunkSize;
             remaining -= chunkSize;
 
@@ -131,4 +131,4 @@ function isAllZero(arr: Uint8Array): bool {
 }
 
 export const idOfVariableBytes = idof<IVariableBytesCodec>();
-export const VariableBytesCodec = new IVariableBytesCodec();
+export const VariableBytesCodec = new IVariableBytesCodec();

package/runtime/nested/storage/StorageMap.ts

@@ -4,7 +4,7 @@ import { BytesReader } from '../../buffer/BytesReader';
 import { encodePointerUnknownLength } from '../../math/abi';
 
 import { i128, u128, u256 } from '@btc-vision/as-bignum/assembly';
-import { idOfAddress, idOfI128, idOfString, idOfU128, idOfU256, idOfUint8Array } from '../codecs/Ids';
+import { idOfAddress, idOfI128, idOfString, idOfU128, idOfU256, idOfUint8Array, } from '../codecs/Ids';
 
 import { AddressCodec } from '../codecs/AddressCodec';
 import { BooleanCodec } from '../codecs/BooleanCodec';
@@ -66,7 +66,7 @@ export class StorageMap<K, V> {
     @unsafe
     public clear(): void {
         // Not implemented: we'd need key-tracking to remove them all
-        throw new Error('clear() not implemented; no key-tracking logic here.');
+        throw new Revert('clear() not implemented; no key-tracking logic here.');
     }
 
     // ----------------------------------------------------------
@@ -224,4 +224,4 @@ export class StorageMap<K, V> {
 
         throw new Revert('encodeValue: Unsupported type');
     }
-}
+}

package/runtime/nested/storage/StorageSet.ts

@@ -2,7 +2,7 @@ import { ICodec } from '../interfaces/ICodec';
 import { BytesWriter } from '../../buffer/BytesWriter';
 import { encodePointerUnknownLength } from '../../math/abi';
 import { Blockchain } from '../../env';
-
+import { Revert } from '../../types/Revert';
 
 export class StorageSet<T> {
     private readonly pointer: u16;
@@ -43,7 +43,7 @@ export class StorageSet<T> {
 
     @unsafe
     public clear(): void {
-        throw new Error('clear() not implemented.');
+        throw new Revert('clear() not implemented.');
     }
 
     private getStorageKey(value: T): Uint8Array {

package/runtime/plugins/Plugin.ts

@@ -1,12 +1,10 @@
 import { Calldata } from '../types';
+import { Selector } from '../math/abi';
 
 export class Plugin {
-    public onDeployment(_calldata: Calldata): void {
-    }
+    public onDeployment(_calldata: Calldata): void {}
 
-    public onExecutionStarted(): void {
-    }
+    public onExecutionStarted(_selector: Selector, _calldata: Calldata): void {}
 
-    public onExecutionCompleted(): void {
-    }
-}
+    public onExecutionCompleted(_selector: Selector, _calldata: Calldata): void {}
+}

package/runtime/script/Bech32.ts

@@ -0,0 +1,369 @@
+import { BytesWriter } from '../buffer/BytesWriter';
+import { SegwitDecoded } from './ScriptUtils';
+import { Revert } from '../types/Revert';
+
+/**
+ * Result type for Bech32 operations that can fail
+ */
+@final
+export class Bech32Result<T> {
+    public readonly success: bool;
+    public readonly value: T | null;
+    public readonly error: string | null;
+
+    public constructor(success: bool, value: T | null, error: string | null) {
+        this.success = success;
+        this.value = value;
+        this.error = error;
+    }
+
+    public static ok<T>(value: T): Bech32Result<T> {
+        return new Bech32Result<T>(true, value, null);
+    }
+
+    public static err<T>(error: string): Bech32Result<T> {
+        return new Bech32Result<T>(false, null, error);
+    }
+}
+
+@final
+export class Bech32 {
+    private static readonly CHARSET: string = 'qpzry9x8gf2tvdw0s3jn54khce6mua7l';
+    private static decodeTbl: Int8Array | null = null;
+
+    /**
+     * Consider using encodeOrNull instead, this method will throw on error
+     * @param hrp
+     * @param witver
+     * @param program
+     */
+    public static encode(hrp: string, witver: i32, program: Uint8Array): string {
+        const result = Bech32.encodeOrNull(hrp, witver, program);
+        if (!result) {
+            throw new Revert('Bech32 encoding failed');
+        }
+
+        return result as string;
+    }
+
+    /**
+     * Safe encode that returns null on error instead of throwing
+     */
+    public static encodeOrNull(hrp: string, witver: i32, program: Uint8Array): string | null {
+        // Validate inputs
+        if (witver < 0 || witver > 16) return null;
+        if (witver == 0 && program.length != 20 && program.length != 32) return null;
+        if (witver != 0 && (program.length < 2 || program.length > 40)) return null;
+
+        // Build the 5-bit words array
+        const wordsWB = new BytesWriter(1 + (program.length * 8 + 4) / 5);
+        wordsWB.writeU8(<u8>witver);
+
+        const convertResult = Bech32.convertBitsSafe(program, 8, 5, true);
+        if (!convertResult.success) return null;
+
+        if (convertResult.value === null) {
+            throw new Revert('Bech32 convertBits failed with unknown error');
+        }
+
+        wordsWB.writeBytes(convertResult.value as Uint8Array);
+
+        const data = wordsWB.getBuffer().subarray(0, <i32>wordsWB.getOffset());
+        const chk = Bech32.createChecksum(hrp, data, /*bech32m*/ witver != 0);
+
+        // Build final output
+        const totalLen = hrp.length + 1 + data.length + chk.length;
+        const outWB = new BytesWriter(totalLen);
+
+        for (let i = 0; i < hrp.length; i++) {
+            outWB.writeU8(<u8>hrp.charCodeAt(i));
+        }
+        outWB.writeU8(49); // '1' separator
+
+        for (let i = 0; i < data.length; i++) {
+            outWB.writeU8(<u8>Bech32.CHARSET.charCodeAt(data[i]));
+        }
+
+        for (let i = 0; i < chk.length; i++) {
+            outWB.writeU8(<u8>Bech32.CHARSET.charCodeAt(chk[i]));
+        }
+
+        return String.UTF8.decode(outWB.getBuffer().buffer);
+    }
+
+    /**
+     * Consider using decodeOrNull instead, this method will throw on error
+     * @param addr
+     */
+    public static decode(addr: string): SegwitDecoded {
+        const result = Bech32.decodeOrNull(addr);
+        if (!result) {
+            throw new Revert('Bech32 decode failed');
+        }
+
+        return result as SegwitDecoded;
+    }
+
+    /**
+     * Safe decode that returns null on error
+     */
+    public static decodeOrNull(addr: string): SegwitDecoded | null {
+        const L = addr.length;
+
+        // Validate basic length constraints
+        if (L < 8 || L > 90) return null;
+
+        let lower = false;
+        let upper = false;
+        let pos = -1;
+
+        // Scan for separator and validate characters
+        for (let i = 0; i < L; i++) {
+            const c = addr.charCodeAt(i);
+            if (c < 33 || c > 126) return null;
+
+            if (c >= 97 && c <= 122) lower = true;
+            else if (c >= 65 && c <= 90) upper = true;
+
+            if (c == 49) pos = i; // '1' separator
+        }
+
+        // Check case consistency
+        if (lower && upper) return null;
+
+        // Validate separator position
+        if (pos < 1 || pos + 7 > L) return null;
+
+        // Extract HRP and normalize to lowercase
+        const hrp = lower ? addr.substring(0, pos) : addr.substring(0, pos).toLowerCase();
+
+        // Decode the data part
+        const dpLen = L - pos - 1;
+        const data = new Uint8Array(dpLen);
+
+        Bech32.ensureTable();
+        const tbl = changetype<Int8Array>(Bech32.decodeTbl);
+
+        for (let i = 0; i < dpLen; i++) {
+            let c = addr.charCodeAt(pos + 1 + i);
+            // Normalize to lowercase if needed
+            if (!lower && c >= 65 && c <= 90) c += 32;
+
+            const v = c < 128 ? unchecked(tbl[c]) : -1;
+            if (v < 0) return null;
+
+            data[i] = <u8>v;
+        }
+
+        // Verify checksum
+        const w = new BytesWriter(hrp.length * 2 + 1 + dpLen);
+        w.writeBytes(Bech32.hrpExpand(hrp));
+        w.writeBytes(data);
+
+        const pm = Bech32.polymod(w.getBuffer().subarray(0, <i32>w.getOffset()));
+        const witver = <i32>data[0];
+
+        if (witver < 0 || witver > 16) return null;
+
+        // Check if checksum matches for either bech32 or bech32m
+        let constOK = false;
+        if ((pm ^ 1) == 0) constOK = witver == 0; // bech32 for v0
+        if ((pm ^ 0x2bc830a3) == 0) constOK = witver != 0; // bech32m for v1+
+
+        if (!constOK) return null;
+
+        // Extract witness program
+        const words = data.subarray(0, dpLen - 6);
+        const progWords = words.subarray(1);
+
+        const convertResult = Bech32.convertBitsSafe(progWords, 5, 8, false);
+        if (!convertResult.success) return null;
+
+        const program = convertResult.value!;
+
+        // Validate program length based on witness version
+        if (witver == 0) {
+            const Lp = program.length;
+            if (Lp != 20 && Lp != 32) return null;
+        } else {
+            const Lp = program.length;
+            if (Lp < 2 || Lp > 40) return null;
+        }
+
+        return new SegwitDecoded(hrp, witver, program);
+    }
+
+    /**
+     * Ensure the decode table is initialized
+     * This is safe to call multiple times
+     */
+    private static ensureTable(): void {
+        if (Bech32.decodeTbl) return;
+
+        const t = new Int8Array(128);
+        for (let i = 0; i < 128; i++) {
+            unchecked((t[i] = -1));
+        }
+
+        for (let i = 0; i < 32; i++) {
+            const c = Bech32.CHARSET.charCodeAt(i);
+            if (c < 128) {
+                unchecked((t[c] = <i8>i));
+            }
+        }
+
+        Bech32.decodeTbl = t;
+    }
+
+    /**
+     * Expand human-readable part for checksum computation
+     */
+    private static hrpExpand(hrp: string): Uint8Array {
+        const L = hrp.length;
+        const w = new BytesWriter(L * 2 + 1);
+
+        // High bits of each character
+        for (let i = 0; i < L; i++) {
+            w.writeU8(<u8>(hrp.charCodeAt(i) >>> 5));
+        }
+
+        w.writeU8(0); // Separator
+
+        // Low bits of each character
+        for (let i = 0; i < L; i++) {
+            w.writeU8(<u8>(hrp.charCodeAt(i) & 31));
+        }
+
+        return w.getBuffer();
+    }
+
+    /**
+     * Compute Bech32 checksum polymod
+     */
+    private static polymod(values: Uint8Array): u32 {
+        let chk: u32 = 1;
+
+        // Generator polynomial coefficients
+        const G0: u32 = 0x3b6a57b2;
+        const G1: u32 = 0x26508e6d;
+        const G2: u32 = 0x1ea119fa;
+        const G3: u32 = 0x3d4233dd;
+        const G4: u32 = 0x2a1462b3;
+
+        const L = values.length;
+        for (let i = 0; i < L; i++) {
+            const top = chk >>> 25;
+            chk = ((chk & 0x1ffffff) << 5) ^ (<u32>unchecked(values[i]));
+
+            if ((top & 1) != 0) chk ^= G0;
+            if ((top & 2) != 0) chk ^= G1;
+            if ((top & 4) != 0) chk ^= G2;
+            if ((top & 8) != 0) chk ^= G3;
+            if ((top & 16) != 0) chk ^= G4;
+        }
+
+        return chk;
+    }
+
+    /**
+     * Consider using convertBitsSafe instead, this method will throw on error
+     */
+    private static convertBits(
+        data: Uint8Array,
+        fromBits: i32,
+        toBits: i32,
+        pad: bool,
+    ): Uint8Array {
+        const result = Bech32.convertBitsSafe(data, fromBits, toBits, pad);
+        if (!result.success) {
+            if (!result.error) {
+                throw new Revert('Bech32 convertBits failed with unknown error');
+            }
+
+            throw new Revert(result.error);
+        }
+        return result.value!;
+    }
+
+    /**
+     * Safe version of convertBits that returns a result object
+     */
+    private static convertBitsSafe(
+        data: Uint8Array,
+        fromBits: i32,
+        toBits: i32,
+        pad: bool,
+    ): Bech32Result<Uint8Array> {
+        let acc: i32 = 0;
+        let bits: i32 = 0;
+        const maxv = (1 << toBits) - 1;
+
+        // Calculate output length
+        const outLen64: i64 = pad
+            ? (<i64>data.length * fromBits + (toBits - 1)) / toBits
+            : (<i64>data.length * fromBits) / toBits;
+
+        if (outLen64 > <i64>0x7fffffff) {
+            return Bech32Result.err<Uint8Array>('convertBits outLen overflow');
+        }
+
+        const wb = new BytesWriter(<i32>outLen64);
+        const L = data.length;
+
+        for (let i = 0; i < L; i++) {
+            const v = <i32>unchecked(data[i]);
+
+            // Validate input value
+            if (v < 0 || v >> fromBits != 0) {
+                return Bech32Result.err<Uint8Array>('invalid value');
+            }
+
+            acc = (acc << fromBits) | v;
+            bits += fromBits;
+
+            while (bits >= toBits) {
+                bits -= toBits;
+                wb.writeU8(<u8>((acc >> bits) & maxv));
+            }
+        }
+
+        if (pad) {
+            if (bits > 0) {
+                wb.writeU8(<u8>((acc << (toBits - bits)) & maxv));
+            }
+        } else {
+            if (bits >= fromBits) {
+                return Bech32Result.err<Uint8Array>('excess padding');
+            }
+            if (((acc << (toBits - bits)) & maxv) != 0) {
+                return Bech32Result.err<Uint8Array>('non-zero padding');
+            }
+        }
+
+        return Bech32Result.ok<Uint8Array>(wb.getBuffer().subarray(0, <i32>wb.getOffset()));
+    }
+
+    private static createChecksum(hrp: string, data: Uint8Array, bech32m: bool): Uint8Array {
+        const hrpEx = Bech32.hrpExpand(hrp);
+        const w = new BytesWriter(hrpEx.length + data.length + 6);
+
+        w.writeBytes(hrpEx);
+        w.writeBytes(data);
+
+        // Add 6 zero bytes for checksum calculation
+        for (let i = 0; i < 6; i++) {
+            w.writeU8(0);
+        }
+
+        const pm =
+            Bech32.polymod(w.getBuffer().subarray(0, <i32>w.getOffset())) ^
+            (bech32m ? 0x2bc830a3 : 1);
+
+        const out = new Uint8Array(6);
+        for (let p = 0; p < 6; p++) {
+            out[p] = <u8>((pm >>> (5 * (5 - p))) & 31);
+        }
+
+        return out;
+    }
+}