@btc-vision/btc-runtime 1.8.1 → 1.9.0

package/runtime/types/SafeMathI128.ts

@@ -1,4 +1,5 @@
 import { i128 } from '@btc-vision/as-bignum/assembly';
+import { Revert } from './Revert';
 
 export class SafeMathI128 {
     public static readonly ZERO: i128 = i128.fromI32(0);
@@ -13,14 +14,14 @@ export class SafeMathI128 {
      * Throws if (a + b) overflows or underflows the signed 128-bit range.
      */
     public static add(a: i128, b: i128): i128 {
-        let c = i128.add(a, b);
+        const c = i128.add(a, b);
 
         // Overflow check for 2's complement:
         // If a and b have the same sign, but c differs, overflow occurred.
         // We can detect sign mismatch using ((a ^ c) & (b ^ c)) < 0
         // (i.e., the sign bit is set in that expression).
         if (((a ^ c) & (b ^ c)).isNeg()) {
-            throw new Error('SafeMathI128: addition overflow');
+            throw new Revert('SafeMathI128: addition overflow');
         }
 
         return c;
@@ -31,12 +32,12 @@ export class SafeMathI128 {
      * Throws if (a - b) overflows or underflows the signed 128-bit range.
      */
     public static sub(a: i128, b: i128): i128 {
-        let c = i128.sub(a, b);
+        const c = i128.sub(a, b);
 
         // Subtraction is (a + (-b)). We can do a direct check like:
         // If (a ^ b) & (a ^ c) has sign bit set => overflow.
         if (((a ^ b) & (a ^ c)).isNeg()) {
-            throw new Error('SafeMathI128: subtraction overflow');
+            throw new Revert('SafeMathI128: subtraction overflow');
         }
 
         return c;
@@ -56,7 +57,7 @@ export class SafeMathI128 {
         if (b != SafeMathI128.ZERO) {
             let divCheck = i128.div(c, b);
             if (divCheck != a) {
-                throw new Error('SafeMathI128: multiplication overflow');
+                throw new Revert('SafeMathI128: multiplication overflow');
             }
         }
 
@@ -65,12 +66,12 @@ export class SafeMathI128 {
 
     /*public static div(a: i128, b: i128): i128 {
         if (b == SafeMathI128.ZERO) {
-            throw new Error('SafeMathI128: division by zero');
+            throw new Revert('SafeMathI128: division by zero');
         }
 
         // Check i128 edge case: MIN / -1 => possible overflow if no corresponding positive.
         if (a == SafeMathI128.MIN && b == SafeMathI128.NEG_ONE) {
-            throw new Error('SafeMathI128: division overflow (MIN / -1)');
+            throw new Revert('SafeMathI128: division overflow (MIN / -1)');
         }
 
         return i128.div(a, b);
@@ -78,14 +79,14 @@ export class SafeMathI128 {
 
     /*public static mod(a: i128, b: i128): i128 {
         if (b == SafeMathI128.ZERO) {
-            throw new Error('SafeMathI128: modulo by zero');
+            throw new Revert('SafeMathI128: modulo by zero');
         }
         // Similar edge case as division:
         if (a == SafeMathI128.MIN && b == SafeMathI128.NEG_ONE) {
             // Some implementations might treat MIN % -1 == 0,
             // but if the library doesn't, you may handle it similarly to division.
             // We'll assume we throw to be safe:
-            throw new Error('SafeMathI128: modulo overflow (MIN % -1)');
+            throw new Revert('SafeMathI128: modulo overflow (MIN % -1)');
         }
 
         // Use i128.rem, i128.mod, or the operator as appropriate.
@@ -97,7 +98,7 @@ export class SafeMathI128 {
      */
     public static inc(value: i128): i128 {
         if (value == SafeMathI128.MAX) {
-            throw new Error('SafeMathI128: inc overflow');
+            throw new Revert('SafeMathI128: inc overflow');
         }
 
         return SafeMathI128.add(value, SafeMathI128.ONE);
@@ -108,7 +109,7 @@ export class SafeMathI128 {
      */
     public static dec(value: i128): i128 {
         if (value == SafeMathI128.MIN) {
-            throw new Error('SafeMathI128: dec underflow');
+            throw new Revert('SafeMathI128: dec underflow');
         }
 
         return SafeMathI128.sub(value, SafeMathI128.ONE);
@@ -121,7 +122,7 @@ export class SafeMathI128 {
         if (x.isNeg()) {
             // If x == MIN, -x can overflow.
             if (x == SafeMathI128.MIN) {
-                throw new Error('SafeMathI128: abs overflow on MIN');
+                throw new Revert('SafeMathI128: abs overflow on MIN');
             }
             return x.neg();
         }
@@ -133,7 +134,7 @@ export class SafeMathI128 {
      */
     public static neg(x: i128): i128 {
         if (x == SafeMathI128.MIN) {
-            throw new Error('SafeMathI128: neg overflow on MIN');
+            throw new Revert('SafeMathI128: neg overflow on MIN');
         }
         return x.neg();
     }

package/runtime/utils/hex.ts

@@ -1,3 +1,43 @@
+import { Revert } from '../types/Revert';
+
+function hexCharToValue(char: u8): u8 {
+    if (char >= 48 && char <= 57) {
+        // '0' to '9'
+        return char - 48;
+    } else if (char >= 97 && char <= 102) {
+        // 'a' to 'f'
+        return char - 97 + 10;
+    } else if (char >= 65 && char <= 70) {
+        // 'A' to 'F'
+        return char - 65 + 10;
+    } else {
+        throw new Revert('Invalid hex character: ' + String.fromCharCode(char));
+    }
+}
+
+export function decodeHexArray(hex: string): u8[] {
+    // Remove 0x prefix if present
+    if (hex.startsWith('0x') || hex.startsWith('0X')) {
+        hex = hex.substring(2);
+    }
+
+    // Validate length is even
+    if (hex.length % 2 !== 0) {
+        throw new Revert('Hex string must have even length');
+    }
+
+    const result = new Array<u8>(hex.length / 2);
+    const hexBytes = String.UTF8.encode(hex);
+
+    for (let i = 0; i < hex.length; i += 2) {
+        const high = hexCharToValue(load<u8>(changetype<usize>(hexBytes) + i));
+        const low = hexCharToValue(load<u8>(changetype<usize>(hexBytes) + i + 1));
+        result[i / 2] = (high << 4) | low;
+    }
+
+    return result;
+}
+
 const hexLookupTable: StaticArray<u8> = [
     48, 48, 48, 49, 48, 50, 48, 51, 48, 52, 48, 53, 48, 54, 48, 55, 48, 56, 48, 57, 48, 97, 48, 98,
     48, 99, 48, 100, 48, 101, 48, 102, 49, 48, 49, 49, 49, 50, 49, 51, 49, 52, 49, 53, 49, 54, 49,
@@ -26,7 +66,7 @@ const hexLookupTable: StaticArray<u8> = [
 
 export function encodeHexUTF8(start: usize, len: usize): ArrayBuffer {
     const result = new ArrayBuffer(2 + <i32>len * 2);
-    store<u16>(changetype<usize>(result), <u16>0x7830);
+    store<u16>(changetype<usize>(result), <u16>0x7830); // Stores "0x" prefix
     for (let i: usize = 0; i < len; i++) {
         store<u16>(
             2 + changetype<usize>(result) + i * 2,
@@ -43,21 +83,3 @@ export function encodeHex(start: usize, len: usize): string {
 export function encodeHexFromBuffer(data: ArrayBuffer): string {
     return encodeHex(changetype<usize>(data), data.byteLength);
 }
-
-export function decodeHex(hex: string): ArrayBuffer {
-    const result = new ArrayBuffer(hex.length / 2);
-    for (let i = 0; i < hex.length; i += 2) {
-        store<u8>(changetype<usize>(result) + i / 2, <u8>parseInt(hex.substring(i, i + 2), 16));
-    }
-    return result;
-}
-
-export function decodeHexArray(hex: string): u8[] {
-    const result = new Array<u8>(hex.length / 2);
-
-    for (let i = 0; i < hex.length; i += 2) {
-        result[i / 2] = <u8>parseInt(hex.substring(i, i + 2), 16);
-    }
-
-    return result;
-}

package/runtime/utils/index.ts

@@ -1,4 +1,2 @@
-export * from './box';
-export * from './encodings';
 export * from './hex';
 export * from './lengths';

package/runtime/contracts/DeployableOP_20.ts

@@ -1,415 +0,0 @@
-import { u256 } from '@btc-vision/as-bignum/assembly';
-
-import { BytesWriter } from '../buffer/BytesWriter';
-import { Blockchain } from '../env';
-import { ApproveEvent, BurnEvent, MintEvent, TransferEvent } from '../events/predefined';
-import { StoredString } from '../storage/StoredString';
-import { StoredU256 } from '../storage/StoredU256';
-import { Address } from '../types/Address';
-import { Revert } from '../types/Revert';
-import { SafeMath } from '../types/SafeMath';
-import { sha256 } from '../env/global';
-import { EMPTY_POINTER } from '../math/bytes';
-import { AddressMemoryMap } from '../memory/AddressMemoryMap';
-import { MapOfMap } from '../memory/MapOfMap';
-import { Calldata } from '../types';
-import { ADDRESS_BYTE_LENGTH, BOOLEAN_BYTE_LENGTH, U256_BYTE_LENGTH } from '../utils';
-import { IOP_20 } from './interfaces/IOP_20';
-import { OP20InitParameters } from './interfaces/OP20InitParameters';
-import { OP_NET } from './OP_NET';
-
-const nonceMapPointer: u16 = Blockchain.nextPointer;
-const maxSupplyPointer: u16 = Blockchain.nextPointer;
-const decimalsPointer: u16 = Blockchain.nextPointer;
-const stringPointer: u16 = Blockchain.nextPointer;
-const totalSupplyPointer: u16 = Blockchain.nextPointer;
-const allowanceMapPointer: u16 = Blockchain.nextPointer;
-const balanceOfMapPointer: u16 = Blockchain.nextPointer;
-
-export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
-    protected readonly allowanceMap: MapOfMap<u256>;
-    protected readonly balanceOfMap: AddressMemoryMap;
-
-    protected readonly _maxSupply: StoredU256;
-    protected readonly _decimals: StoredU256;
-    protected readonly _name: StoredString;
-    protected readonly _symbol: StoredString;
-    protected readonly _nonceMap: AddressMemoryMap;
-
-    public constructor(params: OP20InitParameters | null = null) {
-        super();
-
-        this.allowanceMap = new MapOfMap<u256>(allowanceMapPointer);
-        this.balanceOfMap = new AddressMemoryMap(balanceOfMapPointer);
-        this._nonceMap = new AddressMemoryMap(nonceMapPointer);
-
-        this._totalSupply = new StoredU256(totalSupplyPointer, EMPTY_POINTER);
-        this._maxSupply = new StoredU256(maxSupplyPointer, EMPTY_POINTER);
-        this._decimals = new StoredU256(decimalsPointer, EMPTY_POINTER);
-        this._name = new StoredString(stringPointer, 0);
-        this._symbol = new StoredString(stringPointer, 1);
-
-        if (params && this._maxSupply.value.isZero()) {
-            this.instantiate(params, true);
-        }
-    }
-
-    /** Intentionally public for inherited classes */
-    public _totalSupply: StoredU256;
-
-    public get totalSupply(): u256 {
-        return this._totalSupply.value;
-    }
-
-    public get maxSupply(): u256 {
-        if (!this._maxSupply) throw new Revert('Max supply not set');
-        return this._maxSupply.value;
-    }
-
-    public get decimals(): u8 {
-        if (!this._decimals) throw new Revert('Decimals not set');
-        return u8(this._decimals.value.toU32());
-    }
-
-    public get name(): string {
-        if (!this._name) throw new Revert('Name not set');
-        return this._name.value;
-    }
-
-    public get symbol(): string {
-        if (!this._symbol) throw new Revert('Symbol not set');
-        return this._symbol.value;
-    }
-
-    public instantiate(
-        params: OP20InitParameters,
-        skipDeployerVerification: boolean = false,
-    ): void {
-        if (!this._maxSupply.value.isZero()) throw new Revert('Already initialized');
-        if (!skipDeployerVerification) this.onlyDeployer(Blockchain.tx.sender);
-        if (params.decimals > 32) throw new Revert('Decimals > 32');
-
-        this._maxSupply.value = params.maxSupply;
-        this._decimals.value = u256.fromU32(u32(params.decimals));
-        this._name.value = params.name;
-        this._symbol.value = params.symbol;
-    }
-
-    @method('decimals')
-    @returns({ name: 'decimals', type: ABIDataTypes.UINT8 })
-    public fn_decimals(_: Calldata): BytesWriter {
-        const w = new BytesWriter(1);
-        w.writeU8(this.decimals);
-        return w;
-    }
-
-    @method('name')
-    @returns({ name: 'name', type: ABIDataTypes.STRING })
-    public fn_name(_: Calldata): BytesWriter {
-        const w = new BytesWriter(String.UTF8.byteLength(this.name) + 4);
-        w.writeStringWithLength(this.name);
-        return w;
-    }
-
-    @method('symbol')
-    @returns({ name: 'symbol', type: ABIDataTypes.STRING })
-    public fn_symbol(_: Calldata): BytesWriter {
-        const w = new BytesWriter(String.UTF8.byteLength(this.symbol) + 4);
-        w.writeStringWithLength(this.symbol);
-        return w;
-    }
-
-    @method('totalSupply')
-    @returns({ name: 'totalSupply', type: ABIDataTypes.UINT256 })
-    public fn_totalSupply(_: Calldata): BytesWriter {
-        const w = new BytesWriter(U256_BYTE_LENGTH);
-        w.writeU256(this.totalSupply);
-        return w;
-    }
-
-    @method('maximumSupply')
-    @returns({ name: 'maximumSupply', type: ABIDataTypes.UINT256 })
-    public fn_maximumSupply(_: Calldata): BytesWriter {
-        const w = new BytesWriter(U256_BYTE_LENGTH);
-        w.writeU256(this.maxSupply);
-        return w;
-    }
-
-    @method(
-        { name: 'owner', type: ABIDataTypes.ADDRESS },
-        { name: 'spender', type: ABIDataTypes.ADDRESS },
-    )
-    @returns({ name: 'remaining', type: ABIDataTypes.UINT256 })
-    public allowance(calldata: Calldata): BytesWriter {
-        const w = new BytesWriter(U256_BYTE_LENGTH);
-        const rem = this._allowance(calldata.readAddress(), calldata.readAddress());
-        w.writeU256(rem);
-        return w;
-    }
-
-    @method(
-        { name: 'spender', type: ABIDataTypes.ADDRESS },
-        { name: 'amount', type: ABIDataTypes.UINT256 },
-    )
-    @returns({ name: 'success', type: ABIDataTypes.BOOL })
-    @emit('Approve')
-    public approve(calldata: Calldata): BytesWriter {
-        const ok = this._approve(Blockchain.tx.sender, calldata.readAddress(), calldata.readU256());
-        const w = new BytesWriter(BOOLEAN_BYTE_LENGTH);
-        w.writeBoolean(ok);
-        return w;
-    }
-
-    @method(
-        { name: 'spender', type: ABIDataTypes.ADDRESS },
-        { name: 'amount', type: ABIDataTypes.UINT256 },
-        { name: 'nonce', type: ABIDataTypes.UINT256 },
-        { name: 'sig', type: ABIDataTypes.BYTES },
-    )
-    @returns({ name: 'success', type: ABIDataTypes.BOOL })
-    @emit('Approve')
-    public approveFrom(calldata: Calldata): BytesWriter {
-        if (Blockchain.tx.origin == Blockchain.tx.sender) {
-            throw new Revert('Direct owner approval – use approve()');
-        }
-
-        const owner: Address = Blockchain.tx.origin;
-        const spender: Address = calldata.readAddress();
-        const value: u256 = calldata.readU256();
-        const nonce: u256 = calldata.readU256();
-        const sig = calldata.readBytesWithLength();
-        if (sig.length !== 64) throw new Revert('Invalid signature length');
-
-        const ok = this._approveFrom(owner, spender, value, nonce, sig);
-        const w = new BytesWriter(BOOLEAN_BYTE_LENGTH);
-        w.writeBoolean(ok);
-        return w;
-    }
-
-    @method({ name: 'owner', type: ABIDataTypes.ADDRESS })
-    @returns({ name: 'nonce', type: ABIDataTypes.UINT256 })
-    public nonceOf(calldata: Calldata): BytesWriter {
-        const current = this._nonceMap.get(calldata.readAddress());
-        const w = new BytesWriter(U256_BYTE_LENGTH);
-        w.writeU256(current);
-        return w;
-    }
-
-    @method({ name: 'owner', type: ABIDataTypes.ADDRESS })
-    @returns({ name: 'balance', type: ABIDataTypes.UINT256 })
-    public balanceOf(calldata: Calldata): BytesWriter {
-        const bal = this._balanceOf(calldata.readAddress());
-        const w = new BytesWriter(U256_BYTE_LENGTH);
-        w.writeU256(bal);
-        return w;
-    }
-
-    @method({ name: 'amount', type: ABIDataTypes.UINT256 })
-    @returns({ name: 'success', type: ABIDataTypes.BOOL })
-    @emit('Burn')
-    public burn(calldata: Calldata): BytesWriter {
-        const ok = this._burn(calldata.readU256());
-        const w = new BytesWriter(BOOLEAN_BYTE_LENGTH);
-        w.writeBoolean(ok);
-        return w;
-    }
-
-    @method(
-        { name: 'to', type: ABIDataTypes.ADDRESS },
-        { name: 'amount', type: ABIDataTypes.UINT256 },
-    )
-    @returns({ name: 'success', type: ABIDataTypes.BOOL })
-    @emit('Transfer')
-    public transfer(calldata: Calldata): BytesWriter {
-        const ok = this._transfer(calldata.readAddress(), calldata.readU256());
-        const w = new BytesWriter(BOOLEAN_BYTE_LENGTH);
-        w.writeBoolean(ok);
-        return w;
-    }
-
-    @method(
-        { name: 'from', type: ABIDataTypes.ADDRESS },
-        { name: 'to', type: ABIDataTypes.ADDRESS },
-        { name: 'amount', type: ABIDataTypes.UINT256 },
-    )
-    @returns({ name: 'success', type: ABIDataTypes.BOOL })
-    @emit('Transfer')
-    public transferFrom(calldata: Calldata): BytesWriter {
-        const ok = this._transferFrom(
-            calldata.readAddress(),
-            calldata.readAddress(),
-            calldata.readU256(),
-        );
-        const w = new BytesWriter(BOOLEAN_BYTE_LENGTH);
-        w.writeBoolean(ok);
-        return w;
-    }
-
-    protected _allowance(owner: Address, spender: Address): u256 {
-        const senderMap = this.allowanceMap.get(owner);
-        return senderMap.get(spender);
-    }
-
-    protected _approveFrom(
-        owner: Address,
-        spender: Address,
-        value: u256,
-        nonce: u256,
-        signature: Uint8Array,
-    ): boolean {
-        if (owner === Blockchain.DEAD_ADDRESS) throw new Revert('Address can not be dead');
-        if (spender === Blockchain.DEAD_ADDRESS) throw new Revert('Spender can not be dead');
-
-        const storedNonce = this._nonceMap.get(owner);
-        if (!u256.eq(storedNonce, nonce)) throw new Revert('Invalid nonce');
-
-        const writer = new BytesWriter(
-            ADDRESS_BYTE_LENGTH * 3 + U256_BYTE_LENGTH + U256_BYTE_LENGTH,
-        );
-        writer.writeAddress(owner);
-        writer.writeAddress(spender);
-        writer.writeU256(value);
-        writer.writeU256(nonce);
-        writer.writeAddress(this.address);
-
-        const hash = sha256(writer.getBuffer());
-        if (!Blockchain.verifySchnorrSignature(owner, signature, hash)) {
-            throw new Revert('Invalid signature');
-        }
-
-        this._nonceMap.set(owner, SafeMath.add(storedNonce, u256.One));
-
-        const senderMap = this.allowanceMap.get(owner);
-        senderMap.set(spender, value);
-
-        this.createApproveEvent(owner, spender, value);
-        return true;
-    }
-
-    protected _approve(owner: Address, spender: Address, value: u256): boolean {
-        if (owner === Blockchain.DEAD_ADDRESS) throw new Revert('Address can not be dead');
-        if (spender === Blockchain.DEAD_ADDRESS) throw new Revert('Spender can not be dead');
-
-        const senderMap = this.allowanceMap.get(owner);
-        senderMap.set(spender, value);
-
-        this.createApproveEvent(owner, spender, value);
-        return true;
-    }
-
-    protected _balanceOf(owner: Address): u256 {
-        if (!this.balanceOfMap.has(owner)) return u256.Zero;
-        return this.balanceOfMap.get(owner);
-    }
-
-    protected _burn(value: u256, onlyDeployer: boolean = true): boolean {
-        if (u256.eq(value, u256.Zero)) throw new Revert('No tokens');
-
-        if (onlyDeployer) this.onlyDeployer(Blockchain.tx.sender);
-        if (this._totalSupply.value < value) throw new Revert('Insufficient supply');
-        if (!this.balanceOfMap.has(Blockchain.tx.sender)) throw new Revert('No balance');
-
-        const balance: u256 = this.balanceOfMap.get(Blockchain.tx.sender);
-        if (balance < value) throw new Revert('Insufficient balance');
-
-        const newBalance: u256 = SafeMath.sub(balance, value);
-        this.balanceOfMap.set(Blockchain.tx.sender, newBalance);
-
-        // @ts-expect-error AssemblyScript valid
-        this._totalSupply -= value;
-
-        this.createBurnEvent(value);
-        return true;
-    }
-
-    protected _mint(to: Address, value: u256, onlyDeployer: boolean = true): boolean {
-        if (onlyDeployer) this.onlyDeployer(Blockchain.tx.sender);
-
-        if (!this.balanceOfMap.has(to)) {
-            this.balanceOfMap.set(to, value);
-        } else {
-            const toBal: u256 = this.balanceOfMap.get(to);
-            this.balanceOfMap.set(to, SafeMath.add(toBal, value));
-        }
-
-        // @ts-expect-error AssemblyScript valid
-        this._totalSupply += value;
-
-        if (this._totalSupply.value > this.maxSupply) throw new Revert('Max supply reached');
-        this.createMintEvent(to, value);
-        return true;
-    }
-
-    protected _transfer(to: Address, value: u256): boolean {
-        const sender = Blockchain.tx.sender;
-        if (this.isSelf(sender)) throw new Revert('Cannot transfer from self');
-        if (u256.eq(value, u256.Zero)) throw new Revert('Cannot transfer 0');
-
-        const balance: u256 = this.balanceOfMap.get(sender);
-        if (balance < value) throw new Revert('Insufficient balance');
-
-        this.balanceOfMap.set(sender, SafeMath.sub(balance, value));
-
-        const toBal: u256 = this.balanceOfMap.get(to);
-        this.balanceOfMap.set(to, SafeMath.add(toBal, value));
-
-        this.createTransferEvent(sender, to, value);
-        return true;
-    }
-
-    @unsafe
-    protected _unsafeTransferFrom(from: Address, to: Address, value: u256): boolean {
-        const balance: u256 = this.balanceOfMap.get(from);
-        if (balance < value) {
-            throw new Revert(`TransferFrom insufficient balance`);
-        }
-
-        this.balanceOfMap.set(from, SafeMath.sub(balance, value));
-
-        if (!this.balanceOfMap.has(to)) {
-            this.balanceOfMap.set(to, value);
-        } else {
-            const toBal: u256 = this.balanceOfMap.get(to);
-            this.balanceOfMap.set(to, SafeMath.add(toBal, value));
-        }
-
-        this.createTransferEvent(from, to, value);
-        return true;
-    }
-
-    protected _transferFrom(from: Address, to: Address, value: u256): boolean {
-        if (from === Blockchain.DEAD_ADDRESS) throw new Revert('Cannot transfer from dead address');
-
-        this._spendAllowance(from, Blockchain.tx.sender, value);
-        this._unsafeTransferFrom(from, to, value);
-        return true;
-    }
-
-    protected _spendAllowance(owner: Address, spender: Address, value: u256): void {
-        const ownerMap = this.allowanceMap.get(owner);
-        const allowed: u256 = ownerMap.get(spender);
-
-        if (allowed < value) {
-            throw new Revert('Insufficient allowance');
-        }
-
-        ownerMap.set(spender, SafeMath.sub(allowed, value));
-        this.allowanceMap.set(owner, ownerMap);
-    }
-
-    protected createBurnEvent(value: u256): void {
-        this.emitEvent(new BurnEvent(value));
-    }
-
-    protected createApproveEvent(owner: Address, spender: Address, value: u256): void {
-        this.emitEvent(new ApproveEvent(owner, spender, value));
-    }
-
-    protected createMintEvent(recipient: Address, value: u256): void {
-        this.emitEvent(new MintEvent(recipient, value));
-    }
-
-    protected createTransferEvent(from: Address, to: Address, value: u256): void {
-        this.emitEvent(new TransferEvent(from, to, value));
-    }
-}

package/runtime/contracts/OP_20.ts

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

package/runtime/contracts/interfaces/IOP_20.ts

@@ -1,19 +0,0 @@
-import { BytesWriter } from '../../buffer/BytesWriter';
-import { StoredU256 } from '../../storage/StoredU256';
-import { Calldata } from '../../types';
-
-export interface IOP_20 {
-    readonly _totalSupply: StoredU256;
-
-    balanceOf(callData: Calldata): BytesWriter;
-
-    transfer(callData: Calldata): BytesWriter;
-
-    transferFrom(callData: Calldata): BytesWriter;
-
-    approve(callData: Calldata): BytesWriter;
-
-    allowance(callData: Calldata): BytesWriter;
-
-    burn(callData: Calldata): BytesWriter;
-}

package/runtime/events/predefined/BurnEvent.ts

@@ -1,14 +0,0 @@
-import { u256 } from '@btc-vision/as-bignum/assembly';
-import { BytesWriter } from '../../buffer/BytesWriter';
-import { U256_BYTE_LENGTH } from '../../utils/lengths';
-import { NetEvent } from '../NetEvent';
-
-@final
-export class BurnEvent extends NetEvent {
-    constructor(amount: u256) {
-        const data: BytesWriter = new BytesWriter(U256_BYTE_LENGTH);
-        data.writeU256(amount);
-
-        super('Burn', data);
-    }
-}