@btc-vision/btc-runtime 1.4.6 → 1.5.0

package/runtime/env/BlockchainEnvironment.ts

@@ -3,27 +3,26 @@ import { BytesReader } from '../buffer/BytesReader';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { OP_NET } from '../contracts/OP_NET';
 import { NetEvent } from '../events/NetEvent';
-import { MapU256 } from '../generic/MapU256';
-import { DeployContractResponse } from '../interfaces/DeployContractResponse';
 import { Potential } from '../lang/Definitions';
-import { MemorySlotData } from '../memory/MemorySlot';
-import { MemorySlotPointer } from '../memory/MemorySlotPointer';
-import { PointerStorage } from '../types';
 import { Address } from '../types/Address';
-import { ADDRESS_BYTE_LENGTH, U256_BYTE_LENGTH } from '../utils/lengths';
+import { ADDRESS_BYTE_LENGTH } from '../utils';
 import { Block } from './classes/Block';
 import { Transaction } from './classes/Transaction';
 import {
     callContract,
     deployFromAddress,
     emit,
-    encodeAddress,
+    env_exit,
+    getCallResult,
     loadPointer,
     log,
+    sha256,
     storePointer,
     validateBitcoinAddress,
     verifySchnorrSignature,
 } from './global';
+import { eqUint, MapUint8Array } from '../generic/MapUint8Array';
+import { EMPTY_BUFFER } from '../math/bytes';
 
 export * from '../env/global';
 
@@ -37,7 +36,7 @@ export class BlockchainEnvironment {
 
     public readonly DEAD_ADDRESS: Address = Address.dead();
 
-    private storage: PointerStorage = new MapU256();
+    private storage: MapUint8Array = new MapUint8Array();
     private _selfContract: Potential<OP_NET> = null;
 
     private _block: Potential<Block> = null;
@@ -65,13 +64,13 @@ export class BlockchainEnvironment {
     private _contract: Potential<() => OP_NET> = null;
 
     public get contract(): OP_NET {
-        this.createContractIfNotExists();
-
         return this._selfContract as OP_NET;
     }
 
     public set contract(contract: () => OP_NET) {
         this._contract = contract;
+
+        this.createContractIfNotExists();
     }
 
     private _nextPointer: u16 = 0;
@@ -106,24 +105,28 @@ export class BlockchainEnvironment {
         return this._contractAddress as Address;
     }
 
-    public setEnvironment(data: Uint8Array): void {
+    public setEnvironmentVariables(data: Uint8Array): void {
         const reader: BytesReader = new BytesReader(data);
 
+        const blockHash = reader.readBytes(32);
+        const blockNumber = reader.readU64();
+        const blockMedianTime = reader.readU64();
+        const txHash = reader.readBytes(32);
+        const contractAddress = reader.readAddress();
+        const contractDeployer = reader.readAddress();
+        const caller = reader.readAddress();
+        const origin = reader.readAddress();
+
         this._tx = new Transaction(
-            reader.readAddress(),
-            reader.readAddress(),
-            reader.readBytes(32),
+            caller,
+            origin,
+            txHash,
         );
 
-        const currentBlock = reader.readU256();
-
-        this._contractDeployer = reader.readAddress();
-        this._contractAddress = reader.readAddress();
+        this._contractDeployer = contractDeployer;
+        this._contractAddress = contractAddress;
 
-        const medianTimestamp = reader.readU64();
-        const safeRnd64 = reader.readU64();
-
-        this._block = new Block(currentBlock, medianTimestamp, safeRnd64);
+        this._block = new Block(blockHash, blockNumber, blockMedianTime);
 
         this.createContractIfNotExists();
     }
@@ -137,143 +140,105 @@ export class BlockchainEnvironment {
             throw this.error('Destination contract is required');
         }
 
-        const call = new BytesWriter(ADDRESS_BYTE_LENGTH + calldata.bufferLength() + 4);
-        call.writeAddress(destinationContract);
-        call.writeBytesWithLength(calldata.getBuffer());
+        const resultLengthBuffer = new ArrayBuffer(32);
+        const status = callContract(destinationContract.buffer, calldata.getBuffer().buffer, calldata.bufferLength(), resultLengthBuffer);
+
+        const reader = new BytesReader(Uint8Array.wrap(resultLengthBuffer));
+        const resultLength = reader.readU32(true);
+        const resultBuffer = new ArrayBuffer(resultLength);
+        getCallResult(0, resultLength, resultBuffer);
 
-        const response: Uint8Array = callContract(call.getBuffer());
+        if (status !== 0) {
+            env_exit(status, resultBuffer, resultLength);
+        }
 
-        return new BytesReader(response);
+        return new BytesReader(Uint8Array.wrap(resultBuffer));
     }
 
     public log(data: string): void {
         const writer = new BytesWriter(data.length + 2);
-        writer.writeStringWithLength(data);
+        writer.writeString(data);
 
         const buffer = writer.getBuffer();
-        log(buffer);
+        log(buffer.buffer, buffer.length);
     }
 
     public emit(event: NetEvent): void {
         const data = event.getEventData();
-        const buffer = new BytesWriter(event.eventType.length + 6 + data.byteLength);
+        const writer = new BytesWriter(event.eventType.length + 6 + data.byteLength);
 
-        buffer.writeStringWithLength(event.eventType);
-        buffer.writeBytesWithLength(data);
+        writer.writeStringWithLength(event.eventType);
+        writer.writeBytesWithLength(data);
 
-        emit(buffer.getBuffer());
+        emit(writer.getBuffer().buffer, writer.bufferLength());
     }
 
     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);
-        writer.writeBytesU8Array(virtualAddress);
-
-        const buffer: Uint8Array = writer.getBuffer();
-        const cb: Potential<Uint8Array> = encodeAddress(buffer);
-        if (!cb) throw this.error('Failed to encode virtual address');
+        const result = validateBitcoinAddress(writer.getBuffer().buffer, address.length);
 
-        const reader: BytesReader = new BytesReader(cb as Uint8Array);
-        return reader.readAddress();
+        return result === 1;
     }
 
-    /*public deployContract(hash: u256, bytecode: Uint8Array): DeployContractResponse {
-        const writer = new BytesWriter(U256_BYTE_LENGTH + bytecode.length);
-        writer.writeU256(hash);
-        writer.writeBytes(bytecode);
-
-        const cb: Potential<Uint8Array> = deploy(writer.getBuffer());
-        if (!cb) throw this.error('Failed to deploy contract');
-
-        const reader: BytesReader = new BytesReader(cb as Uint8Array);
-        const virtualAddress: u256 = reader.readU256();
-        const contractAddress: Address = reader.readAddress();
-
-        return new DeployContractResponse(virtualAddress, contractAddress);
-    }*/
-
     public deployContractFromExisting(
         existingAddress: Address,
         salt: u256,
-    ): DeployContractResponse {
-        const writer = new BytesWriter(ADDRESS_BYTE_LENGTH + U256_BYTE_LENGTH);
-        writer.writeAddress(existingAddress);
-        writer.writeU256(salt);
+    ): Address {
+        const resultAddressBuffer = new ArrayBuffer(ADDRESS_BYTE_LENGTH);
 
-        const buffer: Uint8Array = writer.getBuffer();
-        const cb: Potential<Uint8Array> = deployFromAddress(buffer);
-        if (!cb) throw this.error('Failed to deploy contract');
+        const status = deployFromAddress(
+            existingAddress.buffer,
+            salt.toUint8Array(true).buffer,
+            resultAddressBuffer,
+        );
 
-        const reader: BytesReader = new BytesReader(cb as Uint8Array);
-        const virtualAddress: u256 = reader.readU256();
-        const contractAddress: Address = reader.readAddress();
+        if (status !== 0) {
+            throw this.error('Failed to deploy contract');
+        }
 
-        return new DeployContractResponse(virtualAddress, contractAddress);
+        const contractAddressReader = new BytesReader(Uint8Array.wrap(resultAddressBuffer));
+        return contractAddressReader.readAddress();
     }
 
-    // TODO: Change MemorySlotData type to a Uint8Array instead of a u256.
     public getStorageAt(
-        pointerHash: MemorySlotPointer,
-        defaultValue: MemorySlotData<u256>,
-    ): MemorySlotData<u256> {
-        this.ensureStorageAtPointer(pointerHash, defaultValue);
-
+        pointerHash: Uint8Array,
+    ): Uint8Array {
+        this.hasPointerStorageHash(pointerHash);
         if (this.storage.has(pointerHash)) {
             return this.storage.get(pointerHash);
         }
 
-        return defaultValue;
+        return new Uint8Array(32);
     }
 
-    /*public getNextPointerGreaterThan(
-        targetPointer: MemorySlotPointer,
-        valueAtLeast: u256,
-        lte: boolean = true,
-    ): MemorySlotData<u256> {
-        const writer = new BytesWriter(U256_BYTE_LENGTH * 2 + BOOLEAN_BYTE_LENGTH);
-        writer.writeU256(targetPointer);
-        writer.writeU256(valueAtLeast);
-        writer.writeBoolean(lte);
-
-        const result: Uint8Array = nextPointerGreaterThan(writer.getBuffer());
-        const reader: BytesReader = new BytesReader(result);
+    public sha256(buffer: Uint8Array): Uint8Array {
+        return sha256(buffer);
+    }
 
-        return reader.readU256();
-    }*/
+    public hash256(buffer: Uint8Array): Uint8Array {
+        return sha256(sha256(buffer));
+    }
 
     public verifySchnorrSignature(
         publicKey: Address,
         signature: Uint8Array,
         hash: Uint8Array,
     ): boolean {
-        const writer = new BytesWriter(ADDRESS_BYTE_LENGTH + 64 + 32);
-        writer.writeBytes(publicKey);
-        writer.writeBytes(signature);
-        writer.writeBytes(hash);
+        const result: u32 = verifySchnorrSignature(publicKey.buffer, signature.buffer, hash.buffer);
 
-        const result: Uint8Array = verifySchnorrSignature(writer.getBuffer());
-
-        const reader = new BytesReader(result);
-        return reader.readBoolean();
+        return result === 1;
     }
 
-    // TODO: Change MemorySlotData type to a Uint8Array instead of a u256.
-    public hasStorageAt(pointerHash: MemorySlotPointer): bool {
+    public hasStorageAt(pointerHash: Uint8Array): 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);
+        const val: Uint8Array = this.getStorageAt(pointerHash);
 
-        return u256.ne(val, u256.Zero);
+        return !eqUint(val, EMPTY_BUFFER);
     }
 
-    public setStorageAt(pointerHash: MemorySlotPointer, value: MemorySlotData<u256>): void {
+    public setStorageAt(pointerHash: Uint8Array, value: Uint8Array): void {
         this._internalSetStorageAt(pointerHash, value);
     }
 
@@ -291,47 +256,24 @@ export class BlockchainEnvironment {
         return runtimeError(msg);
     }
 
-    private _internalSetStorageAt(pointerHash: u256, value: MemorySlotData<u256>): void {
+    private _internalSetStorageAt(pointerHash: Uint8Array, value: Uint8Array): void {
         this.storage.set(pointerHash, value);
 
-        const writer: BytesWriter = new BytesWriter(U256_BYTE_LENGTH * 2);
-        writer.writeU256(pointerHash);
-        writer.writeU256(value);
-
-        const buffer: Uint8Array = writer.getBuffer();
-        storePointer(buffer);
+        storePointer(pointerHash.buffer, value.buffer);
     }
 
-    private hasPointerStorageHash(pointer: MemorySlotPointer): bool {
+    private hasPointerStorageHash(pointer: Uint8Array): bool {
         if (this.storage.has(pointer)) {
             return true;
         }
 
         // we attempt to load the requested pointer.
-        const writer = new BytesWriter(U256_BYTE_LENGTH);
-        writer.writeU256(pointer);
+        const resultBuffer = new ArrayBuffer(32);
+        loadPointer(pointer.buffer, resultBuffer);
 
-        const result: Uint8Array = loadPointer(writer.getBuffer());
-        const reader: BytesReader = new BytesReader(result);
-
-        const value: u256 = reader.readU256();
+        const value: Uint8Array = Uint8Array.wrap(resultBuffer);
         this.storage.set(pointer, value); // cache the value
 
-        return !u256.eq(value, u256.Zero);
-    }
-
-    private ensureStorageAtPointer(
-        pointerHash: MemorySlotPointer,
-        defaultValue: MemorySlotData<u256>,
-    ): void {
-        if (this.hasPointerStorageHash(pointerHash)) {
-            return;
-        }
-
-        if (u256.eq(defaultValue, u256.Zero)) {
-            return;
-        }
-
-        this._internalSetStorageAt(pointerHash, defaultValue);
+        return !eqUint(value, EMPTY_BUFFER);
     }
 }

package/runtime/env/classes/Block.ts

@@ -2,17 +2,13 @@ import { u256 } from '@btc-vision/as-bignum/assembly';
 
 @final
 export class Block {
-    private readonly u64BlockNumber: u64;
+    public readonly numberU256: u256;
 
     public constructor(
-        public readonly number: u256,
+        public readonly hash: Uint8Array,
+        public readonly number: u64,
         public readonly medianTimestamp: u64,
-        public readonly safeRnd64: u64,
     ) {
-        this.u64BlockNumber = number.toU64();
-    }
-
-    public get numberU64(): u64 {
-        return this.u64BlockNumber;
+        this.numberU256 = u256.fromU64(number);
     }
 }

package/runtime/env/classes/Transaction.ts

@@ -2,15 +2,16 @@ import { Address } from '../../types/Address';
 import { TransactionInput, TransactionOutput } from './UTXO';
 import { Potential } from '../../lang/Definitions';
 import { BytesReader } from '../../buffer/BytesReader';
-import { inputs, outputs } from '../global';
+import { getInputsSize, getOutputsSize, inputs, outputs } from '../global';
 
 @final
 export class Transaction {
     public constructor(
         public readonly sender: Address, // "immediate caller"
         public readonly origin: Address, // "leftmost thing in the call chain"
-        public readonly id: Uint8Array,
-    ) {}
+        public readonly hash: Uint8Array,
+    ) {
+    }
 
     private _inputs: Potential<TransactionInput[]> = null;
 
@@ -39,14 +40,20 @@ export class Transaction {
     }
 
     private loadInputs(): TransactionInput[] {
-        const buffer = new BytesReader(inputs());
+        const inputsSize = getInputsSize();
+        let resultBuffer = new ArrayBuffer(inputsSize);
+        inputs(resultBuffer);
 
-        return buffer.readTransactionInputs();
+        const reader = new BytesReader(Uint8Array.wrap(resultBuffer));
+        return reader.readTransactionInputs();
     }
 
     private loadOutputs(): TransactionOutput[] {
-        const buffer = new BytesReader(outputs());
+        const outputsSize = getOutputsSize();
+        let resultBuffer = new ArrayBuffer(outputsSize);
+        outputs(resultBuffer);
 
-        return buffer.readTransactionOutputs();
+        const reader = new BytesReader(Uint8Array.wrap(resultBuffer));
+        return reader.readTransactionOutputs();
     }
 }

package/runtime/env/classes/UTXO.ts

@@ -4,7 +4,8 @@ export class TransactionInput {
         public readonly txId: Uint8Array,
         public readonly outputIndex: u8,
         public readonly scriptSig: Uint8Array,
-    ) {}
+    ) {
+    }
 }
 
 @final
@@ -13,5 +14,6 @@ export class TransactionOutput {
         public readonly index: u8,
         public readonly to: string,
         public readonly value: u64,
-    ) {}
+    ) {
+    }
 }

package/runtime/env/global.ts

@@ -1,6 +1,14 @@
+// @ts-ignore
+@external('env', 'environment')
+export declare function getEnvironmentVariables(offset: u32, length: u32, result: ArrayBuffer): void;
+
+// @ts-ignore
+@external('env', 'calldata')
+export declare function getCalldata(offset: u32, length: u32, result: ArrayBuffer): void;
+
 // @ts-ignore
 @external('env', 'load')
-export declare function loadPointer(data: Uint8Array): Uint8Array;
+export declare function loadPointer(key: ArrayBuffer, result: ArrayBuffer): void;
 
 // @ts-ignore
 @external('env', 'nextPointerGreaterThan')
@@ -8,52 +16,73 @@ export declare function nextPointerGreaterThan(data: Uint8Array): Uint8Array;
 
 // @ts-ignore
 @external('env', 'store')
-export declare function storePointer(data: Uint8Array): Uint8Array;
-
-// @ts-ignore
-@external('env', 'deploy')
-export declare function deploy(data: Uint8Array): Uint8Array;
+export declare function storePointer(key: ArrayBuffer, value: ArrayBuffer): void;
 
 // @ts-ignore
 @external('env', 'deployFromAddress')
-export declare function deployFromAddress(data: Uint8Array): Uint8Array;
+export declare function deployFromAddress(originAddress: ArrayBuffer, salt: ArrayBuffer, resultAddress: ArrayBuffer): u32;
 
 // @ts-ignore
 @external('env', 'call')
-export declare function callContract(data: Uint8Array): Uint8Array;
+export declare function callContract(address: ArrayBuffer, calldata: ArrayBuffer, calldataLength: u32, resultLength: ArrayBuffer): u32;
 
 // @ts-ignore
-@external('env', 'log')
-export declare function log(data: Uint8Array): void;
+@external('env', 'callResult')
+export declare function getCallResult(offset: u32, length: u32, result: ArrayBuffer): void;
 
 // @ts-ignore
-@external('env', 'emit')
-export declare function emit(data: Uint8Array): void;
+@external('debug', 'log')
+export declare function log(data: ArrayBuffer, dataLength: u32): void;
 
 // @ts-ignore
-@external('env', 'encodeAddress')
-export declare function encodeAddress(data: Uint8Array): Uint8Array;
+@external('env', 'emit')
+export declare function emit(data: ArrayBuffer, dataLength: u32): void;
 
 // @ts-ignore
 @external('env', 'sha256')
-export declare function sha256(data: Uint8Array): Uint8Array;
+export declare function _sha256(data: ArrayBuffer, dataLength: u32, result: ArrayBuffer): void;
+
+export function sha256(data: Uint8Array): Uint8Array {
+    const resultBuffer = new ArrayBuffer(32);
+    _sha256(data.buffer, data.length, resultBuffer);
+    return Uint8Array.wrap(resultBuffer);
+}
 
 // @ts-ignore
 @external('env', 'ripemd160')
-export declare function ripemd160(data: Uint8Array): Uint8Array;
+export declare function _ripemd160(data: ArrayBuffer, dataLength: u32, result: ArrayBuffer): void;
+
+export function ripemd160(data: Uint8Array): Uint8Array {
+    const resultBuffer = new ArrayBuffer(20);
+    _ripemd160(data.buffer, data.length, resultBuffer);
+
+    return Uint8Array.wrap(resultBuffer);
+}
 
 // @ts-ignore
 @external('env', 'validateBitcoinAddress')
-export declare function validateBitcoinAddress(data: Uint8Array): Uint8Array;
+export declare function validateBitcoinAddress(address: ArrayBuffer, addressLength: u32): u32;
 
 // @ts-ignore
 @external('env', 'inputs')
-export declare function inputs(): Uint8Array;
+export declare function inputs(result: ArrayBuffer): void;
+
+// @ts-ignore
+@external('env', 'inputsSize')
+export declare function getInputsSize(): u32;
 
 // @ts-ignore
 @external('env', 'outputs')
-export declare function outputs(): Uint8Array;
+export declare function outputs(result: ArrayBuffer): void;
+
+// @ts-ignore
+@external('env', 'outputsSize')
+export declare function getOutputsSize(): u32;
 
 // @ts-ignore
 @external('env', 'verifySchnorrSignature')
-export declare function verifySchnorrSignature(data: Uint8Array): Uint8Array;
+export declare function verifySchnorrSignature(publicKey: ArrayBuffer, signature: ArrayBuffer, message: ArrayBuffer): u32;
+
+// @ts-ignore
+@external('env', 'exit')
+export declare function env_exit(status: u32, data: ArrayBuffer, dataLength: u32): void;

package/runtime/events/predefined/MintEvent.ts

@@ -1,7 +1,7 @@
 import { u256 } from '@btc-vision/as-bignum/assembly';
 import { BytesWriter } from '../../buffer/BytesWriter';
 import { Address } from '../../types/Address';
-import { ADDRESS_BYTE_LENGTH, U256_BYTE_LENGTH } from '../../utils/lengths';
+import { ADDRESS_BYTE_LENGTH, U256_BYTE_LENGTH } from '../../utils';
 import { NetEvent } from '../NetEvent';
 
 @final

package/runtime/exports/index.ts

@@ -3,24 +3,45 @@ import { BytesWriter } from '../buffer/BytesWriter';
 import { BytesReader } from '../buffer/BytesReader';
 import { Selector } from '../math/abi';
 import { Calldata } from '../types';
+import { env_exit, getCalldata, getEnvironmentVariables } from '../env/global';
 
-export function execute(data: Uint8Array): Uint8Array {
-    const calldata: Calldata = new BytesReader(data);
+const ENVIRONMENT_VARIABLES_BYTE_LENGTH: u32 = 208;
+
+export function execute(calldataLength: u32): u32 {
+    const environmentVariablesBuffer = new ArrayBuffer(ENVIRONMENT_VARIABLES_BYTE_LENGTH);
+    getEnvironmentVariables(0, ENVIRONMENT_VARIABLES_BYTE_LENGTH, environmentVariablesBuffer);
+    Blockchain.setEnvironmentVariables(Uint8Array.wrap(environmentVariablesBuffer));
+
+    const calldataBuffer = new ArrayBuffer(calldataLength);
+    getCalldata(0, calldataLength, calldataBuffer);
+
+    const calldata: Calldata = new BytesReader(Uint8Array.wrap(calldataBuffer));
     const selector: Selector = calldata.readSelector();
     const result: BytesWriter = Blockchain.contract.execute(selector, calldata);
 
     Blockchain.contract.onExecutionCompleted();
 
-    return result.getBuffer();
+    const resultBuffer = result.getBuffer().buffer;
+    const resultLength = resultBuffer.byteLength;
+    if (resultLength > 0) {
+        env_exit(0, resultBuffer, resultLength);
+    }
+
+    return 0;
 }
 
-export function onDeploy(data: Uint8Array): void {
-    const calldata: Calldata = new BytesReader(data);
+export function onDeploy(calldataLength: u32): u32 {
+    const environmentVariablesBuffer = new ArrayBuffer(ENVIRONMENT_VARIABLES_BYTE_LENGTH);
+    getEnvironmentVariables(0, ENVIRONMENT_VARIABLES_BYTE_LENGTH, environmentVariablesBuffer);
+    Blockchain.setEnvironmentVariables(Uint8Array.wrap(environmentVariablesBuffer));
+
+    const calldataBuffer = new ArrayBuffer(calldataLength);
+    getCalldata(0, calldataLength, calldataBuffer);
+
+    const calldata: Calldata = new BytesReader(Uint8Array.wrap(calldataBuffer));
 
     Blockchain.contract.onDeployment(calldata);
     Blockchain.contract.onExecutionCompleted();
-}
 
-export function setEnvironment(data: Uint8Array): void {
-    Blockchain.setEnvironment(data);
+    return 0;
 }

package/runtime/generic/AddressMap.ts

@@ -4,14 +4,16 @@ import { Address } from '../types/Address';
 
 @final
 export class AddressMap<V> extends Map<Address, V> {
-    public set(key: Address, value: V): void {
-        const index: i32 = this._keys.indexOf(key);
-        if (index == -1) {
+    public set(key: Address, value: V): this {
+        const index: i32 = this.indexOf(key);
+        if (index === -1) {
             this._keys.push(key);
             this._values.push(value);
         } else {
             this._values[index] = value;
         }
+
+        return this;
     }
 
     public indexOf(address: Address): i32 {
@@ -38,7 +40,7 @@ export class AddressMap<V> extends Map<Address, V> {
 
     public get(key: Address): V {
         const index: i32 = this.indexOf(key);
-        if (index == -1) {
+        if (index === -1) {
             throw new Revert('Key not found in map (AddressMap)');
         }
         return this._values[index];
@@ -46,7 +48,7 @@ export class AddressMap<V> extends Map<Address, V> {
 
     public delete(key: Address): bool {
         const index: i32 = this.indexOf(key);
-        if (index == -1) {
+        if (index === -1) {
             return false;
         }