@btc-vision/btc-runtime 1.2.5 → 1.3.0

package/README.md

@@ -42,17 +42,17 @@ execution while integrating deeply with Bitcoin's decentralized architecture.
 ## Installation
 
 1. Clone the repository:
-   ```bash
-   git clone https://github.com/btc-vision/btc-runtime.git
-   ```
+    ```bash
+    git clone https://github.com/btc-vision/btc-runtime.git
+    ```
 2. Navigate to the repository directory:
-   ```bash
-   cd btc-runtime
-   ```
+    ```bash
+    cd btc-runtime
+    ```
 3. Install the necessary dependencies:
-   ```bash
-   npm install
-   ```
+    ```bash
+    npm install
+    ```
 
 ## Core Concepts
 
@@ -95,59 +95,95 @@ Here is a real-world example of how to create a basic token contract using the O
 contract follows the OP20 standard.
 
 ```typescript
-import { u128, u256 } from 'as-bignum/assembly';
 import {
-    Address, Blockchain,
+    Address,
+    Blockchain,
     BytesWriter,
     Calldata,
+    DeployableOP_20,
     encodeSelector,
     Map,
     OP20InitParameters,
     Selector,
+    AddressMap
 } from '@btc-vision/btc-runtime/runtime';
-import { DeployableOP_20 } from '@btc-vision/btc-runtime/runtime/contracts/DeployableOP_20';
+import { u128, u256 } from 'as-bignum/assembly';
 
 @final
 export class MyToken extends DeployableOP_20 {
-    constructor() {
+    public constructor() {
         super();
 
-        // DO NOT USE TO DEFINE VARIABLE THAT ARE NOT CONSTANT. SEE "solidityLikeConstructor" BELOW.
+        // IMPORTANT. THIS WILL RUN EVERYTIME THE CONTRACT IS INTERACTED WITH. FOR SPECIFIC INITIALIZATION, USE "onDeployment" METHOD.
     }
 
-    // "solidityLikeConstructor" This is a solidity-like constructor. This method will only run once.
-    public onInstantiated(): void {
-        if (!this.isInstantiated) {
-            super.onInstantiated(); // IMPORTANT.
-
-            const maxSupply: u256 = u128.fromString('100000000000000000000000000').toU256(); // Your max supply.
-            const decimals: u8 = 18; // Your decimals.
-            const name: string = 'MyToken'; // Your token name.
-            const symbol: string = 'TOKEN'; // Your token symbol.
+    // "solidityLikeConstructor" This is a solidity-like constructor. This method will only run once when the contract is deployed.
+    public override onDeployment(_calldata: Calldata): void {
+        const maxSupply: u256 = u128.fromString('100000000000000000000000000').toU256(); // Your max supply.
+        const decimals: u8 = 18; // Your decimals.
+        const name: string = 'MyToken'; // Your token name.
+        const symbol: string = 'TOKEN'; // Your token symbol.
 
-            this.instantiate(new OP20InitParameters(maxSupply, decimals, name, symbol));
+        this.instantiate(new OP20InitParameters(maxSupply, decimals, name, symbol));
 
-            // Add your logic here. Eg, minting the initial supply:
-            // this._mint(Blockchain.origin, maxSupply);
-        }
+        // Add your logic here. Eg, minting the initial supply:
+        this._mint(Blockchain.tx.origin, maxSupply);
     }
 
-    public override callMethod(method: Selector, calldata: Calldata): BytesWriter {
+    public override execute(method: Selector, calldata: Calldata): BytesWriter {
         switch (method) {
+            case encodeSelector('airdrop'):
+                return this.airdrop(calldata);
+            case encodeSelector('airdropWithAmount'):
+                return this.airdropWithAmount(calldata);
             default:
-                return super.callMethod(method, calldata);
+                return super.execute(method, calldata);
         }
     }
-}
-```
 
-### Emitting Events
+    private airdrop(calldata: Calldata): BytesWriter {
+        this.onlyOwner(Blockchain.tx.sender);
 
-```typescript
-class MyContract extends OP_NET {
-    public someAction(): void {
-        const event = new CustomEvent(Blockchain.sender, u256.fromU32(100));
-        this.emitEvent(event);
+        const drops: AddressMap<u256> = calldata.readAddressValueTuple();
+
+        const addresses: Address[] = drops.keys();
+        for (let i: i32 = 0; i < addresses.length; i++) {
+            const address = addresses[i];
+            const amount = drops.get(address);
+
+            this._mint(address, amount, false);
+        }
+
+        const writer: BytesWriter = new BytesWriter(1);
+        writer.writeBoolean(true);
+
+        return writer;
+    }
+
+    private _optimizedMint(address: Address, amount: u256): void {
+        this.balanceOfMap.set(address, amount);
+
+        this._totalSupply.addNoCommit(amount);
+
+        this.createMintEvent(address, amount);
+    }
+
+    private airdropWithAmount(calldata: Calldata): BytesWriter {
+        this.onlyOwner(Blockchain.tx.sender);
+
+        const amount: u256 = calldata.readU256();
+        const addresses: Address[] = calldata.readAddressArray();
+
+        for (let i: i32 = 0; i < addresses.length; i++) {
+            this._optimizedMint(addresses[i], amount);
+        }
+
+        this._totalSupply.commit();
+
+        const writer: BytesWriter = new BytesWriter(1);
+        writer.writeBoolean(true);
+
+        return writer;
     }
 }
 ```

package/package.json

@@ -1,10 +1,11 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.2.5",
+    "version": "1.3.0",
     "description": "Bitcoin Smart Contract Runtime",
     "main": "btc/index.ts",
     "scripts": {
-        "build": "cross-env node scripts/asc tests/tests.ts"
+        "build": "cross-env node scripts/asc tests/tests.ts",
+        "test": "ts-mocha tests/**/*.spec.ts"
     },
     "types": "btc/index.ts",
     "keywords": [
@@ -20,7 +21,7 @@
     "license": "MIT",
     "devDependencies": {
         "@types/mocha": "^10.0.8",
-        "@types/node": "^22.5.5",
+        "@types/node": "^22.7.5",
         "assemblyscript": "^0.27.30",
         "cross-env": "^7.0.3",
         "fs-extra": "^11.2.0",
@@ -45,8 +46,10 @@
         "@eslint/js": "^9.10.0",
         "as-bignum": "^0.3.0",
         "gulplog": "^2.2.0",
+        "mocha": "^10.7.3",
         "ts-node": "^10.9.2",
         "typescript": "^5.6.2",
-        "typescript-eslint": "^8.6.0"
+        "typescript-eslint": "^8.6.0",
+        "yargs": "^17.7.2"
     }
 }

package/runtime/buffer/BytesReader.ts

@@ -2,10 +2,10 @@ import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
 import { Selector } from '../math/abi';
 import { i128, u128, u256 } from 'as-bignum/assembly';
 import { Revert } from '../types/Revert';
-import { Map } from '../generic/Map';
 import { TransactionInput, TransactionOutput } from '../env/classes/UTXO';
 import { StaticArray } from 'staticarray';
 import { i256 } from '../math/i256';
+import { AddressMap } from '../generic/AddressMap';
 
 @final
 export class BytesReader {
@@ -107,8 +107,8 @@ export class BytesReader {
         return bytes;
     }
 
-    public readMultiBytesAddressMap(): Map<Address, Uint8Array[]> {
-        const map: Map<Address, Uint8Array[]> = new Map<Address, Uint8Array[]>();
+    public readMultiBytesAddressMap(): AddressMap<Uint8Array[]> {
+        const map: AddressMap<Uint8Array[]> = new AddressMap<Uint8Array[]>();
         const size: u8 = this.readU8();
 
         if (size > 8) throw new Revert('Too many contract called.');
@@ -192,9 +192,9 @@ export class BytesReader {
         return result;
     }
 
-    public readAddressValueTuple(): Map<Address, u256> {
+    public readAddressValueTuple(): AddressMap<u256> {
         const length: u16 = this.readU16();
-        const result = new Map<Address, u256>();
+        const result = new AddressMap<u256>();
 
         for (let i: u16 = 0; i < length; i++) {
             const address = this.readAddress();
@@ -230,7 +230,12 @@ export class BytesReader {
     }
 
     public readAddress(): Address {
-        return this.readString(<u16>ADDRESS_BYTE_LENGTH);
+        const bytes: Address = new Address();
+        for (let i: u32 = 0; i < u32(ADDRESS_BYTE_LENGTH); i++) {
+            bytes[i] = this.readU8();
+        }
+
+        return bytes;
     }
 
     public getOffset(): i32 {

package/runtime/buffer/BytesWriter.ts

@@ -3,9 +3,9 @@ import { Address, ADDRESS_BYTE_LENGTH } from '../types/Address';
 import { Selector } from '../math/abi';
 import { BytesReader } from './BytesReader';
 import { Revert } from '../types/Revert';
-import { Map } from '../generic/Map';
 import { ArrayBuffer } from 'arraybuffer';
 import { i256 } from '../math/i256';
+import { AddressMap } from '../generic/AddressMap';
 
 @final
 export class BytesWriter {
@@ -154,7 +154,7 @@ export class BytesWriter {
         this.writeString(value);
     }
 
-    public writeAddressValueTupleMap(map: Map<Address, u256>): void {
+    public writeAddressValueTupleMap(map: AddressMap<u256>): void {
         if (map.size > 65535) throw new Revert('Map size is too large');
 
         /*const requiredSize: u32 = 2 + map.size * (ADDRESS_BYTE_LENGTH + 32);
@@ -177,7 +177,7 @@ export class BytesWriter {
         }
     }
 
-    public writeLimitedAddressBytesMap(map: Map<Address, Uint8Array[]>): void {
+    public writeLimitedAddressBytesMap(map: AddressMap<Uint8Array[]>): void {
         if (map.size > 8) throw new Revert('Too many contract called.'); // no more than 8 different contracts.
 
         /*let requiredSize: u32 = 1 + (map.size * ADDRESS_BYTE_LENGTH + 1);
@@ -269,22 +269,14 @@ export class BytesWriter {
         return value1 < value2 ? value1 : value2;
     }
 
-    private fromAddress(value: Address): Uint8Array {
-        if (value.length > ADDRESS_BYTE_LENGTH) {
-            throw new Revert(`Address is too long ${value.length} > ${ADDRESS_BYTE_LENGTH} bytes`);
-        }
-
-        const length: i32 = this.min(value.length + 1, ADDRESS_BYTE_LENGTH);
-        const bytes: Uint8Array = new Uint8Array(length);
-        for (let i: i32 = 0; i < value.length; i++) {
-            bytes[i] = value.charCodeAt(i);
-        }
-
-        if (value.length < ADDRESS_BYTE_LENGTH) {
-            bytes[value.length] = 0;
+    private fromAddress(pubKey: Address): Uint8Array {
+        if (pubKey.byteLength > ADDRESS_BYTE_LENGTH) {
+            throw new Revert(
+                `Address is too long ${pubKey.byteLength} > ${ADDRESS_BYTE_LENGTH} bytes`,
+            );
         }
 
-        return bytes;
+        return pubKey;
     }
 
     private resize(size: u32): void {

package/runtime/contracts/DeployableOP_20.ts

@@ -12,10 +12,10 @@ import { Address } from '../types/Address';
 import { Revert } from '../types/Revert';
 import { SafeMath } from '../types/SafeMath';
 
+import { Calldata } from '../types';
 import { IOP_20 } from './interfaces/IOP_20';
 import { OP20InitParameters } from './interfaces/OP20InitParameters';
 import { OP_NET } from './OP_NET';
-import { Calldata } from '../types';
 
 const maxSupplyPointer: u16 = Blockchain.nextPointer;
 const decimalsPointer: u16 = Blockchain.nextPointer;
@@ -27,7 +27,7 @@ const balanceOfMapPointer: u16 = Blockchain.nextPointer;
 
 export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     protected readonly allowanceMap: MultiAddressMemoryMap<Address, Address, MemorySlotData<u256>>;
-    protected readonly balanceOfMap: AddressMemoryMap<Address, MemorySlotData<u256>>;
+    protected readonly balanceOfMap: AddressMemoryMap<MemorySlotData<u256>>;
 
     protected readonly _maxSupply: StoredU256;
     protected readonly _decimals: StoredU256;
@@ -42,7 +42,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
             u256.Zero,
         );
 
-        this.balanceOfMap = new AddressMemoryMap<Address, MemorySlotData<u256>>(
+        this.balanceOfMap = new AddressMemoryMap<MemorySlotData<u256>>(
             balanceOfMapPointer,
             u256.Zero,
         );
@@ -150,15 +150,6 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         return response;
     }
 
-    public mint(callData: Calldata): BytesWriter {
-        const response = new BytesWriter(1);
-        const resp = this._mint(callData.readAddress(), callData.readU256());
-
-        response.writeBoolean(resp);
-
-        return response;
-    }
-
     public transfer(callData: Calldata): BytesWriter {
         const response = new BytesWriter(1);
         const resp = this._transfer(callData.readAddress(), callData.readU256());
@@ -213,8 +204,6 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
                 return this.balanceOf(calldata);
             case encodeSelector('burn'):
                 return this.burn(calldata);
-            case encodeSelector('mint'):
-                return this.mint(calldata);
             case encodeSelector('transfer'):
                 return this.transfer(calldata);
             case encodeSelector('transferFrom'):
@@ -297,7 +286,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         return true;
     }
 
-    protected _transfer(to: string, value: u256): boolean {
+    protected _transfer(to: Address, value: u256): boolean {
         const sender = Blockchain.tx.sender;
 
         if (!this.balanceOfMap.has(sender)) throw new Revert();
@@ -317,7 +306,6 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         const newToBalance: u256 = SafeMath.add(toBalance, value);
 
         this.balanceOfMap.set(to, newToBalance);
-
         this.createTransferEvent(sender, to, value);
 
         return true;

package/runtime/contracts/OP_NET.ts

@@ -8,11 +8,11 @@ import { MAX_EVENT_DATA_SIZE, NetEvent } from '../events/NetEvent';
 import { Calldata } from '../types';
 
 export class OP_NET implements IBTC {
-    public get address(): string {
+    public get address(): Address {
         return Blockchain.contractAddress;
     }
 
-    public get owner(): string {
+    public get owner(): Address {
         return Blockchain.owner;
     }
 

package/runtime/contracts/interfaces/IOP_20.ts

@@ -16,6 +16,4 @@ export interface IOP_20 {
     allowance(callData: Calldata): BytesWriter;
 
     burn(callData: Calldata): BytesWriter;
-
-    mint(callData: Calldata): BytesWriter;
 }

package/runtime/env/BlockchainEnvironment.ts

@@ -3,7 +3,6 @@ import { MemorySlotPointer } from '../memory/MemorySlotPointer';
 import { MemorySlotData } from '../memory/MemorySlot';
 import { u256 } from 'as-bignum/assembly';
 import { BytesReader } from '../buffer/BytesReader';
-import { encodePointerHash } from '../math/abi';
 import { BytesWriter } from '../buffer/BytesWriter';
 import { NetEvent } from '../events/NetEvent';
 import { Potential } from '../lang/Definitions';
@@ -34,7 +33,7 @@ export function runtimeError(msg: string): Error {
 export class BlockchainEnvironment {
     private static readonly MAX_U16: u16 = 65535;
 
-    public readonly DEAD_ADDRESS: Address = 'bc1dead';
+    public readonly DEAD_ADDRESS: Address = Address.dead();
 
     private storage: PointerStorage = new MapU256();
     private _selfContract: Potential<OP_NET> = null;
@@ -128,7 +127,7 @@ export class BlockchainEnvironment {
     }
 
     public call(destinationContract: Address, calldata: BytesWriter): BytesReader {
-        if (destinationContract === this._contractAddress) {
+        if (destinationContract === this.contractAddress) {
             throw this.error('Cannot call self');
         }
 
@@ -163,9 +162,10 @@ export class BlockchainEnvironment {
         emit(buffer.getBuffer());
     }
 
-    public encodeVirtualAddress(virtualAddress: Uint8Array): Address {
-        const writer: BytesWriter = new BytesWriter(virtualAddress.byteLength + 4);
-        writer.writeBytesWithLength(virtualAddress);
+    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);
@@ -210,11 +210,9 @@ export class BlockchainEnvironment {
     }
 
     public getStorageAt(
-        pointer: u16,
-        subPointer: MemorySlotPointer,
+        pointerHash: MemorySlotPointer,
         defaultValue: MemorySlotData<u256>,
     ): MemorySlotData<u256> {
-        const pointerHash: MemorySlotPointer = encodePointerHash(pointer, subPointer);
         this.ensureStorageAtPointer(pointerHash, defaultValue);
 
         if (this.storage.has(pointerHash)) {
@@ -224,20 +222,14 @@ export class BlockchainEnvironment {
         return defaultValue;
     }
 
-    public hasStorageAt(pointer: u16, subPointer: MemorySlotPointer): bool {
+    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(pointer, subPointer, u256.Zero);
+        const val: u256 = this.getStorageAt(pointerHash, u256.Zero);
 
         return u256.ne(val, u256.Zero);
     }
 
-    public setStorageAt(
-        pointer: u16,
-        keyPointer: MemorySlotPointer,
-        value: MemorySlotData<u256>,
-    ): void {
-        const pointerHash: u256 = encodePointerHash(pointer, keyPointer);
-
+    public setStorageAt(pointerHash: MemorySlotPointer, value: MemorySlotData<u256>): void {
         this._internalSetStorageAt(pointerHash, value);
     }
 
@@ -288,12 +280,14 @@ export class BlockchainEnvironment {
         pointerHash: MemorySlotPointer,
         defaultValue: MemorySlotData<u256>,
     ): void {
-        if (!this.hasPointerStorageHash(pointerHash)) {
-            if (u256.eq(defaultValue, u256.Zero)) {
-                return;
-            }
+        if (this.hasPointerStorageHash(pointerHash)) {
+            return;
+        }
 
-            this._internalSetStorageAt(pointerHash, defaultValue);
+        if (u256.eq(defaultValue, u256.Zero)) {
+            return;
         }
+
+        this._internalSetStorageAt(pointerHash, defaultValue);
     }
 }

package/runtime/generic/AddressMap.ts

@@ -0,0 +1,62 @@
+import { Revert } from '../types/Revert';
+import { Map } from './Map';
+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) {
+            this._keys.push(key);
+            this._values.push(value);
+        } else {
+            this._values[index] = value;
+        }
+    }
+
+    public indexOf(address: Address): i32 {
+        for (let i: i32 = 0; i < this._keys.length; i++) {
+            const key = this._keys[i];
+
+            if (address.equals(key)) {
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    public has(key: Address): bool {
+        for (let i: i32 = 0; i < this._keys.length; i++) {
+            if (key.equals(this._keys[i])) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public get(key: Address): V {
+        const index: i32 = this.indexOf(key);
+        if (index == -1) {
+            throw new Revert('Key not found in map');
+        }
+        return this._values[index];
+    }
+
+    public delete(key: Address): bool {
+        const index: i32 = this.indexOf(key);
+        if (index == -1) {
+            return false;
+        }
+
+        this._keys.splice(index, 1);
+        this._values.splice(index, 1);
+
+        return true;
+    }
+
+    public getAddresses(): Address[] {
+        return this._keys;
+    }
+}

package/runtime/generic/Map.ts

@@ -27,7 +27,13 @@ export class Map<K, V> {
     }
 
     public indexOf(key: K): i32 {
-        return this._keys.indexOf(key);
+        for (let i: i32 = 0; i < this._keys.length; i++) {
+            if (this._keys[i] == key) {
+                return i;
+            }
+        }
+
+        return -1;
     }
 
     public get(key: K): V {
@@ -39,13 +45,7 @@ export class Map<K, V> {
     }
 
     public has(key: K): bool {
-        for (let i: i32 = 0; i < this._keys.length; i++) {
-            if (this._keys[i] == key) {
-                return true;
-            }
-        }
-
-        return false;
+        return this.indexOf(key) != -1;
     }
 
     public delete(key: K): bool {
@@ -53,6 +53,7 @@ export class Map<K, V> {
         if (index == -1) {
             return false;
         }
+
         this._keys.splice(index, 1);
         this._values.splice(index, 1);
         return true;

package/runtime/index.ts

@@ -13,6 +13,7 @@ export * from './buffer/BytesReader';
 export * from './buffer/BytesWriter';
 
 /** Interfaces */
+export * from './interfaces/IBTC';
 export * from './interfaces/DeployContractResponse';
 
 /** Events */
@@ -24,9 +25,12 @@ export * from './env/classes/UTXO';
 export * from './env/classes/Transaction';
 export * from './env/classes/Block';
 
-/** Types */
+/** Maps */
 export * from './generic/Map';
-export * from './interfaces/IBTC';
+export * from './generic/MapU256';
+export * from './generic/AddressMap';
+
+/** Types */
 export * from './types';
 
 /** Definitions */
@@ -42,24 +46,34 @@ export * from './math/cyrb53';
 export * from './math/sha256';
 export * from './math/rnd';
 export * from './math/i256';
+export * from './secp256k1/ECPoint';
 
 /** Memory */
 export * from './memory/AddressMemoryMap';
+export * from './memory/StringMemoryMap';
+export * from './memory/MultiStringMemoryMap';
 export * from './memory/MemorySlot';
 export * from './memory/MemorySlotPointer';
 export * from './memory/KeyMerger';
 export * from './memory/MultiAddressMemoryMap';
+export * from './memory/Uint8ArrayMerger';
 
 /** Storage */
 export * from './storage/StoredU256';
 export * from './storage/StoredString';
+export * from './storage/StoredAddress';
 export * from './storage/StoredBoolean';
 export * from './storage/Serializable';
 
+export * from './storage/StorageBacked';
+export * from './storage/StorageSlot';
+export * from './storage/StorageStruct';
+export * from './storage/StorageLayout';
+export * from './storage/StorageValue';
+
 /** Shared libraries */
 export * from './shared-libraries/TransferHelper';
 export * from './shared-libraries/OP20Utils';
 
 /** Utils */
-export * from './utils/hex';
-export * from './utils/box';
+export * from './utils';

package/runtime/math/abi.ts

@@ -1,7 +1,6 @@
 // SO IN TYPESCRIPT, WE CAN NOT USE TWO METHOD WITH THE SAME NAME. SO NOT ADDING THE TYPE TO THE HASH IS A DESIGN CHOICE.
 import { bytes32, bytes4 } from './bytes';
 import { MemorySlotPointer } from '../memory/MemorySlotPointer';
-import { u256 } from 'as-bignum/assembly';
 import { Sha256 } from './sha256';
 
 export type Selector = u32;
@@ -13,25 +12,8 @@ export function encodeSelector(name: string): Selector {
     return bytes4(hash);
 }
 
-export function encodePointer(str: string): MemorySlotPointer {
-    const typed = Uint8Array.wrap(String.UTF8.encode(str));
+export function encodePointer(typed: Uint8Array): MemorySlotPointer {
     const hash = Sha256.hash(typed);
 
     return bytes32(hash);
 }
-
-export function encodePointerHash(pointer: u16, sub: u256): MemorySlotPointer {
-    const finalBuffer: Uint8Array = new Uint8Array(34);
-    const mergedKey: u8[] = [u8(pointer & u16(0xff)), u8((pointer >> u16(8)) & u16(0xff))];
-
-    for (let i: i32 = 0; i < mergedKey.length; i++) {
-        finalBuffer[i] = mergedKey[i];
-    }
-
-    const subKey = sub.toUint8Array();
-    for (let i: i32 = 0; i < subKey.length; i++) {
-        finalBuffer[mergedKey.length + i] = subKey[i];
-    }
-
-    return bytes32(Sha256.hash(finalBuffer));
-}