@btc-vision/btc-runtime 1.9.1 → 1.9.2

package/runtime/contracts/OP_NET.ts

@@ -50,6 +50,11 @@ export class OP_NET implements IBTC {
         return this.address === address;
     }
 
+    protected _buildDomainSeparator(): Uint8Array {
+        // This method should be overridden in derived classes to provide the domain separator
+        throw new Error('Method not implemented.');
+    }
+
     protected onlyDeployer(caller: Address): void {
         if (this.contractDeployer !== caller) {
             throw new Revert('Only deployer can call this method');

package/runtime/contracts/ReentrancyGuard.ts

@@ -0,0 +1,136 @@
+import { Blockchain } from '../env';
+import { OP_NET } from './OP_NET';
+import { StoredBoolean } from '../storage/StoredBoolean';
+import { StoredU256 } from '../storage/StoredU256';
+import { Selector } from '../math/abi';
+import { Calldata } from '../types';
+import { Revert } from '../types/Revert';
+import { u256 } from '@btc-vision/as-bignum/assembly';
+import { SafeMath } from '../types/SafeMath';
+import {
+    ON_OP1155_BATCH_RECEIVED_MAGIC,
+    ON_OP1155_RECEIVED_MAGIC,
+    ON_OP20_RECEIVED_SELECTOR,
+    ON_OP721_RECEIVED_SELECTOR,
+} from '../constants/Exports';
+import { EMPTY_POINTER } from '../math/bytes';
+
+const statusPointer: u16 = Blockchain.nextPointer;
+const depthPointer: u16 = Blockchain.nextPointer;
+
+/**
+ * @enum ReentrancyLevel
+ * @description
+ * Defines the level of reentrancy protection.
+ *
+ * STANDARD: Strict single entry, no reentrancy allowed.
+ * CALLBACK: Allows one level of reentrancy for callbacks (e.g., token transfers).
+ */
+export enum ReentrancyLevel {
+    STANDARD = 0,
+    CALLBACK = 1,
+}
+
+export class ReentrancyGuard extends OP_NET {
+    protected readonly _locked: StoredBoolean;
+    protected readonly _reentrancyDepth: StoredU256;
+
+    // Override this in derived contracts to set protection level
+    protected readonly reentrancyLevel: ReentrancyLevel = ReentrancyLevel.STANDARD;
+
+    protected constructor() {
+        super();
+        this._locked = new StoredBoolean(statusPointer, false);
+        this._reentrancyDepth = new StoredU256(depthPointer, EMPTY_POINTER);
+    }
+
+    public override onExecutionCompleted(selector: Selector, calldata: Calldata): void {
+        super.onExecutionCompleted(selector, calldata);
+
+        if (this.isSelectorExcluded(selector)) {
+            return;
+        }
+
+        this.nonReentrantAfter();
+    }
+
+    public override onExecutionStarted(selector: Selector, calldata: Calldata): void {
+        super.onExecutionStarted(selector, calldata);
+
+        if (this.isSelectorExcluded(selector)) {
+            return;
+        }
+
+        this.nonReentrantBefore();
+    }
+
+    public nonReentrantBefore(): void {
+        if (this.reentrancyLevel === ReentrancyLevel.STANDARD) {
+            // Standard behavior - strict single entry
+            if (this._locked.value) {
+                this.reentrancyGuardReentrantCall();
+            }
+            this._locked.value = true;
+        } else if (this.reentrancyLevel === ReentrancyLevel.CALLBACK) {
+            // Allow one level of reentrancy for callbacks
+            const currentDepth = this._reentrancyDepth.value;
+
+            // Maximum depth of 2 (original call + one callback reentry)
+            if (currentDepth >= u256.One) {
+                throw new Revert('ReentrancyGuard: Max depth exceeded');
+            }
+
+            this._reentrancyDepth.value = SafeMath.add(currentDepth, u256.One);
+
+            // Use locked flag for first entry
+            if (currentDepth.isZero()) {
+                this._locked.value = true;
+            }
+        }
+    }
+
+    public nonReentrantAfter(): void {
+        if (this.reentrancyLevel === ReentrancyLevel.STANDARD) {
+            // Standard behavior
+            this._locked.value = false;
+        } else if (this.reentrancyLevel === ReentrancyLevel.CALLBACK) {
+            // Decrement depth
+            const currentDepth = this._reentrancyDepth.value;
+            if (currentDepth.isZero()) {
+                throw new Revert('ReentrancyGuard: Depth underflow');
+            }
+
+            const newDepth = SafeMath.sub(currentDepth, u256.One);
+            this._reentrancyDepth.value = newDepth;
+
+            // Clear locked flag when fully exited
+            if (newDepth.isZero()) {
+                this._locked.value = false;
+            }
+        }
+    }
+
+    public reentrancyGuardEntered(): boolean {
+        return this._locked.value === true;
+    }
+
+    public getCurrentDepth(): u256 {
+        return this._reentrancyDepth.value;
+    }
+
+    /**
+     * @dev Unauthorized reentrant call.
+     */
+    protected reentrancyGuardReentrantCall(): void {
+        throw new Revert('ReentrancyGuard: LOCKED');
+    }
+
+    protected isSelectorExcluded(selector: Selector): boolean {
+        return (
+            selector === ON_OP20_RECEIVED_SELECTOR ||
+            selector === ON_OP721_RECEIVED_SELECTOR ||
+            selector === ON_OP1155_RECEIVED_MAGIC ||
+            selector === ON_OP1155_BATCH_RECEIVED_MAGIC
+        );
+    }
+}

package/runtime/contracts/interfaces/IOP1155.ts

@@ -0,0 +1,33 @@
+import { BytesWriter } from '../../buffer/BytesWriter';
+import { Calldata } from '../../types';
+
+export interface IOP1155 {
+    // Core properties
+    fn_name(calldata: Calldata): BytesWriter;
+    fn_symbol(calldata: Calldata): BytesWriter;
+    uri(calldata: Calldata): BytesWriter;
+
+    // Balance and supply
+    balanceOf(calldata: Calldata): BytesWriter;
+    balanceOfBatch(calldata: Calldata): BytesWriter;
+    totalSupply(calldata: Calldata): BytesWriter;
+    exists(calldata: Calldata): BytesWriter;
+
+    // Transfer functions
+    safeTransferFrom(calldata: Calldata): BytesWriter;
+    safeBatchTransferFrom(calldata: Calldata): BytesWriter;
+
+    // Approval functions
+    setApprovalForAll(calldata: Calldata): BytesWriter;
+    isApprovedForAll(calldata: Calldata): BytesWriter;
+
+    // Advanced functions
+    burn(calldata: Calldata): BytesWriter;
+    burnBatch(calldata: Calldata): BytesWriter;
+    transferBySignature(calldata: Calldata): BytesWriter;
+    batchTransferBySignature(calldata: Calldata): BytesWriter;
+    domainSeparator(calldata: Calldata): BytesWriter;
+
+    // Interface support
+    supportsInterface(calldata: Calldata): BytesWriter;
+}

package/runtime/contracts/interfaces/IOP721.ts

@@ -0,0 +1,29 @@
+import { BytesWriter } from '../../buffer/BytesWriter';
+import { Calldata } from '../../types';
+
+export interface IOP721 {
+    // Core NFT properties
+    fn_name(calldata: Calldata): BytesWriter;
+    fn_symbol(calldata: Calldata): BytesWriter;
+    tokenURI(calldata: Calldata): BytesWriter;
+    fn_totalSupply(calldata: Calldata): BytesWriter;
+
+    // Balance and ownership
+    balanceOf(calldata: Calldata): BytesWriter;
+    ownerOf(calldata: Calldata): BytesWriter;
+
+    // Transfer functions
+    transferFrom(calldata: Calldata): BytesWriter;
+    safeTransferFrom(calldata: Calldata): BytesWriter;
+
+    // Approval functions
+    approve(calldata: Calldata): BytesWriter;
+    getApproved(calldata: Calldata): BytesWriter;
+    setApprovalForAll(calldata: Calldata): BytesWriter;
+    isApprovedForAll(calldata: Calldata): BytesWriter;
+
+    // Advanced functions
+    burn(calldata: Calldata): BytesWriter;
+    transferBySignature(calldata: Calldata): BytesWriter;
+    domainSeparator(calldata: Calldata): BytesWriter;
+}

package/runtime/contracts/interfaces/OP1155InitParameters.ts

@@ -0,0 +1,11 @@
+export class OP1155InitParameters {
+    public name: string;
+    public symbol: string;
+    public baseUri: string;
+
+    constructor(name: string, symbol: string, baseUri: string) {
+        this.name = name;
+        this.symbol = symbol;
+        this.baseUri = baseUri;
+    }
+}

package/runtime/contracts/interfaces/OP721InitParameters.ts

@@ -0,0 +1,15 @@
+import { u256 } from '@btc-vision/as-bignum/assembly';
+
+export class OP721InitParameters {
+    public name: string;
+    public symbol: string;
+    public baseURI: string;
+    public maxSupply: u256;
+
+    constructor(name: string, symbol: string, baseURI: string, maxSupply: u256) {
+        this.name = name;
+        this.symbol = symbol;
+        this.baseURI = baseURI;
+        this.maxSupply = maxSupply;
+    }
+}

package/runtime/env/BlockchainEnvironment.ts

@@ -35,6 +35,14 @@ import { Network, Networks } from '../script/Networks';
 
 export * from '../env/global';
 
+@final
+export class CallResult {
+    constructor(
+        public readonly success: boolean,
+        public readonly data: BytesReader,
+    ) {}
+}
+
 @final
 export class BlockchainEnvironment {
     public readonly DEAD_ADDRESS: Address = Address.dead();
@@ -204,7 +212,11 @@ export class BlockchainEnvironment {
         this.createContractIfNotExists();
     }
 
-    public call(destinationContract: Address, calldata: BytesWriter): BytesReader {
+    public call(
+        destinationContract: Address,
+        calldata: BytesWriter,
+        stopExecutionOnFailure: boolean = true,
+    ): CallResult {
         if (!destinationContract) {
             throw new Revert('Destination contract is required');
         }
@@ -222,11 +234,11 @@ export class BlockchainEnvironment {
         const resultBuffer = new ArrayBuffer(resultLength);
         getCallResult(0, resultLength, resultBuffer);
 
-        if (status !== 0) {
+        if (status !== 0 && stopExecutionOnFailure) {
             env_exit(status, resultBuffer, resultLength);
         }
 
-        return new BytesReader(Uint8Array.wrap(resultBuffer));
+        return new CallResult(status === 0, new BytesReader(Uint8Array.wrap(resultBuffer)));
     }
 
     public log(data: string): void {
@@ -285,6 +297,7 @@ export class BlockchainEnvironment {
 
     public getStorageAt(pointerHash: Uint8Array): Uint8Array {
         this.hasPointerStorageHash(pointerHash);
+
         if (this.storage.has(pointerHash)) {
             return this.storage.get(pointerHash);
         }
@@ -367,12 +380,20 @@ export class BlockchainEnvironment {
     private _internalSetStorageAt(pointerHash: Uint8Array, value: Uint8Array): void {
         this.storage.set(pointerHash, value);
 
+        if (pointerHash.buffer.byteLength !== 32 || value.buffer.byteLength !== 32) {
+            throw new Revert('Pointer and value must be 32 bytes long');
+        }
+
         storePointer(pointerHash.buffer, value.buffer);
     }
 
     private _internalSetTransientStorageAt(pointerHash: Uint8Array, value: Uint8Array): void {
         this.transientStorage.set(pointerHash, value);
 
+        if (pointerHash.buffer.byteLength !== 32 || value.buffer.byteLength !== 32) {
+            throw new Revert('Transient pointer and value must be 32 bytes long');
+        }
+
         tStorePointer(pointerHash.buffer, value.buffer);
     }
 
@@ -381,6 +402,10 @@ export class BlockchainEnvironment {
             return true;
         }
 
+        if (pointer.buffer.byteLength !== 32) {
+            throw new Revert('Pointer must be 32 bytes long');
+        }
+
         // we attempt to load the requested pointer.
         const resultBuffer = new ArrayBuffer(32);
         loadPointer(pointer.buffer, resultBuffer);
@@ -396,6 +421,10 @@ export class BlockchainEnvironment {
             return true;
         }
 
+        if (pointer.buffer.byteLength !== 32) {
+            throw new Revert('Transient pointer must be 32 bytes long');
+        }
+
         // we attempt to load the requested pointer.
         const resultBuffer = new ArrayBuffer(32);
         tLoadPointer(pointer.buffer, resultBuffer);

package/runtime/events/predefined/ApprovedForAll.ts

@@ -0,0 +1,16 @@
+import { NetEvent } from '../NetEvent';
+import { BytesWriter } from '../../buffer/BytesWriter';
+import { Address } from '../../types/Address';
+import { ADDRESS_BYTE_LENGTH } from '../../utils';
+
+@final
+export class ApprovedForAllEvent extends NetEvent {
+    constructor(account: Address, operator: Address, approved: boolean) {
+        const writer = new BytesWriter(ADDRESS_BYTE_LENGTH * 2 + 1);
+        writer.writeAddress(account);
+        writer.writeAddress(operator);
+        writer.writeBoolean(approved);
+
+        super('ApprovedForAll', writer);
+    }
+}

package/runtime/events/predefined/TransferredBatchEvent.ts

@@ -0,0 +1,35 @@
+import { NetEvent } from '../NetEvent';
+import { Address } from '../../types/Address';
+import { u256 } from '@btc-vision/as-bignum/assembly';
+import { ADDRESS_BYTE_LENGTH, U256_BYTE_LENGTH, U32_BYTE_LENGTH } from '../../utils';
+import { BytesWriter } from '../../buffer/BytesWriter';
+import { Revert } from '../../types/Revert';
+
+@final
+export class TransferredBatchEvent extends NetEvent {
+    constructor(operator: Address, from: Address, to: Address, ids: u256[], values: u256[]) {
+        // Check max array size to avoid exceeding event data limit
+        // 3 addresses (32*3) + 2 lengths (4*2) = 104 bytes overhead
+        // Each id+value pair = 64 bytes
+        // Max pairs = (352 - 104) / 64 = 3.875, so max 3 items
+        if (ids.length > 3) {
+            throw new Revert('TransferBatch event exceeds max data size');
+        }
+
+        const size =
+            ADDRESS_BYTE_LENGTH * 3 + U32_BYTE_LENGTH * 2 + ids.length * U256_BYTE_LENGTH * 2;
+        const writer = new BytesWriter(size);
+        writer.writeAddress(operator);
+        writer.writeAddress(from);
+        writer.writeAddress(to);
+        writer.writeU32(u32(ids.length));
+        for (let i = 0; i < ids.length; i++) {
+            writer.writeU256(ids[i]);
+        }
+        writer.writeU32(u32(values.length));
+        for (let i = 0; i < values.length; i++) {
+            writer.writeU256(values[i]);
+        }
+        super('TransferredBatch', writer);
+    }
+}

package/runtime/events/predefined/TransferredSingleEvent.ts

@@ -0,0 +1,18 @@
+import { NetEvent } from '../NetEvent';
+import { Address } from '../../types/Address';
+import { u256 } from '@btc-vision/as-bignum/assembly';
+import { BytesWriter } from '../../buffer/BytesWriter';
+import { ADDRESS_BYTE_LENGTH, U256_BYTE_LENGTH } from '../../utils';
+
+@final
+export class TransferredSingleEvent extends NetEvent {
+    constructor(operator: Address, from: Address, to: Address, id: u256, value: u256) {
+        const writer = new BytesWriter(ADDRESS_BYTE_LENGTH * 3 + U256_BYTE_LENGTH * 2);
+        writer.writeAddress(operator);
+        writer.writeAddress(from);
+        writer.writeAddress(to);
+        writer.writeU256(id);
+        writer.writeU256(value);
+        super('TransferredSingle', writer);
+    }
+}

package/runtime/events/predefined/URIEvent.ts

@@ -0,0 +1,23 @@
+import { NetEvent } from '../NetEvent';
+import { u256 } from '@btc-vision/as-bignum/assembly';
+import { BytesWriter } from '../../buffer/BytesWriter';
+import { U256_BYTE_LENGTH, U32_BYTE_LENGTH } from '../../utils';
+import { Revert } from '../../types/Revert';
+
+export const MAX_URI_LENGTH: u32 = 200;
+
+@final
+export class URIEvent extends NetEvent {
+    constructor(value: string, id: u256) {
+        const valueBytes: i32 = String.UTF8.byteLength(value);
+
+        if (valueBytes > MAX_URI_LENGTH) {
+            throw new Revert('URI event exceeds max data size');
+        }
+
+        const writer = new BytesWriter(U32_BYTE_LENGTH + valueBytes + U256_BYTE_LENGTH);
+        writer.writeStringWithLength(value);
+        writer.writeU256(id);
+        super('URI', writer);
+    }
+}

package/runtime/events/predefined/index.ts

@@ -2,3 +2,7 @@ export * from './ApprovedEvent';
 export * from './BurnedEvent';
 export * from './MintedEvent';
 export * from './TransferredEvent';
+export * from './ApprovedForAll';
+export * from './URIEvent';
+export * from './TransferredBatchEvent';
+export * from './TransferredSingleEvent';

package/runtime/index.ts

@@ -97,3 +97,12 @@ export * from './script/BitcoinAddresses';
 export * from './script/Networks';
 export * from './script/Opcodes';
 export * from './script/Segwit';
+
+export * from './constants/Exports';
+export * from './contracts/OP721';
+export * from './contracts/interfaces/IOP721';
+export * from './contracts/OP1155';
+export * from './contracts/interfaces/IOP1155';
+export * from './contracts/interfaces/OP721InitParameters';
+export * from './contracts/ReentrancyGuard';
+export * from './contracts/interfaces/OP1155InitParameters';

package/runtime/math/abi.ts

@@ -68,11 +68,34 @@ export function u256To30Bytes(value: u256): Uint8Array {
 
 /**
  * Optimized pointer encoding, see encodePointerUnknownLength for a more generic version.
+ *
+ * ⚠️ CRITICAL SECURITY NOTICE ⚠️
+ * ================================================================================================
+ * THIS FUNCTION WILL OVERWRITE THE FIRST 2 BYTES OF YOUR DATA!
+ *
+ * If you pass a 32-byte buffer, the first 2 bytes WILL BE DESTROYED and replaced with the
+ * uniqueIdentifier. This is BY DESIGN for pointer encoding.
+ *
+ * CORRECT USAGE:
+ * - For incremental pointers: You MUST provide exactly 30 bytes of data, NOT 32 bytes
+ * - The function will create a new 32-byte buffer with:
+ *   - Bytes 0-1: uniqueIdentifier (split into two bytes)
+ *   - Bytes 2-31: Your 30 bytes of data
+ *
+ * INCORRECT USAGE (DATA LOSS):
+ * - DO NOT pass 32 bytes expecting them to be preserved
+ * - DO NOT assume this function appends the identifier - it PREPENDS and shifts your data
+ *
+ * Example:
+ * - Input: uniqueIdentifier=0x1234, data=[30 bytes]
+ * - Output: [0x34, 0x12, ...your 30 bytes...] = 32 bytes total
+ *
  * @param uniqueIdentifier
  * @param typed
  * @param enforce30Bytes
  * @param {string} context Optional debug context.
  */
+@unsafe
 export function encodePointer(uniqueIdentifier: u16, typed: Uint8Array, enforce30Bytes: boolean = true, context: string = ''): Uint8Array {
     const array = ensureAtLeast30Bytes(typed);
 

package/runtime/math/bytes.ts

@@ -159,6 +159,10 @@ export function writeLengthAndStartIndex(length: u32, startIndex: u32): Uint8Arr
 
 @inline
 export function bigEndianAdd(base: Uint8Array, increment: u64): Uint8Array {
+    if(base.length !== 32) {
+        throw new Revert('bigEndianAdd: base must be 32 bytes');
+    }
+
     const add = u64ToBE32Bytes(increment);
 
     return addUint8ArraysBE(base, add);

package/runtime/memory/AddressMemoryMap.ts

@@ -5,6 +5,26 @@ import { u256 } from '@btc-vision/as-bignum/assembly';
 import { EMPTY_BUFFER } from '../math/bytes';
 import { Revert } from '../types/Revert';
 
+/**
+ * SECURITY NOTICE:
+ *
+ * This class uses a 30-byte truncation of addresses for storage pointer generation.
+ * While this may appear to introduce collision risks, it is secure within the OP_NET
+ * protocol context because:
+ *
+ * 1. All addresses in OP_NET are tweaked public keys (32-byte elliptic curve points)
+ *
+ * 2. Tweaked public keys are uniformly distributed across the secp256k1 curve space
+ *
+ * 3. Finding two public keys with identical 30-byte prefixes (240 bits) requires
+ *    approximately 2^120 operations due to the birthday paradox
+ *
+ * 4. The probability of accidentally generating colliding addresses through normal
+ *    key generation is cryptographically negligible
+ *
+ * The truncation from 32 to 30 bytes is a space optimization that does not
+ * meaningfully impact security given the uniform distribution of elliptic curve points.
+ */
 @final
 export class AddressMemoryMap {
     public pointer: u16;

package/runtime/nested/storage/StorageMap.ts

@@ -14,6 +14,7 @@ import { U256Codec } from '../codecs/U256Codec';
 
 import { Address } from '../../types/Address';
 import { Revert } from '../../types/Revert';
+import { EMPTY_BUFFER } from '../../math/bytes';
 
 /**
  * A reflection-based StorageMap<K, V>.
@@ -32,10 +33,6 @@ export class StorageMap<K, V> {
         this.pointer = pointer;
     }
 
-    // ----------------------------------------------------------
-    // PUBLIC API
-    // ----------------------------------------------------------
-
     public set(key: K, value: V): this {
         const storageKey = this.getStorageKey(key);
         this.storeValue<V>(storageKey, value);
@@ -59,7 +56,7 @@ export class StorageMap<K, V> {
             return false;
         }
 
-        Blockchain.setStorageAt(storageKey, new Uint8Array(0));
+        Blockchain.setStorageAt(storageKey, EMPTY_BUFFER);
         return true;
     }
 
@@ -69,22 +66,12 @@ export class StorageMap<K, V> {
         throw new Revert('clear() not implemented; no key-tracking logic here.');
     }
 
-    // ----------------------------------------------------------
-    // INTERNAL: Derive the final storage key
-    // ----------------------------------------------------------
-
     private getStorageKey(k: K): Uint8Array {
-        // 1) encode the key
         const keyBytes = this.encodeValue<K>(k);
 
-        // 2) transform with pointer
         return encodePointerUnknownLength(this.pointer, keyBytes);
     }
 
-    // ----------------------------------------------------------
-    // ENCODE / DECODE
-    // ----------------------------------------------------------
-
     /**
      * Retrieve the value of type P from the given storage pointer (32 bytes).
      * If it's a variable-length type, we decode from pointer-based approach
@@ -123,10 +110,6 @@ export class StorageMap<K, V> {
         Blockchain.setStorageAt(storageKey, raw);
     }
 
-    // ----------------------------------------------------------
-    // decodeBytesAsType: interpret raw bytes as type P
-    // ----------------------------------------------------------
-
     private decodeBytesAsType<P>(raw: Uint8Array): P {
         // isInteger => built-in numeric types (i32, u32, etc.)
         if (isInteger<P>()) {
@@ -173,10 +156,6 @@ export class StorageMap<K, V> {
         throw new Revert(`Unsupported type ${typeId}`);
     }
 
-    // ----------------------------------------------------------
-    // encodeValue<P>: convert a value of type P into raw bytes
-    // ----------------------------------------------------------
-
     private encodeValue<P>(value: P): Uint8Array {
         // built-in integer => write with BytesWriter
         if (isInteger<P>()) {
@@ -221,6 +200,7 @@ export class StorageMap<K, V> {
 
         // If nested map => handle in a custom branch (not shown here):
         // if (value instanceof StorageMap<...>) { ... }
+        // TODO
 
         throw new Revert('encodeValue: Unsupported type');
     }

package/runtime/nested/storage/StorageSet.ts

@@ -4,6 +4,9 @@ import { encodePointerUnknownLength } from '../../math/abi';
 import { Blockchain } from '../../env';
 import { Revert } from '../../types/Revert';
 
+const SLOT_BYTES: i32 = 32;
+const PRESENCE_BYTE: u8 = 1;
+
 export class StorageSet<T> {
     private readonly pointer: u16;
     private readonly parentKey: Uint8Array;
@@ -20,8 +23,8 @@ export class StorageSet<T> {
         const storageKey = this.getStorageKey(value);
 
         // A 1-byte array with a single 0x01 is enough to mark presence
-        const flag = new Uint8Array(1);
-        flag[31] = 1;
+        const flag = new Uint8Array(SLOT_BYTES);
+        flag[31] = PRESENCE_BYTE;
 
         Blockchain.setStorageAt(storageKey, flag);
     }
@@ -37,7 +40,7 @@ export class StorageSet<T> {
             return false;
         }
 
-        Blockchain.setStorageAt(storageKey, new Uint8Array(32));
+        Blockchain.setStorageAt(storageKey, new Uint8Array(SLOT_BYTES));
         return true;
     }
 

package/runtime/script/Script.ts

@@ -64,7 +64,7 @@ export class ScriptNumber {
     /**
      * Decode result type for safe error handling
      */
-    static decodeResult(data: Uint8Array, minimal: bool = true): DecodeNumberResult {
+    public static decodeResult(data: Uint8Array, minimal: bool = true): DecodeNumberResult {
         const L = data.length;
         if (L == 0) return DecodeNumberResult.ok(0);
 

package/runtime/secp256k1/ECPoint.ts

@@ -41,7 +41,7 @@ export class ECPoint {
     // x3 = λ^2 - 2x mod P
     // y3 = λ*(x - x3) - y mod P
     // ----------------------------
-    static double(p: ECPoint): ECPoint {
+    public 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" convention
@@ -80,7 +80,7 @@ export class ECPoint {
     // x3 = λ^2 - x1 - x2 mod P
     // y3 = λ*(x1 - x3) - y1 mod P
     // ----------------------------
-    static add(p: ECPoint, q: ECPoint): ECPoint {
+    public 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();
@@ -122,7 +122,7 @@ export class ECPoint {
     // Scalar Multiplication: k*P
     // Double-and-add approach
     // ----------------------------
-    static scalarMultiply(p: ECPoint, k: u256): ECPoint {
+    public static scalarMultiply(p: ECPoint, k: u256): ECPoint {
         let result = new ECPoint(u256.Zero, u256.Zero); // ∞
         let addend = p;
         const two = u256.fromU64(2);