@btc-vision/btc-runtime 1.6.1 → 1.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.6.1",
+    "version": "1.6.3",
     "description": "Bitcoin Smart Contract Runtime",
     "main": "btc/index.ts",
     "scripts": {},

package/runtime/buffer/BytesReader.ts

@@ -1,5 +1,4 @@
 import { i128, u128, u256 } from '@btc-vision/as-bignum/assembly';
-import { TransactionInput, TransactionOutput } from '../env/classes/UTXO';
 import { AddressMap } from '../generic/AddressMap';
 import { Selector } from '../math/abi';
 import { Address } from '../types/Address';
@@ -242,7 +241,7 @@ export class BytesReader {
         return addr;
     }
 
-// ------------------- Arrays ------------------- //
+    // ------------------- Arrays ------------------- //
 
     /**
      * The AS writer does `writeU32(length)` for U256 arrays, so we read a u32.
@@ -330,34 +329,6 @@ export class BytesReader {
         return result;
     }
 
-    public readTransactionInputs(): TransactionInput[] {
-        const length = this.readU16();
-        const result = new Array<TransactionInput>(length);
-
-        for (let i: u16 = 0; i < length; i++) {
-            const txId = this.readBytes(32);
-            const outputIndex = this.readU16();
-            const scriptSig = this.readBytesWithLength();
-            result[i] = new TransactionInput(txId, outputIndex, scriptSig);
-        }
-
-        return result;
-    }
-
-    public readTransactionOutputs(): TransactionOutput[] {
-        const length = this.readU16();
-        const result = new Array<TransactionOutput>(length);
-
-        for (let i: u16 = 0; i < length; i++) {
-            const index = this.readU16();
-            const scriptPubKey = this.readStringWithLength();
-            const value = this.readU64();
-            result[i] = new TransactionOutput(index, scriptPubKey, value);
-        }
-
-        return result;
-    }
-
     public getOffset(): i32 {
         return this.currentOffset;
     }
@@ -373,7 +344,7 @@ export class BytesReader {
         if (size > this.buffer.byteLength) {
             throw new Error(
                 `Attempt to read beyond buffer length. Requested up to offset ${size}, ` +
-                `but buffer is only ${this.buffer.byteLength} bytes.`,
+                    `but buffer is only ${this.buffer.byteLength} bytes.`,
             );
         }
     }

package/runtime/env/Atomic.ts

@@ -0,0 +1,51 @@
+// @ts-ignore
+@external('env', '__atomic_wait32')
+declare function __atomic_wait32(addr: i32, expected: i32, timeout: i64, proof: ArrayBuffer, verifier: ArrayBuffer): i32;
+
+// @ts-ignore
+@external('env', '__atomic_wait64')
+declare function __atomic_wait64(addr: i32, expected: i64, timeout: i64, proof: ArrayBuffer, verifier: ArrayBuffer): i32;
+
+// @ts-ignore
+@external('env', '__atomic_notify')
+declare function __atomic_notify(addr: i32, count: i32): i32;
+
+// @ts-ignore
+@external('env', '__thread_spawn')
+declare function __thread_spawn(): i32;
+
+export namespace Atomics {
+    export const OK: i32 = 0;
+    export const TIMED_OUT: i32 = 1;
+    export const NOT_EQUAL: i32 = 2;
+    export const NOT_AUTHORIZED: i32 = 3;
+    export const FAULT: i32 = -1;
+
+    /** Waits on `addr` until its value != `expected` or timeout (ns). */
+    export function wait32(addr: usize, expected: i32, timeoutNs: i64, proof: Uint8Array, verifier: Uint8Array): i32 {
+        WARNING('EXPERIMENTAL: wait32 is not yet stable and may change in the future. This feature is not available in production.');
+
+        return __atomic_wait32(<i32>addr, expected, timeoutNs, proof.buffer, verifier.buffer);
+    }
+
+    /** Waits on `addr` until its value != `expected` or timeout (ns). */
+    export function wait64(addr: usize, expected: i64, timeoutNs: i64, proof: Uint8Array, verifier: Uint8Array): i32 {
+        WARNING('EXPERIMENTAL: wait64 is not yet stable and may change in the future. This feature is not available in production.');
+
+        return __atomic_wait64(<i32>addr, expected, timeoutNs, proof.buffer, verifier.buffer);
+    }
+
+    /** Wakes up at most `count` waiters. */
+    export function notify(addr: usize, count: i32 = 1): i32 {
+        WARNING('EXPERIMENTAL: notify is not yet stable and may change in the future. This feature is not available in production.');
+
+        return __atomic_notify(<i32>addr, count);
+    }
+
+    /** Spawns a helper thread. */
+    export function spawn(): i32 {
+        WARNING('EXPERIMENTAL: spawn is not yet stable and may change in the future. This feature is not available in production.');
+
+        return __thread_spawn();
+    }
+}

package/runtime/env/BlockchainEnvironment.ts

@@ -35,8 +35,6 @@ export * from '../env/global';
 
 @final
 export class BlockchainEnvironment {
-    private static readonly MAX_U16: u16 = 65535;
-
     public readonly DEAD_ADDRESS: Address = Address.dead();
 
     private storage: MapUint8Array = new MapUint8Array();
@@ -81,7 +79,7 @@ export class BlockchainEnvironment {
     private _nextPointer: u16 = 0;
 
     public get nextPointer(): u16 {
-        if (this._nextPointer === BlockchainEnvironment.MAX_U16) {
+        if (this._nextPointer === u16.MAX_VALUE) {
             throw new Revert(`Out of storage pointer.`);
         }
 
@@ -157,12 +155,7 @@ export class BlockchainEnvironment {
         const caller = reader.readAddress();
         const origin = reader.readAddress();
 
-        this._tx = new Transaction(
-            caller,
-            origin,
-            txId,
-            txHash,
-        );
+        this._tx = new Transaction(caller, origin, txId, txHash);
 
         this._contractDeployer = contractDeployer;
         this._contractAddress = contractAddress;
@@ -178,7 +171,12 @@ export class BlockchainEnvironment {
         }
 
         const resultLengthBuffer = new ArrayBuffer(32);
-        const status = callContract(destinationContract.buffer, calldata.getBuffer().buffer, calldata.bufferLength(), resultLengthBuffer);
+        const status = callContract(
+            destinationContract.buffer,
+            calldata.getBuffer().buffer,
+            calldata.bufferLength(),
+            resultLengthBuffer,
+        );
 
         const reader = new BytesReader(Uint8Array.wrap(resultLengthBuffer));
         const resultLength = reader.readU32(true);
@@ -244,9 +242,7 @@ export class BlockchainEnvironment {
         return contractAddressReader.readAddress();
     }
 
-    public getStorageAt(
-        pointerHash: Uint8Array,
-    ): Uint8Array {
+    public getStorageAt(pointerHash: Uint8Array): Uint8Array {
         this.hasPointerStorageHash(pointerHash);
         if (this.storage.has(pointerHash)) {
             return this.storage.get(pointerHash);
@@ -255,9 +251,7 @@ export class BlockchainEnvironment {
         return new Uint8Array(32);
     }
 
-    public getTransientStorageAt(
-        pointerHash: Uint8Array,
-    ): Uint8Array {
+    public getTransientStorageAt(pointerHash: Uint8Array): Uint8Array {
         if (this.hasPointerTransientStorageHash(pointerHash)) {
             return this.transientStorage.get(pointerHash);
         }

package/runtime/env/classes/Transaction.ts

@@ -3,16 +3,18 @@ import { TransactionInput, TransactionOutput } from './UTXO';
 import { Potential } from '../../lang/Definitions';
 import { BytesReader } from '../../buffer/BytesReader';
 import { getInputsSize, getOutputsSize, inputs, outputs } from '../global';
+import { TransactionDecoder } from '../decoders/TransactionDecoder';
 
 @final
 export class Transaction {
+    private readonly transactionDecoder: TransactionDecoder = new TransactionDecoder();
+
     public constructor(
         public readonly sender: Address, // "immediate caller"
         public readonly origin: Address, // "leftmost thing in the call chain"
         public readonly txId: Uint8Array,
         public readonly hash: Uint8Array,
-    ) {
-    }
+    ) {}
 
     private _inputs: Potential<TransactionInput[]> = null;
 
@@ -46,7 +48,7 @@ export class Transaction {
         inputs(resultBuffer);
 
         const reader = new BytesReader(Uint8Array.wrap(resultBuffer));
-        return reader.readTransactionInputs();
+        return this.transactionDecoder.readTransactionInputs(reader);
     }
 
     private loadOutputs(): TransactionOutput[] {
@@ -55,6 +57,6 @@ export class Transaction {
         outputs(resultBuffer);
 
         const reader = new BytesReader(Uint8Array.wrap(resultBuffer));
-        return reader.readTransactionOutputs();
+        return this.transactionDecoder.readTransactionOutputs(reader);
     }
 }

package/runtime/env/classes/UTXO.ts

@@ -1,10 +1,17 @@
+import { TransactionInputFlags, TransactionOutputFlags } from '../enums/TransactionFlags';
+
 @final
 export class TransactionInput {
     public constructor(
+        public readonly flags: u8,
         public readonly txId: Uint8Array,
         public readonly outputIndex: u16,
         public readonly scriptSig: Uint8Array,
-    ) {
+        public readonly coinbase: Uint8Array | null,
+    ) {}
+
+    public get isCoinbase(): boolean {
+        return (this.flags & TransactionInputFlags.hasCoinbase) !== 0;
     }
 }
 
@@ -12,8 +19,21 @@ export class TransactionInput {
 export class TransactionOutput {
     public constructor(
         public readonly index: u16,
-        public readonly to: string,
+        public readonly flags: u8,
+        public readonly scriptPublicKey: Uint8Array | null,
+        public readonly to: string | null,
         public readonly value: u64,
-    ) {
+    ) {}
+
+    public get hasTo(): boolean {
+        return (this.flags & TransactionOutputFlags.hasTo) !== 0;
+    }
+
+    public get hasScriptPubKey(): boolean {
+        return (this.flags & TransactionOutputFlags.hasScriptPubKey) !== 0;
+    }
+
+    public get isOPReturn(): boolean {
+        return (this.flags & TransactionOutputFlags.OP_RETURN) !== 0;
     }
 }

package/runtime/env/decoders/TransactionDecoder.ts

@@ -0,0 +1,66 @@
+import { TransactionInput, TransactionOutput } from '../classes/UTXO';
+import { TransactionInputFlags, TransactionOutputFlags } from '../enums/TransactionFlags';
+import { BytesReader } from '../../buffer/BytesReader';
+
+export class TransactionDecoder {
+    public readTransactionInputs(buffer: BytesReader): TransactionInput[] {
+        const length = buffer.readU16();
+        const result = new Array<TransactionInput>(length);
+
+        for (let i: u16 = 0; i < length; i++) {
+            result[i] = this.decodeInput(buffer);
+        }
+
+        return result;
+    }
+
+    public readTransactionOutputs(buffer: BytesReader): TransactionOutput[] {
+        const length = buffer.readU16();
+        const result = new Array<TransactionOutput>(length);
+
+        for (let i: u16 = 0; i < length; i++) {
+            result[i] = this.decodeOutput(buffer);
+        }
+
+        return result;
+    }
+
+    private decodeInput(buffer: BytesReader): TransactionInput {
+        const flags = buffer.readU8();
+        const txId = buffer.readBytes(32);
+        const outputIndex = buffer.readU16();
+        const scriptSig = buffer.readBytesWithLength();
+
+        const coinbase: Uint8Array | null = this.hasFlag(flags, TransactionInputFlags.hasCoinbase)
+            ? buffer.readBytesWithLength()
+            : null;
+
+        return new TransactionInput(flags, txId, outputIndex, scriptSig, coinbase);
+    }
+
+    private decodeOutput(buffer: BytesReader): TransactionOutput {
+        const flags = buffer.readU8();
+        const index = buffer.readU16();
+
+        let scriptPubKey: Uint8Array | null = null;
+        if (this.hasFlag(flags, TransactionOutputFlags.hasScriptPubKey)) {
+            scriptPubKey = buffer.readBytesWithLength();
+        }
+
+        let to: string | null = null;
+        if (this.hasFlag(flags, TransactionOutputFlags.hasTo)) {
+            to = buffer.readStringWithLength();
+        }
+
+        const value = buffer.readU64();
+
+        return new TransactionOutput(index, flags, scriptPubKey, to, value);
+    }
+
+    /**
+     * Checks if the given flag is set in the flags byte.
+     */
+    private hasFlag<T extends u8>(flags: u8, flag: T): boolean {
+        return (flags & flag) !== 0;
+    }
+}

package/runtime/env/enums/TransactionFlags.ts

@@ -0,0 +1,9 @@
+export enum TransactionInputFlags {
+    hasCoinbase = 0b00000001,
+}
+
+export enum TransactionOutputFlags {
+    hasTo = 0b00000001,
+    hasScriptPubKey = 0b00000010,
+    OP_RETURN = 0b00000100,
+}

package/runtime/env/global.ts

@@ -98,3 +98,5 @@ export declare function getAccountType(address: ArrayBuffer): u32;
 // @ts-ignore
 @external('env', 'exit')
 export declare function env_exit(status: u32, data: ArrayBuffer, dataLength: u32): void;
+
+export * from './Atomic';

package/runtime/index.ts

@@ -61,10 +61,15 @@ export * from './nested/codecs/VariableBytesCodec';
 /** Storage */
 export * from './storage/StoredU256';
 export * from './storage/StoredU64';
+export * from './storage/StoredU32';
 export * from './storage/StoredString';
+export * from './storage/AdvancedStoredString';
 export * from './storage/StoredAddress';
 export * from './storage/StoredBoolean';
 
+/** Maps */
+export * from './storage/maps/StoredMapU256';
+
 /** Arrays */
 export * from './storage/arrays/StoredAddressArray';
 export * from './storage/arrays/StoredBooleanArray';

package/runtime/math/bytes.ts

@@ -133,14 +133,14 @@ export function setBit(buffer: Uint8Array, bitIndex: u16, bitValue: bool): void
  * Assume the data is at least 16 bytes, read two u64s from it in big-endian order.
  */
 @inline
-export function readLengthAndStartIndex(data: Uint8Array): u64[] {
+export function readLengthAndStartIndex(data: Uint8Array): u32[] {
     if (data.length < 16) {
         return [0, 0];
     }
 
     const reader = new BytesReader(data);
-    const length = reader.readU64();
-    const startIndex = reader.readU64();
+    const length = reader.readU32();
+    const startIndex = reader.readU32();
 
     return [length, startIndex];
 }
@@ -149,10 +149,10 @@ export function readLengthAndStartIndex(data: Uint8Array): u64[] {
  * Write two u64s into a 32-byte buffer in big-endian order
  */
 @inline
-export function writeLengthAndStartIndex(length: u64, startIndex: u64): Uint8Array {
+export function writeLengthAndStartIndex(length: u32, startIndex: u32): Uint8Array {
     const writer = new BytesWriter(32);
-    writer.writeU64(length);
-    writer.writeU64(startIndex);
+    writer.writeU32(length);
+    writer.writeU32(startIndex);
 
     return writer.getBuffer();
 }
@@ -174,4 +174,4 @@ export function bigEndianAdd(base: Uint8Array, increment: u64): Uint8Array {
     const add = u64ToBE32Bytes(increment);
 
     return addUint8ArraysBE(base, add);
-}
+}

package/runtime/storage/AdvancedStoredString.ts

@@ -0,0 +1,199 @@
+import { Blockchain } from '../env';
+import { encodePointer } from '../math/abi';
+import { bigEndianAdd } from '../math/bytes';
+import { Revert } from '../types/Revert';
+
+const MAX_LENGTH: u32 = 256;
+
+/**
+ * @class AdvancedStoredString
+ * @description
+ * Stores a string in a sequence of 32-byte storage slots, in UTF-8 format:
+ *  - Slot 0: first 4 bytes = length (big-endian), next 28 bytes = partial data
+ *  - Slot N>0: 32 bytes of data each
+ *
+ * The maximum is 65,535 bytes in UTF-8 form (not necessarily the same as code points).
+ */
+@final
+export class AdvancedStoredString {
+    constructor(
+        public pointer: u16,
+        private readonly subPointer: Uint8Array,
+    ) {}
+
+    private _value: string = '';
+
+    /**
+     * Cached string value. If `_value` is empty, we call `load()` on first access.
+     */
+    public get value(): string {
+        if (!this._value) {
+            this.load();
+        }
+        return this._value;
+    }
+
+    public set value(v: string) {
+        this._value = v;
+
+        this.save();
+    }
+
+    /**
+     * Derives a 32-byte pointer for the given chunkIndex and performs big-endian addition.
+     * chunkIndex=0 => header slot, 1 => second slot, etc.
+     */
+    private getPointer(chunkIndex: u64): Uint8Array {
+        const base = encodePointer(this.pointer, this.subPointer);
+        return bigEndianAdd(base, chunkIndex);
+    }
+
+    /**
+     * Reads the first slot and returns the stored byte length (big-endian).
+     * Returns 0 if the slot is all zero.
+     */
+    private getStoredLength(): u32 {
+        const headerSlot = Blockchain.getStorageAt(this.getPointer(0));
+        const b0 = <u32>headerSlot[0];
+        const b1 = <u32>headerSlot[1];
+        const b2 = <u32>headerSlot[2];
+        const b3 = <u32>headerSlot[3];
+        return (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
+    }
+
+    /**
+     * Clears old data from storage. Based on `oldLength`, determines how many slots
+     * were used, and writes zeroed 32-byte arrays to each.
+     */
+    private clearOldStorage(oldLength: u32): void {
+        if (oldLength == 0) {
+            return;
+        }
+
+        // We always use at least 1 slot (the header slot).
+        let chunkCount: u64 = 1;
+
+        // In the header slot, we can store up to 28 bytes of data.
+        const remaining = oldLength > 28 ? oldLength - 28 : 0;
+        if (remaining > 0) {
+            // Each additional chunk is 32 bytes.
+            // Use integer math ceiling: (remaining + 32 - 1) / 32
+            chunkCount += (remaining + 32 - 1) / 32;
+        }
+
+        // Zero out each previously used slot
+        for (let i: u64 = 0; i < chunkCount; i++) {
+            Blockchain.setStorageAt(this.getPointer(i), new Uint8Array(32));
+        }
+    }
+
+    /**
+     * Saves the current string to storage in UTF-8 form.
+     */
+    private save(): void {
+        // 1) Clear old data
+        const oldLen = this.getStoredLength();
+        this.clearOldStorage(oldLen);
+
+        // 2) Encode new string as UTF-8
+        const utf8Data = String.UTF8.encode(this._value, false);
+        const length = <u32>utf8Data.byteLength;
+
+        // Enforce max length
+        if (length > MAX_LENGTH) {
+            throw new Revert(`StoredString: value is too long (max=${MAX_LENGTH})`);
+        }
+
+        // 3) If new string is empty, just store a zeroed header and return
+        if (length == 0) {
+            // A zeroed 32-byte array => indicates length=0
+            Blockchain.setStorageAt(this.getPointer(0), new Uint8Array(32));
+            return;
+        }
+
+        // 4) Write the first slot: length + up to 28 bytes
+        let remaining: u32 = length;
+        let offset: u32 = 0;
+        const firstSlot = new Uint8Array(32);
+        firstSlot[0] = <u8>((length >> 24) & 0xff);
+        firstSlot[1] = <u8>((length >> 16) & 0xff);
+        firstSlot[2] = <u8>((length >> 8) & 0xff);
+        firstSlot[3] = <u8>(length & 0xff);
+
+        const bytes = Uint8Array.wrap(utf8Data);
+        const firstChunkSize = remaining < 28 ? remaining : 28;
+        for (let i: u32 = 0; i < firstChunkSize; i++) {
+            firstSlot[4 + i] = bytes[i];
+        }
+        Blockchain.setStorageAt(this.getPointer(0), firstSlot);
+
+        remaining -= firstChunkSize;
+        offset += firstChunkSize;
+
+        // 5) Write subsequent slots (32 bytes each)
+        let chunkIndex: u64 = 1;
+        while (remaining > 0) {
+            const slotData = new Uint8Array(32);
+            const chunkSize = remaining < u32(32) ? remaining : u32(32);
+            for (let i: u32 = 0; i < chunkSize; i++) {
+                slotData[i] = bytes[offset + i];
+            }
+            Blockchain.setStorageAt(this.getPointer(chunkIndex), slotData);
+
+            remaining -= chunkSize;
+            offset += chunkSize;
+            chunkIndex++;
+        }
+    }
+
+    /**
+     * Loads the string from storage by reading the stored byte length, then decoding
+     * the corresponding UTF-8 data from the slots.
+     */
+    private load(): void {
+        // Read the header slot first
+        const headerSlot = Blockchain.getStorageAt(this.getPointer(0));
+
+        // Parse the big-endian length
+        const b0 = <u32>headerSlot[0];
+        const b1 = <u32>headerSlot[1];
+        const b2 = <u32>headerSlot[2];
+        const b3 = <u32>headerSlot[3];
+        const length: u32 = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3;
+
+        // If length=0, then the string is empty
+        if (length == 0) {
+            this._value = '';
+            return;
+        }
+
+        // Read the UTF-8 bytes from storage
+        let remaining: u32 = length;
+        let offset: u32 = 0;
+        const out = new Uint8Array(length);
+
+        // First slot can hold up to 28 bytes after the length
+        const firstChunkSize = remaining < 28 ? remaining : 28;
+        for (let i: u32 = 0; i < firstChunkSize; i++) {
+            out[i] = headerSlot[4 + i];
+        }
+        remaining -= firstChunkSize;
+        offset += firstChunkSize;
+
+        // Read the subsequent slots of 32 bytes each
+        let chunkIndex: u64 = 1;
+        while (remaining > 0) {
+            const slotData = Blockchain.getStorageAt(this.getPointer(chunkIndex));
+            const chunkSize = remaining < 32 ? remaining : 32;
+            for (let i: u32 = 0; i < chunkSize; i++) {
+                out[offset + i] = slotData[i];
+            }
+            remaining -= chunkSize;
+            offset += chunkSize;
+            chunkIndex++;
+        }
+
+        // Decode UTF-8 into a normal string
+        this._value = String.UTF8.decode(out.buffer, false);
+    }
+}