@btc-vision/btc-runtime 1.5.6 → 1.5.7

package/package.json

@@ -1,46 +1,46 @@
 {
-  "name": "@btc-vision/btc-runtime",
-  "version": "1.5.6",
-  "description": "Bitcoin Smart Contract Runtime",
-  "main": "btc/index.ts",
-  "scripts": {},
-  "types": "btc/index.ts",
-  "keywords": [
-    "bitcoin",
-    "smart",
-    "contract",
-    "runtime",
-    "opnet",
-    "OP_NET"
-  ],
-  "homepage": "https://opnet.org",
-  "author": "BlobMaster41",
-  "license": "MIT",
-  "devDependencies": {
-    "@types/node": "^22.13.10",
-    "assemblyscript": "^0.27.35"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/btc-vision/btc-runtime"
-  },
-  "type": "module",
-  "files": [
-    "package.json",
-    "runtime",
-    "runtime/*.ts",
-    "runtime/**/*.ts",
-    "!**/*.js.map",
-    "!**/*.tsbuildinfo",
-    "test/*.ts"
-  ],
-  "dependencies": {
-    "@assemblyscript/loader": "^0.27.35",
-    "@btc-vision/as-bignum": "^0.0.5",
-    "@eslint/js": "^9.22.0",
-    "gulplog": "^2.2.0",
-    "ts-node": "^10.9.2",
-    "typescript": "^5.8.2",
-    "typescript-eslint": "^8.26.1"
-  }
+    "name": "@btc-vision/btc-runtime",
+    "version": "1.5.7",
+    "description": "Bitcoin Smart Contract Runtime",
+    "main": "btc/index.ts",
+    "scripts": {},
+    "types": "btc/index.ts",
+    "keywords": [
+        "bitcoin",
+        "smart",
+        "contract",
+        "runtime",
+        "opnet",
+        "OP_NET"
+    ],
+    "homepage": "https://opnet.org",
+    "author": "BlobMaster41",
+    "license": "MIT",
+    "devDependencies": {
+        "@types/node": "^22.13.10",
+        "assemblyscript": "^0.27.35"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/btc-vision/btc-runtime"
+    },
+    "type": "module",
+    "files": [
+        "package.json",
+        "runtime",
+        "runtime/*.ts",
+        "runtime/**/*.ts",
+        "!**/*.js.map",
+        "!**/*.tsbuildinfo",
+        "test/*.ts"
+    ],
+    "dependencies": {
+        "@assemblyscript/loader": "^0.27.35",
+        "@btc-vision/as-bignum": "^0.0.5",
+        "@eslint/js": "^9.22.0",
+        "gulplog": "^2.2.0",
+        "ts-node": "^10.9.2",
+        "typescript": "^5.8.2",
+        "typescript-eslint": "^8.26.1"
+    }
 }

package/runtime/contracts/DeployableOP_20.ts

@@ -39,7 +39,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
 
     protected readonly _nonceMap: AddressMemoryMap;
 
-    protected constructor(params: OP20InitParameters | null = null) {
+    public constructor(params: OP20InitParameters | null = null) {
         super();
 
         // Initialize main storage structures

package/runtime/contracts/OP_20.ts

@@ -3,7 +3,7 @@ import { u256 } from '@btc-vision/as-bignum/assembly';
 import { OP20InitParameters } from './interfaces/OP20InitParameters';
 
 export abstract class OP_20 extends DeployableOP_20 {
-    protected constructor(maxSupply: u256, decimals: u8, name: string, symbol: string) {
+    public constructor(maxSupply: u256, decimals: u8, name: string, symbol: string) {
         super(new OP20InitParameters(maxSupply, decimals, name, symbol));
     }
 }

package/runtime/env/BlockchainEnvironment.ts

@@ -25,13 +25,10 @@ import { eqUint, MapUint8Array } from '../generic/MapUint8Array';
 import { EMPTY_BUFFER } from '../math/bytes';
 import { Plugin } from '../plugins/Plugin';
 import { Calldata } from '../types';
+import { Revert } from '../types/Revert';
 
 export * from '../env/global';
 
-export function runtimeError(msg: string): Error {
-    return new Error(`RuntimeException: ${msg}`);
-}
-
 @final
 export class BlockchainEnvironment {
     private static readonly MAX_U16: u16 = 65535;
@@ -47,7 +44,7 @@ export class BlockchainEnvironment {
     @inline
     public get block(): Block {
         if (!this._block) {
-            throw this.error('Block is required');
+            throw new Revert('Block is required');
         }
 
         return this._block as Block;
@@ -58,7 +55,7 @@ export class BlockchainEnvironment {
     @inline
     public get tx(): Transaction {
         if (!this._tx) {
-            throw this.error('Transaction is required');
+            throw new Revert('Transaction is required');
         }
 
         return this._tx as Transaction;
@@ -80,7 +77,7 @@ export class BlockchainEnvironment {
 
     public get nextPointer(): u16 {
         if (this._nextPointer === BlockchainEnvironment.MAX_U16) {
-            throw this.error(`Out of storage pointer.`);
+            throw new Revert(`Out of storage pointer.`);
         }
 
         this._nextPointer += 1;
@@ -92,7 +89,7 @@ export class BlockchainEnvironment {
 
     public get contractDeployer(): Address {
         if (!this._contractDeployer) {
-            throw this.error('Deployer is required');
+            throw new Revert('Deployer is required');
         }
 
         return this._contractDeployer as Address;
@@ -102,7 +99,7 @@ export class BlockchainEnvironment {
 
     public get contractAddress(): Address {
         if (!this._contractAddress) {
-            throw this.error('Contract address is required');
+            throw new Revert('Contract address is required');
         }
 
         return this._contractAddress as Address;
@@ -171,12 +168,8 @@ export class BlockchainEnvironment {
     }
 
     public call(destinationContract: Address, calldata: BytesWriter): BytesReader {
-        if (destinationContract === this.contractAddress) {
-            throw this.error('Cannot call self');
-        }
-
         if (!destinationContract) {
-            throw this.error('Destination contract is required');
+            throw new Revert('Destination contract is required');
         }
 
         const resultLengthBuffer = new ArrayBuffer(32);
@@ -234,7 +227,7 @@ export class BlockchainEnvironment {
         );
 
         if (status !== 0) {
-            throw this.error('Failed to deploy contract');
+            throw new Revert('Failed to deploy contract');
         }
 
         const contractAddressReader = new BytesReader(Uint8Array.wrap(resultAddressBuffer));
@@ -283,7 +276,7 @@ export class BlockchainEnvironment {
 
     private createContractIfNotExists(): void {
         if (!this._contract) {
-            throw this.error('Contract is required');
+            throw new Revert('Contract is required');
         }
 
         if (!this._selfContract) {
@@ -291,10 +284,6 @@ export class BlockchainEnvironment {
         }
     }
 
-    private error(msg: string): Error {
-        return runtimeError(msg);
-    }
-
     private _internalSetStorageAt(pointerHash: Uint8Array, value: Uint8Array): void {
         this.storage.set(pointerHash, value);
 

package/runtime/storage/arrays/StoredPackedArray.ts

@@ -49,7 +49,7 @@ export abstract class StoredPackedArray<T> {
      */
     protected readonly MAX_LENGTH: u64 = <u64>(u32.MAX_VALUE - 1);
 
-    protected constructor(public pointer: u16, public subPointer: Uint8Array) {
+    protected constructor(public pointer: u16, public subPointer: Uint8Array, protected defaultValue: T) {
         assert(subPointer.length <= 30, `You must pass a 30 bytes sub-pointer. (Array, got ${subPointer.length})`);
 
         const basePointer = encodeBasePointer(pointer, subPointer);
@@ -66,6 +66,24 @@ export abstract class StoredPackedArray<T> {
     @inline
     @operator('[]')
     public get(index: u64): T {
+        // max length used on purpose to prevent unbounded usage
+        if (index > this.MAX_LENGTH) {
+            throw new Revert('get: out of range');
+        }
+
+        const realIndex = (this._startIndex + index) % this.MAX_LENGTH;
+        const cap = this.getSlotCapacity();
+        const slotIndex = realIndex / cap;
+        const subIndex = <u32>(realIndex % cap);
+
+        const slotData = this.ensureSlot(slotIndex);
+        const arr = this.unpackSlot(slotData);
+
+        return arr[subIndex];
+    }
+
+    @inline
+    public get_physical(index: u64): T {
         if (index > this.MAX_LENGTH) {
             throw new Revert('get: index exceeds MAX_LENGTH (packed array)');
         }
@@ -74,11 +92,9 @@ export abstract class StoredPackedArray<T> {
         const slotIndex = index / cap;
         const subIndex = <u32>(index % cap);
 
-        // Load the slot if not cached
         const slotData = this.ensureSlot(slotIndex);
-
-        // Unpack and return the subIndex
         const arr = this.unpackSlot(slotData);
+
         return arr[subIndex];
     }
 
@@ -89,6 +105,28 @@ export abstract class StoredPackedArray<T> {
             throw new Revert('set: index exceeds MAX_LENGTH (packed array)');
         }
 
+        const realIndex = (this._startIndex + index) % this.MAX_LENGTH;
+        const cap = this.getSlotCapacity();
+        const slotIndex = realIndex / cap;
+        const subIndex = <u32>(realIndex % cap);
+
+        let slotData = this.ensureSlot(slotIndex);
+        const arr = this.unpackSlot(slotData);
+
+        if (!this.eq(arr[subIndex], value)) {
+            arr[subIndex] = value;
+            slotData = this.packSlot(arr);
+            this._slots.set(slotIndex, slotData);
+            this._isChanged.add(slotIndex);
+        }
+    }
+
+    @inline
+    public set_physical(index: u64, value: T): void {
+        if (index > this.MAX_LENGTH) {
+            throw new Revert('set: index exceeds MAX_LENGTH (packed array)');
+        }
+
         const cap = this.getSlotCapacity();
         const slotIndex = index / cap;
         const subIndex = <u32>(index % cap);
@@ -105,15 +143,15 @@ export abstract class StoredPackedArray<T> {
     }
 
     @inline
-    public push(value: T): void {
+    public push(value: T, isPhysical: bool = false): void {
         if (this._length >= this.MAX_LENGTH) {
-            throw new Revert('push: array has reached MAX_LENGTH (packed array)');
+            throw new Revert('push: array has reached MAX_LENGTH');
         }
 
-        const newIndex = this._length;
+        const realIndex = ((isPhysical ? 0 : this._startIndex) + this._length) % this.MAX_LENGTH;
         const cap = this.getSlotCapacity();
-        const slotIndex = newIndex / cap;
-        const subIndex = <u32>(newIndex % cap);
+        const slotIndex = realIndex / cap;
+        const subIndex = <u32>(realIndex % cap);
 
         let slotData = this.ensureSlot(slotIndex);
         const arr = this.unpackSlot(slotData);
@@ -129,12 +167,70 @@ export abstract class StoredPackedArray<T> {
         this._isChangedLength = true;
     }
 
+    /**
+     * Remove the first element by zeroing it and shifting all other elements.
+     */
+    @inline
+    public shift(): T {
+        if (this._length == 0) {
+            throw new Revert('shift: array is empty (packed array)');
+        }
+
+        const newIndex = this._startIndex;
+        const cap = this.getSlotCapacity();
+        const slotIndex = newIndex / cap;
+        const subIndex = <u32>(newIndex % cap);
+
+        let slotData = this.ensureSlot(slotIndex);
+
+        const arr = this.unpackSlot(slotData);
+        const currentData = arr[subIndex];
+
+        if (!this.eq(currentData, this.defaultValue)) {
+            arr[subIndex] = this.defaultValue;
+            slotData = this.packSlot(arr);
+
+            this._slots.set(slotIndex, slotData);
+            this._isChanged.add(slotIndex);
+        }
+
+        this._length -= 1;
+        this._startIndex += 1;
+        this._isChangedLength = true;
+        this._isChangedStartIndex = true;
+
+        return currentData;
+    }
+
     /**
      * "Delete" by zeroing out the element at `index`,
      * but does not reduce the length.
      */
     @inline
     public delete(index: u64): void {
+        const realIndex = (this._startIndex + index) % this.MAX_LENGTH;
+        const cap = this.getSlotCapacity();
+        const slotIndex = realIndex / cap;
+        const subIndex = <u32>(realIndex % cap);
+
+        let slotData = this.ensureSlot(slotIndex);
+        const arr = this.unpackSlot(slotData);
+
+        const zeroVal = this.zeroValue();
+        if (!this.eq(arr[subIndex], zeroVal)) {
+            arr[subIndex] = zeroVal;
+            slotData = this.packSlot(arr);
+            this._slots.set(slotIndex, slotData);
+            this._isChanged.add(slotIndex);
+        }
+    }
+
+    /**
+     * "Delete" by zeroing out the element at `index`,
+     * but does not reduce the length.
+     */
+    @inline
+    public delete_physical(index: u64): void {
         const cap = this.getSlotCapacity();
         const slotIndex = index / cap;
         const subIndex = <u32>(index % cap);

package/runtime/storage/arrays/StoredU128Array.ts

@@ -10,7 +10,7 @@ import { bigEndianAdd } from '../../math/bytes';
 @final
 export class StoredU128Array extends StoredPackedArray<u128> {
     public constructor(pointer: u16, subPointer: Uint8Array) {
-        super(pointer, subPointer);
+        super(pointer, subPointer, u128.Zero);
     }
 
     protected getSlotCapacity(): u64 {

package/runtime/storage/arrays/StoredU16Array.ts

@@ -7,7 +7,7 @@ import { bigEndianAdd } from '../../math/bytes';
 @final
 export class StoredU16Array extends StoredPackedArray<u16> {
     public constructor(pointer: u16, subPointer: Uint8Array) {
-        super(pointer, subPointer);
+        super(pointer, subPointer, 0);
     }
 
     protected getSlotCapacity(): u64 {

package/runtime/storage/arrays/StoredU256Array.ts

@@ -9,7 +9,7 @@ import { bigEndianAdd } from '../../math/bytes';
 @final
 export class StoredU256Array extends StoredPackedArray<u256> {
     public constructor(pointer: u16, subPointer: Uint8Array) {
-        super(pointer, subPointer);
+        super(pointer, subPointer, u256.Zero);
     }
 
     protected getSlotCapacity(): u64 {

package/runtime/storage/arrays/StoredU32Array.ts

@@ -8,7 +8,7 @@ import { bigEndianAdd } from '../../math/bytes';
 @final
 export class StoredU32Array extends StoredPackedArray<u32> {
     public constructor(pointer: u16, subPointer: Uint8Array) {
-        super(pointer, subPointer);
+        super(pointer, subPointer, 0);
     }
 
     protected getSlotCapacity(): u64 {

package/runtime/storage/arrays/StoredU64Array.ts

@@ -8,7 +8,7 @@ import { bigEndianAdd } from '../../math/bytes';
 @final
 export class StoredU64Array extends StoredPackedArray<u64> {
     public constructor(pointer: u16, subPointer: Uint8Array) {
-        super(pointer, subPointer);
+        super(pointer, subPointer, 0);
     }
 
     protected getSlotCapacity(): u64 {

package/runtime/storage/arrays/StoredU8Array.ts

@@ -8,7 +8,7 @@ import { bigEndianAdd } from '../../math/bytes';
 @final
 export class StoredU8Array extends StoredPackedArray<u8> {
     public constructor(pointer: u16, subPointer: Uint8Array) {
-        super(pointer, subPointer);
+        super(pointer, subPointer, 0);
     }
 
     protected getSlotCapacity(): u64 {