@btc-vision/btc-runtime 1.3.4 → 1.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.3.4",
+    "version": "1.3.6",
     "description": "Bitcoin Smart Contract Runtime",
     "main": "btc/index.ts",
     "scripts": {
@@ -44,7 +44,7 @@
     "dependencies": {
         "@assemblyscript/loader": "^0.27.30",
         "@eslint/js": "^9.10.0",
-        "as-bignum": "^0.3.0",
+        "as-bignum": "^0.3.1",
         "gulplog": "^2.2.0",
         "mocha": "^10.7.3",
         "ts-node": "^10.9.2",

package/runtime/contracts/DeployableOP_20.ts

@@ -216,8 +216,12 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     protected _approve(owner: Address, spender: Address, value: u256): boolean {
-        if (owner === Blockchain.DEAD_ADDRESS || spender === Blockchain.DEAD_ADDRESS) {
-            throw new Revert('Cannot approve from or to dead address');
+        if (owner === Blockchain.DEAD_ADDRESS) {
+            throw new Revert('Address can not be dead address');
+        }
+
+        if (spender === Blockchain.DEAD_ADDRESS) {
+            throw new Revert('Spender cannot be dead address');
         }
 
         const senderMap = this.allowanceMap.get(owner);

package/runtime/contracts/OP_NET.ts

@@ -22,10 +22,6 @@ export class OP_NET implements IBTC {
         let response: BytesWriter;
 
         switch (method) {
-            case encodeSelector('address'):
-                response = new BytesWriter(ADDRESS_BYTE_LENGTH);
-                response.writeAddress(this.address);
-                break;
             case encodeSelector('owner'):
                 response = new BytesWriter(ADDRESS_BYTE_LENGTH);
                 response.writeAddress(this.owner);

package/runtime/env/BlockchainEnvironment.ts

@@ -16,7 +16,9 @@ import {
     encodeAddress,
     loadPointer,
     log,
+    nextPointerGreaterThan,
     storePointer,
+    validateBitcoinAddress,
 } from './global';
 import { DeployContractResponse } from '../interfaces/DeployContractResponse';
 import { MapU256 } from '../generic/MapU256';
@@ -162,6 +164,14 @@ export class BlockchainEnvironment {
         emit(buffer.getBuffer());
     }
 
+    public validateBitcoinAddress(address: string): bool {
+        const writer = new BytesWriter(address.length);
+        writer.writeString(address);
+
+        const reader = new BytesReader(validateBitcoinAddress(writer.getBuffer()));
+        return reader.readBoolean();
+    }
+
     public encodeVirtualAddress(virtualAddress: u8[]): Address {
         const writer: BytesWriter = new BytesWriter(virtualAddress.length + 4);
         writer.writeU32(virtualAddress.length);
@@ -222,6 +232,22 @@ export class BlockchainEnvironment {
         return defaultValue;
     }
 
+    public getNextPointerGreaterThan(
+        targetPointer: MemorySlotPointer,
+        valueAtLeast: u256,
+        lte: boolean = true,
+    ): MemorySlotData<u256> {
+        const writer = new BytesWriter(65);
+        writer.writeU256(targetPointer);
+        writer.writeU256(valueAtLeast);
+        writer.writeBoolean(lte);
+
+        const result: Uint8Array = nextPointerGreaterThan(writer.getBuffer());
+        const reader: BytesReader = new BytesReader(result);
+
+        return reader.readU256();
+    }
+
     public hasStorageAt(pointerHash: MemorySlotPointer): bool {
         // We mark zero as the default value for the storage, if something is 0, the storage slot get deleted or is non-existent
         const val: u256 = this.getStorageAt(pointerHash, u256.Zero);

package/runtime/env/global.ts

@@ -2,6 +2,10 @@
 @external('env', 'load')
 export declare function loadPointer(data: Uint8Array): Uint8Array;
 
+// @ts-ignore
+@external('env', 'nextPointerGreaterThan')
+export declare function nextPointerGreaterThan(data: Uint8Array): Uint8Array;
+
 // @ts-ignore
 @external('env', 'store')
 export declare function storePointer(data: Uint8Array): Uint8Array;
@@ -38,6 +42,10 @@ export declare function sha256(data: Uint8Array): Uint8Array;
 @external('env', 'ripemd160')
 export declare function ripemd160(data: Uint8Array): Uint8Array;
 
+// @ts-ignore
+@external('env', 'validateBitcoinAddress')
+export declare function validateBitcoinAddress(data: Uint8Array): Uint8Array;
+
 // @ts-ignore
 @external('env', 'inputs')
 export declare function inputs(): Uint8Array;

package/runtime/math/abi.ts

@@ -12,8 +12,17 @@ export function encodeSelector(name: string): Selector {
     return bytes4(hash);
 }
 
-export function encodePointer(typed: Uint8Array): MemorySlotPointer {
+export function encodePointer(uniqueIdentifier: u16, typed: Uint8Array): MemorySlotPointer {
     const hash = Sha256.hash(typed);
 
-    return bytes32(hash);
+    const finalPointer = new Uint8Array(32);
+    finalPointer[0] = uniqueIdentifier & 0xff;
+    finalPointer[1] = (uniqueIdentifier >> 8) & 0xff;
+
+    for (let i = 0; i < 30; i++) {
+        // drop the last two bytes
+        finalPointer[i + 2] = hash[i];
+    }
+
+    return bytes32(finalPointer);
 }

package/runtime/memory/AddressMemoryMap.ts

@@ -49,10 +49,9 @@ export class AddressMemoryMap<V extends MemorySlotData<u256>> {
     }
 
     private encodePointer(key: Address): MemorySlotPointer {
-        const writer = new BytesWriter(key.length + 2);
-        writer.writeU16(this.pointer);
+        const writer = new BytesWriter(key.length);
         writer.writeBytes(key);
 
-        return encodePointer(writer.getBuffer());
+        return encodePointer(this.pointer, writer.getBuffer());
     }
 }

package/runtime/memory/KeyMerger.ts

@@ -53,10 +53,9 @@ export class KeyMerger<K extends string, K2 extends string, V extends MemorySlot
     }
 
     private encodePointer(key: string): MemorySlotPointer {
-        const writer = new BytesWriter(key.length + 2);
-        writer.writeU16(this.pointer);
+        const writer = new BytesWriter(key.length);
         writer.writeString(key);
 
-        return encodePointer(writer.getBuffer());
+        return encodePointer(this.pointer, writer.getBuffer());
     }
 }

package/runtime/memory/MultiAddressMemoryMap.ts

@@ -25,17 +25,6 @@ export class MultiAddressMemoryMap<V extends MemorySlotData<u256>> extends Map<
         return super.get(key);
     }
 
-    public setUpperKey(key: Address, key2: Address, value: V): this {
-        this.createKeyMerger(key);
-
-        const subMap = super.get(key);
-        if (subMap) {
-            subMap.set(key2, value);
-        }
-
-        return this;
-    }
-
     public set(key: Address, value: Uint8ArrayMerger<V>): this {
         this.createKeyMerger(key);
 

package/runtime/memory/StringMemoryMap.ts

@@ -48,10 +48,9 @@ export class StringMemoryMap<K extends string, V extends MemorySlotData<u256>> {
     }
 
     private encodePointer(key: K): MemorySlotPointer {
-        const writer = new BytesWriter(key.length + 2);
-        writer.writeU16(this.pointer);
+        const writer = new BytesWriter(key.length);
         writer.writeString(key);
 
-        return encodePointer(writer.getBuffer());
+        return encodePointer(this.pointer, writer.getBuffer());
     }
 }

package/runtime/memory/Uint8ArrayMerger.ts

@@ -51,7 +51,7 @@ export class Uint8ArrayMerger<V extends MemorySlotData<u256>> {
     }
 
     private getKeyHash(key: Uint8Array): MemorySlotPointer {
-        const writer: BytesWriter = new BytesWriter(key.byteLength + 2 + this.parentKey.byteLength);
+        const writer: BytesWriter = new BytesWriter(key.byteLength + this.parentKey.byteLength);
 
         writer.writeBytes(this.parentKey);
         writer.writeBytes(key);
@@ -60,8 +60,6 @@ export class Uint8ArrayMerger<V extends MemorySlotData<u256>> {
     }
 
     private encodePointer(writer: BytesWriter): MemorySlotPointer {
-        writer.writeU16(this.pointer);
-
-        return encodePointer(writer.getBuffer());
+        return encodePointer(this.pointer, writer.getBuffer());
     }
 }

package/runtime/storage/Serializable.ts

@@ -80,10 +80,9 @@ export abstract class Serializable {
     }
 
     private getPointer(subPointer: u256): u256 {
-        const writer = new BytesWriter(34);
-        writer.writeU16(this.pointer);
+        const writer = new BytesWriter(32);
         writer.writeU256(subPointer);
 
-        return encodePointer(writer.getBuffer());
+        return encodePointer(this.pointer, writer.getBuffer());
     }
 }

package/runtime/storage/StoredAddress.ts

@@ -14,10 +14,9 @@ export class StoredAddress {
         defaultValue: Address,
     ) {
         const writer = new BytesWriter(32);
-        writer.writeU16(pointer);
 
         this.defaultValue = u256.fromBytes(defaultValue);
-        this.addressPointer = encodePointer(writer.getBuffer());
+        this.addressPointer = encodePointer(pointer, writer.getBuffer());
     }
 
     private _value: Address = new Address();

package/runtime/storage/StoredString.ts

@@ -33,11 +33,10 @@ export class StoredString {
     }
 
     private getPointer(key: u256): u256 {
-        const buf = new BytesWriter(34);
-        buf.writeU16(this.pointer);
+        const buf = new BytesWriter(32);
         buf.writeU256(key);
 
-        return encodePointer(buf.getBuffer());
+        return encodePointer(this.pointer, buf.getBuffer());
     }
 
     private save(): void {

package/runtime/storage/StoredU256.ts

@@ -14,11 +14,10 @@ export class StoredU256 {
         public subPointer: MemorySlotPointer,
         private defaultValue: u256,
     ) {
-        const writer = new BytesWriter(34);
-        writer.writeU16(pointer);
+        const writer = new BytesWriter(32);
         writer.writeU256(subPointer);
 
-        this.u256Pointer = encodePointer(writer.getBuffer());
+        this.u256Pointer = encodePointer(pointer, writer.getBuffer());
     }
 
     private _value: u256 = u256.Zero;