@btc-vision/btc-runtime 1.1.9 → 1.1.11

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.1.9",
+    "version": "1.1.11",
     "description": "Bitcoin Smart Contract Runtime",
     "main": "btc/index.ts",
     "types": "btc/index.ts",

package/runtime/buffer/BytesWriter.ts

@@ -2,7 +2,6 @@ import { u256 } from 'as-bignum/assembly';
 import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
 import { Selector } from '../math/abi';
 import { BytesReader } from './BytesReader';
-import { SelectorsMap } from '../universal/ABIRegistry';
 import { Revert } from '../types/Revert';
 import { Map } from '../generic/Map';
 import { ArrayBuffer } from 'arraybuffer';
@@ -12,7 +11,7 @@ export class BytesWriter {
     private currentOffset: u32 = 0;
     private buffer: DataView;
 
-    constructor(length: i32 = 1) {
+    constructor(length: i32) {
         const arrayBuffer = new ArrayBuffer(length);
 
         this.buffer = new DataView(arrayBuffer);
@@ -125,20 +124,17 @@ export class BytesWriter {
         this.writeString(value);
     }
 
-    public writeViewSelectorMap(map: SelectorsMap): void {
-        this.writeU16(u16(map.size));
+    public writeAddressValueTupleMap(map: Map<Address, u256>): void {
+        if (map.size > 65535) throw new Revert('Map size is too large');
 
-        const keys = map.keys();
-        for (let i = 0; i < keys.length; i++) {
-            const key: u32 = keys[i] as u32;
-            const value = map.get(key);
+        /*const requiredSize: u32 = 2 + map.size * (ADDRESS_BYTE_LENGTH + 32);
 
-            this.writeBytes(value);
-        }
-    }
+        if (this.buffer.byteLength < requiredSize) {
+            abort(
+                `This buffer is too small. Required size: ${requiredSize} - Current size: ${this.buffer.byteLength}`,
+            );
+        }*/
 
-    public writeAddressValueTupleMap(map: Map<Address, u256>): void {
-        if (map.size > 65535) throw new Revert('Map size is too large');
         this.writeU16(u16(map.size));
 
         const keys = map.keys();
@@ -154,9 +150,28 @@ export class BytesWriter {
     public writeLimitedAddressBytesMap(map: Map<Address, Uint8Array[]>): void {
         if (map.size > 8) throw new Revert('Too many contract called.'); // no more than 8 different contracts.
 
-        this.writeU8(u8(map.size));
+        /*let requiredSize: u32 = 1 + (map.size * ADDRESS_BYTE_LENGTH + 1);
+
+
+        for (let i = 0; i < map.size; i++) {
+            const address: Address = keys[i];
+            const calls: Uint8Array[] = map.get(address) || [];
+
+            for (let j: i32 = 0; j < calls.length; j++) {
+                requiredSize += 4 + calls[j].length;
+            }
+        }
+
+        if (this.buffer.byteLength < requiredSize) {
+            abort(
+                `This buffer is too small. Required size: ${requiredSize} - Current size: ${this.buffer.byteLength}`,
+            );
+        }*/
 
         const keys: Address[] = map.keys();
+
+        this.writeU8(u8(map.size));
+
         for (let i: i32 = 0; i < keys.length; i++) {
             const address: Address = keys[i];
             const calls: Uint8Array[] = map.get(address) || [];
@@ -243,17 +258,17 @@ export class BytesWriter {
     }
 
     private resize(size: u32): void {
-        //abort(
-        //    `Buffer is getting resized. This is very bad for performance. Expected size: ${size} - Current size: ${this.buffer.byteLength}`,
-        //);
-        
-        const buf: Uint8Array = new Uint8Array(u32(this.buffer.byteLength) + size);
+        abort(
+            `Buffer is getting resized. This is very bad for performance. Expected size: ${this.buffer.byteLength + size} - Current size: ${this.buffer.byteLength}`,
+        );
+
+        /*const buf: Uint8Array = new Uint8Array(u32(this.buffer.byteLength) + size);
 
         for (let i: i32 = 0; i < this.buffer.byteLength; i++) {
             buf[i] = this.buffer.getUint8(i);
         }
 
-        this.buffer = new DataView(buf.buffer);
+        this.buffer = new DataView(buf.buffer);*/
     }
 
     private getDefaultBuffer(length: i32 = 1): DataView {

package/runtime/contracts/DeployableOP_20.ts

@@ -210,11 +210,11 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
                 response.writeU8(this.decimals);
                 break;
             case encodeSelector('name'):
-                response = new BytesWriter(this.name.length + 1);
+                response = new BytesWriter(this.name.length + 2);
                 response.writeStringWithLength(this.name);
                 break;
             case encodeSelector('symbol'):
-                response = new BytesWriter(this.symbol.length + 1);
+                response = new BytesWriter(this.symbol.length + 2);
                 response.writeStringWithLength(this.symbol);
                 break;
             case encodeSelector('totalSupply'):

package/runtime/env/BTCEnvironment.ts

@@ -168,7 +168,7 @@ export class BlockchainEnvironment {
             throw this.error('Too many events');
         }
 
-        const buffer: BytesWriter = new BytesWriter();
+        const buffer: BytesWriter = new BytesWriter(this.getEventSize());
         buffer.writeU16(eventLength);
 
         for (let i: u8 = 0; i < eventLength; i++) {
@@ -195,7 +195,7 @@ export class BlockchainEnvironment {
     }
 
     public deployContract(hash: u256, bytecode: Uint8Array): DeployContractResponse {
-        const writer = new BytesWriter();
+        const writer = new BytesWriter(32 + bytecode.length);
         writer.writeU256(hash);
         writer.writeBytes(bytecode);
 
@@ -260,16 +260,19 @@ export class BlockchainEnvironment {
         this._internalSetStorageAt(pointerHash, value);
     }
 
-    public getViewSelectors(): Uint8Array {
-        return ABIRegistry.getViewSelectors();
-    }
-
     public getMethodSelectors(): Uint8Array {
         return ABIRegistry.getMethodSelectors();
     }
 
-    public getWriteMethods(): Uint8Array {
-        return ABIRegistry.getWriteMethods();
+    private getEventSize(): u32 {
+        let size: u32 = 2;
+
+        for (let i: u32 = 0; i < <u32>this.events.length; i++) {
+            const event: NetEvent = this.events[i];
+            size += 2 + event.eventType.length + 8 + event.length + 4;
+        }
+
+        return size;
     }
 
     private createContractIfNotExists(): void {

package/runtime/events/NetEvent.ts

@@ -1,23 +1,36 @@
 import { BytesWriter } from '../buffer/BytesWriter';
+import { Revert } from '../types/Revert';
 
 export const MAX_EVENT_DATA_SIZE: u32 = 352; // 352 bytes max per event.
 export const MAX_EVENTS: u16 = 1000; // 1000 events max per transactions.
 
 export abstract class NetEvent {
+    private readonly buffer: Uint8Array;
+
     protected constructor(
         public readonly eventType: string,
         protected data: BytesWriter,
-    ) {}
+    ) {
+        if (data.bufferLength() > MAX_EVENT_DATA_SIZE) {
+            throw new Error('Event data length exceeds maximum length.');
+        }
+
+        this.buffer = data.getBuffer();
+    }
 
     public get length(): u32 {
-        return this.data.bufferLength();
+        if (!this.buffer) {
+            throw new Revert('Buffer is not defined');
+        }
+
+        return this.buffer.byteLength;
     }
 
     public getEventData(): Uint8Array {
-        if (this.data.bufferLength() > MAX_EVENT_DATA_SIZE) {
-            throw new Error('Event data length exceeds maximum length.');
+        if (!this.buffer) {
+            throw new Revert('Buffer is not defined');
         }
 
-        return this.data.getBuffer();
+        return this.buffer;
     }
 }

package/runtime/exports/index.ts

@@ -20,18 +20,10 @@ export function getEvents(): Uint8Array {
     return Blockchain.getEvents();
 }
 
-export function getViewABI(): Uint8Array {
-    return Blockchain.getViewSelectors();
-}
-
 export function getMethodABI(): Uint8Array {
     return Blockchain.getMethodSelectors();
 }
 
-export function getWriteMethods(): Uint8Array {
-    return Blockchain.getWriteMethods();
-}
-
 export function setEnvironment(data: Uint8Array): void {
     Blockchain.setEnvironment(data);
 }

package/runtime/universal/ABIRegistry.ts

@@ -1,72 +1,27 @@
 import { encodeSelector, Selector } from '../math/abi';
 import { BytesReader } from '../buffer/BytesReader';
 import { BytesWriter } from '../buffer/BytesWriter';
-import { Map } from '../generic/Map';
 
 export type Calldata = NonNullable<BytesReader>;
-export type SelectorsMap = Map<u32, Uint8Array>;
 
 class ABIRegistryBase {
     private methodMap: Selector[] = [];
-    private selectors: SelectorsMap = new Map();
-
-    private viewSelectors: Selector[] = [];
-    private allowedWriteMethods: Selector[] = [];
-
-    // Register properties with their selectors and handlers
-    public defineGetterSelector(name: string, canWrite: boolean): void {
-        const selector: Selector = encodeSelector(name);
-
-        const selectorWriter: BytesWriter = new BytesWriter();
-        selectorWriter.writeABISelector(name, selector);
-
-        if (!this.selectors.has(selector)) {
-            this.selectors.set(selector, selectorWriter.getBuffer());
-        }
-
-        if (canWrite) this.addToWriteMethods(selector);
-
-        if (!this.viewSelectors.includes(selector)) {
-            this.viewSelectors.push(selector);
-        }
-    }
-
-    public getViewSelectors(): Uint8Array {
-        const writer: BytesWriter = new BytesWriter();
-        writer.writeViewSelectorMap(this.selectors);
-
-        return writer.getBuffer();
-    }
 
     public getMethodSelectors(): Uint8Array {
-        const writer: BytesWriter = new BytesWriter();
+        const writer: BytesWriter = new BytesWriter(2 + this.methodMap.length * 4);
         writer.writeMethodSelectorsMap(this.methodMap);
 
         return writer.getBuffer();
     }
 
-    public getWriteMethods(): Uint8Array {
-        const writer: BytesWriter = new BytesWriter();
-        writer.writeMethodSelectorsMap(this.allowedWriteMethods);
-
-        return writer.getBuffer();
-    }
-
     // Register methods with their selectors and handlers
-    public defineMethodSelector(name: string, canWrite: boolean): void {
+    public defineMethodSelector(name: string): void {
         const selector: u32 = encodeSelector(name);
-        if (canWrite) this.addToWriteMethods(selector);
 
         if (!this.methodMap.includes(selector)) {
             this.methodMap.push(selector);
         }
     }
-
-    private addToWriteMethods(selector: Selector): void {
-        if (!this.allowedWriteMethods.includes(selector)) {
-            this.allowedWriteMethods.push(selector);
-        }
-    }
 }
 
 export const ABIRegistry = new ABIRegistryBase();