@btc-vision/btc-runtime 1.9.16 → 1.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.9.16",
+    "version": "1.10.0",
     "description": "Bitcoin Smart Contract Runtime",
     "main": "btc/index.ts",
     "scripts": {
@@ -25,7 +25,7 @@
         "@btc-vision/as-pect-assembly": "^8.2.0",
         "@btc-vision/as-pect-cli": "^8.2.0",
         "@btc-vision/as-pect-transform": "^8.2.0",
-        "@types/node": "^24.10.0",
+        "@types/node": "^24.10.1",
         "assemblyscript": "^0.28.9"
     },
     "repository": {

package/runtime/buffer/BytesReader.ts

@@ -238,7 +238,7 @@ export class BytesReader {
     public readAddress(): Address {
         this.verifyEnd(this.currentOffset + ADDRESS_BYTE_LENGTH);
 
-        const addr = new Address();
+        const addr = new Address([]);
         for (let i: i32 = 0; i < ADDRESS_BYTE_LENGTH; i++) {
             addr[i] = this.readU8();
         }

package/runtime/constants/Exports.ts

@@ -79,14 +79,14 @@ export const OP721_TRANSFER_TYPE_HASH: u8[] = [
     0x64, 0xab, 0xa6, 0xaf, 0x68, 0x51, 0x03, 0xfe, 0xc4, 0xae, 0x12, 0xd7, 0xa6, 0xa9, 0xb2, 0x0f,
 ];
 
-export const BALANCE_OF_SELECTOR:      u32 = 0x5b46f8f6; // "balanceOf(address)"
-export const ALLOWANCE_SELECTOR:       u32 = 0xd864b7ca; // "allowance(address,address)"
-export const TOTAL_SUPPLY_SELECTOR:    u32 = 0xa368022e; // "totalSupply()"
-export const NAME_SELECTOR:            u32 = 0x1581f81c; // "name()"
-export const SYMBOL_SELECTOR:          u32 = 0x25967ca5; // "symbol()"
-export const DECIMALS_SELECTOR:        u32 = 0xbb844440; // "decimals()"
-export const NONCE_OF_SELECTOR:        u32 = 0xf6824b65; // "nonceOf(address)"
-export const DOMAIN_SEPARATOR_SELECTOR:u32 = 0xf1bf80e0; // "domainSeparator()"
-export const METADATA_SELECTOR:        u32 = 0xfc0d115c; // "metadata()"
-export const MAXIMUM_SUPPLY_SELECTOR:  u32 = 0x7d8d5019; // "maximumSupply()"
-export const ICON_SELECTOR:            u32 = 0xaaaa50c5; // "icon()"
+export const BALANCE_OF_SELECTOR: u32 = 0x5b46f8f6; // "balanceOf(address)"
+export const ALLOWANCE_SELECTOR: u32 = 0xd864b7ca; // "allowance(address,address)"
+export const TOTAL_SUPPLY_SELECTOR: u32 = 0xa368022e; // "totalSupply()"
+export const NAME_SELECTOR: u32 = 0x1581f81c; // "name()"
+export const SYMBOL_SELECTOR: u32 = 0x25967ca5; // "symbol()"
+export const DECIMALS_SELECTOR: u32 = 0xbb844440; // "decimals()"
+export const NONCE_OF_SELECTOR: u32 = 0xf6824b65; // "nonceOf(address)"
+export const DOMAIN_SEPARATOR_SELECTOR: u32 = 0xf1bf80e0; // "domainSeparator()"
+export const METADATA_SELECTOR: u32 = 0xfc0d115c; // "metadata()"
+export const MAXIMUM_SUPPLY_SELECTOR: u32 = 0x7d8d5019; // "maximumSupply()"
+export const ICON_SELECTOR: u32 = 0xaaaa50c5; // "icon()"

package/runtime/contracts/OP20.ts

@@ -50,25 +50,95 @@ 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;
 
+/**
+ * OP20 Token Standard Implementation for OPNet.
+ *
+ * This abstract class implements the OP20 token standard, providing a complete
+ * fungible token implementation with advanced features including:
+ * - EIP-712 style typed data signatures for gasless approvals
+ * - Safe transfer callbacks for receiver contracts
+ * - Reentrancy protection for security
+ * - Quantum-resistant signature support (Schnorr now, ML-DSA future)
+ * - Unlimited approval optimization (u256.Max)
+ *
+ * @remarks
+ * OP20 is OPNet's equivalent of ERC20, adapted for Bitcoin's UTXO model with
+ * additional security features. All storage uses persistent pointers for
+ * cross-transaction state management. The contract includes built-in protection
+ * against common attack vectors including reentrancy and integer overflow.
+ *
+ * Inheriting contracts must implement deployment verification logic and can
+ * extend with additional features like minting permissions, pausability, etc.
+ *
+ * @example
+ * ```typescript
+ * class MyToken extends OP20 {
+ *   constructor() {
+ *     super();
+ *     const params: OP20InitParameters = {
+ *       name: "My Token",
+ *       symbol: "MTK",
+ *       decimals: 18,
+ *       maxSupply: u256.fromU64(1000000000000000000000000), // 1M tokens
+ *       icon: "https://example.com/icon.png"
+ *     };
+ *     this.instantiate(params);
+ *   }
+ * }
+ * ```
+ */
 export abstract class OP20 extends ReentrancyGuard implements IOP20 {
+    /**
+     * Total supply of tokens currently in circulation.
+     * Intentionally public for inherited classes to implement custom minting/burning logic.
+     */
+    public _totalSupply: StoredU256;
+
+    /**
+     * Reentrancy protection level for this contract.
+     * Set to CALLBACK to allow single-depth callbacks for safeTransfer operations.
+     */
     protected readonly reentrancyLevel: ReentrancyLevel = ReentrancyLevel.CALLBACK;
 
+    /**
+     * Nested mapping of owner -> spender -> allowance amount.
+     * Tracks approval amounts for transferFrom operations.
+     */
     protected readonly allowanceMap: MapOfMap<u256>;
+
+    /**
+     * Mapping of address -> balance.
+     * Stores token balances for all holders.
+     */
     protected readonly balanceOfMap: AddressMemoryMap;
 
+    /** Maximum supply that can ever be minted. */
     protected readonly _maxSupply: StoredU256;
+
+    /** Number of decimal places for token display. */
     protected readonly _decimals: StoredU256;
+
+    /** Human-readable token name. */
     protected readonly _name: StoredString;
+
+    /** Token icon URL for display in wallets/explorers. */
     protected readonly _icon: StoredString;
+
+    /** Token ticker symbol. */
     protected readonly _symbol: StoredString;
-    protected readonly _nonceMap: AddressMemoryMap;
 
-    /** Intentionally public for inherited classes */
-    public _totalSupply: StoredU256;
+    /**
+     * Mapping of address -> nonce for EIP-712 signatures.
+     * Prevents signature replay attacks.
+     */
+    protected readonly _nonceMap: AddressMemoryMap;
 
+    /**
+     * Initializes the OP20 token with storage pointers.
+     * Sets up all persistent storage mappings and variables.
+     */
     public constructor() {
         super();
 
@@ -84,6 +154,21 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         this._icon = new StoredString(stringPointer, 2);
     }
 
+    /**
+     * Initializes token parameters. Can only be called once.
+     *
+     * @param params - Token initialization parameters
+     * @param skipDeployerVerification - If true, skips deployer check (use with caution)
+     *
+     * @throws {Revert} If already initialized
+     * @throws {Revert} If decimals > 32
+     * @throws {Revert} If caller is not deployer (unless skipped)
+     *
+     * @remarks
+     * This method sets immutable token parameters and should be called in the
+     * constructor of inheriting contracts. The maximum of 32 decimals is enforced
+     * to prevent precision issues with u256 arithmetic.
+     */
     public instantiate(
         params: OP20InitParameters,
         skipDeployerVerification: boolean = false,
@@ -99,6 +184,11 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         this._icon.value = params.icon;
     }
 
+    /**
+     * Returns the token name.
+     *
+     * @returns Token name as string
+     */
     @method()
     @returns({ name: 'name', type: ABIDataTypes.STRING })
     public name(_: Calldata): BytesWriter {
@@ -107,6 +197,11 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return w;
     }
 
+    /**
+     * Returns the token symbol.
+     *
+     * @returns Token symbol as string
+     */
     @method()
     @returns({ name: 'symbol', type: ABIDataTypes.STRING })
     public symbol(_: Calldata): BytesWriter {
@@ -115,6 +210,11 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return w;
     }
 
+    /**
+     * Returns the token icon URL.
+     *
+     * @returns Icon URL as string
+     */
     @method()
     @returns({ name: 'icon', type: ABIDataTypes.STRING })
     public icon(_: Calldata): BytesWriter {
@@ -123,6 +223,11 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return w;
     }
 
+    /**
+     * Returns the number of decimals used for display.
+     *
+     * @returns Number of decimals (0-32)
+     */
     @method()
     @returns({ name: 'decimals', type: ABIDataTypes.UINT8 })
     public decimals(_: Calldata): BytesWriter {
@@ -131,6 +236,11 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return w;
     }
 
+    /**
+     * Returns the total supply of tokens in circulation.
+     *
+     * @returns Current total supply as u256
+     */
     @method()
     @returns({ name: 'totalSupply', type: ABIDataTypes.UINT256 })
     public totalSupply(_: Calldata): BytesWriter {
@@ -139,6 +249,11 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return w;
     }
 
+    /**
+     * Returns the maximum supply that can ever exist.
+     *
+     * @returns Maximum supply cap as u256
+     */
     @method()
     @returns({ name: 'maximumSupply', type: ABIDataTypes.UINT256 })
     public maximumSupply(_: Calldata): BytesWriter {
@@ -147,6 +262,15 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return w;
     }
 
+    /**
+     * Returns the EIP-712 domain separator for signature verification.
+     *
+     * @returns 32-byte domain separator hash
+     *
+     * @remarks
+     * The domain separator includes chain ID, protocol ID, and contract address
+     * to prevent cross-chain and cross-contract signature replay attacks.
+     */
     @method()
     @returns({ name: 'domainSeparator', type: ABIDataTypes.BYTES32 })
     public domainSeparator(_: Calldata): BytesWriter {
@@ -155,6 +279,12 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return w;
     }
 
+    /**
+     * Returns the token balance of an address.
+     *
+     * @param calldata - Contains the address to query
+     * @returns Balance as u256
+     */
     @method({ name: 'owner', type: ABIDataTypes.ADDRESS })
     @returns({ name: 'balance', type: ABIDataTypes.UINT256 })
     public balanceOf(calldata: Calldata): BytesWriter {
@@ -164,6 +294,12 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return w;
     }
 
+    /**
+     * Returns the current nonce for an address (for signature verification).
+     *
+     * @param calldata - Contains the address to query
+     * @returns Current nonce as u256
+     */
     @method({ name: 'owner', type: ABIDataTypes.ADDRESS })
     @returns({ name: 'nonce', type: ABIDataTypes.UINT256 })
     public nonceOf(calldata: Calldata): BytesWriter {
@@ -173,6 +309,12 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return w;
     }
 
+    /**
+     * Returns the amount an address is allowed to spend on behalf of another.
+     *
+     * @param calldata - Contains owner and spender addresses
+     * @returns Remaining allowance as u256
+     */
     @method(
         { name: 'owner', type: ABIDataTypes.ADDRESS },
         { name: 'spender', type: ABIDataTypes.ADDRESS },
@@ -185,6 +327,15 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return w;
     }
 
+    /**
+     * Transfers tokens from sender to recipient.
+     *
+     * @param calldata - Contains recipient address and amount
+     * @emits Transferred event
+     *
+     * @throws {Revert} If sender has insufficient balance
+     * @throws {Revert} If recipient is zero address
+     */
     @method(
         { name: 'to', type: ABIDataTypes.ADDRESS },
         { name: 'amount', type: ABIDataTypes.UINT256 },
@@ -195,6 +346,15 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return new BytesWriter(0);
     }
 
+    /**
+     * Transfers tokens on behalf of another address using allowance.
+     *
+     * @param calldata - Contains from address, to address, and amount
+     * @emits Transferred event
+     *
+     * @throws {Revert} If insufficient allowance
+     * @throws {Revert} If from has insufficient balance
+     */
     @method(
         { name: 'from', type: ABIDataTypes.ADDRESS },
         { name: 'to', type: ABIDataTypes.ADDRESS },
@@ -212,6 +372,16 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return new BytesWriter(0);
     }
 
+    /**
+     * Safely transfers tokens and calls onOP20Received on recipient if it's a contract.
+     *
+     * @param calldata - Contains recipient, amount, and optional data
+     * @emits Transferred event
+     *
+     * @throws {Revert} If recipient contract rejects the transfer
+     * @remarks
+     * Prevents tokens from being permanently locked in contracts that can't handle them.
+     */
     @method(
         { name: 'to', type: ABIDataTypes.ADDRESS },
         { name: 'amount', type: ABIDataTypes.UINT256 },
@@ -228,6 +398,15 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return new BytesWriter(0);
     }
 
+    /**
+     * Safely transfers tokens on behalf of another address with callback.
+     *
+     * @param calldata - Contains from, to, amount, and optional data
+     * @emits Transferred event
+     *
+     * @throws {Revert} If insufficient allowance or balance
+     * @throws {Revert} If recipient contract rejects
+     */
     @method(
         { name: 'from', type: ABIDataTypes.ADDRESS },
         { name: 'to', type: ABIDataTypes.ADDRESS },
@@ -247,6 +426,16 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return new BytesWriter(0);
     }
 
+    /**
+     * Increases the allowance granted to a spender.
+     *
+     * @param calldata - Contains spender address and amount to increase
+     * @emits Approved event
+     *
+     * @remarks
+     * Preferred over setting allowance directly to avoid race conditions.
+     * If overflow would occur, sets to u256.Max (unlimited).
+     */
     @method(
         { name: 'spender', type: ABIDataTypes.ADDRESS },
         { name: 'amount', type: ABIDataTypes.UINT256 },
@@ -261,6 +450,15 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return new BytesWriter(0);
     }
 
+    /**
+     * Decreases the allowance granted to a spender.
+     *
+     * @param calldata - Contains spender address and amount to decrease
+     * @emits Approved event
+     *
+     * @remarks
+     * If decrease would cause underflow, sets allowance to zero.
+     */
     @method(
         { name: 'spender', type: ABIDataTypes.ADDRESS },
         { name: 'amount', type: ABIDataTypes.UINT256 },
@@ -275,6 +473,18 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return new BytesWriter(0);
     }
 
+    /**
+     * Increases allowance using an EIP-712 typed signature (gasless approval).
+     *
+     * @param calldata - Contains owner, spender, amount, deadline, and signature
+     * @emits Approved event
+     *
+     * @throws {Revert} If signature is invalid or expired
+     *
+     * @remarks
+     * Enables gasless approvals where a third party can submit the transaction.
+     * Uses Schnorr signatures now, will support ML-DSA after quantum transition.
+     */
     @method(
         { name: 'owner', type: ABIDataTypes.ADDRESS },
         { name: 'spender', type: ABIDataTypes.ADDRESS },
@@ -294,6 +504,14 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return new BytesWriter(0);
     }
 
+    /**
+     * Decreases allowance using an EIP-712 typed signature.
+     *
+     * @param calldata - Contains owner, spender, amount, deadline, and signature
+     * @emits Approved event
+     *
+     * @throws {Revert} If signature is invalid or expired
+     */
     @method(
         { name: 'owner', type: ABIDataTypes.ADDRESS },
         { name: 'spender', type: ABIDataTypes.ADDRESS },
@@ -313,6 +531,17 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return new BytesWriter(0);
     }
 
+    /**
+     * Burns tokens from the sender's balance.
+     *
+     * @param calldata - Contains amount to burn
+     * @emits Burned event
+     *
+     * @throws {Revert} If sender has insufficient balance
+     *
+     * @remarks
+     * Permanently removes tokens from circulation, decreasing total supply.
+     */
     @method({ name: 'amount', type: ABIDataTypes.UINT256 })
     @emit('Burned')
     public burn(calldata: Calldata): BytesWriter {
@@ -320,6 +549,14 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return new BytesWriter(0);
     }
 
+    /**
+     * Returns all token metadata in a single call.
+     *
+     * @returns Combined metadata including name, symbol, icon, decimals, totalSupply, and domain separator
+     *
+     * @remarks
+     * Optimization for wallets/explorers to fetch all token info in one call.
+     */
     @method()
     @returns(
         { name: 'name', type: ABIDataTypes.STRING },
@@ -359,22 +596,34 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return w;
     }
 
+    /**
+     * Internal: Gets balance of an address.
+     * @protected
+     */
     protected _balanceOf(owner: Address): u256 {
         if (!this.balanceOfMap.has(owner)) return u256.Zero;
         return this.balanceOfMap.get(owner);
     }
 
+    /**
+     * Internal: Gets allowance between owner and spender.
+     * @protected
+     */
     protected _allowance(owner: Address, spender: Address): u256 {
         const senderMap = this.allowanceMap.get(owner);
         return senderMap.get(spender);
     }
 
+    /**
+     * Internal: Executes token transfer logic.
+     * @protected
+     */
     protected _transfer(from: Address, to: Address, amount: u256): void {
-        if (from === Address.zero() || from === Address.dead()) {
+        if (from === Address.zero()) {
             throw new Revert('Invalid sender');
         }
 
-        if (to === Address.zero() || to === Address.dead()) {
+        if (to === Address.zero()) {
             throw new Revert('Invalid receiver');
         }
 
@@ -391,6 +640,10 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         this.createTransferredEvent(Blockchain.tx.sender, from, to, amount);
     }
 
+    /**
+     * Internal: Safe transfer with receiver callback.
+     * @protected
+     */
     protected _safeTransfer(from: Address, to: Address, amount: u256, data: Uint8Array): void {
         this._transfer(from, to, amount);
 
@@ -401,6 +654,10 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         }
     }
 
+    /**
+     * Internal: Spends allowance for transferFrom.
+     * @protected
+     */
     protected _spendAllowance(owner: Address, spender: Address, amount: u256): void {
         if (owner.equals(spender)) return;
 
@@ -417,6 +674,10 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         this.allowanceMap.set(owner, ownerMap);
     }
 
+    /**
+     * Internal: Calls onOP20Received on receiver contract.
+     * @protected
+     */
     protected _callOnOP20Received(
         from: Address,
         to: Address,
@@ -448,6 +709,10 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         }
     }
 
+    /**
+     * Internal: Processes signature-based allowance increase.
+     * @protected
+     */
     protected _increaseAllowanceBySignature(
         owner: Address,
         spender: Address,
@@ -466,6 +731,10 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         this._increaseAllowance(owner, spender, amount);
     }
 
+    /**
+     * Checks if a selector should bypass reentrancy guards.
+     * @protected
+     */
     protected isSelectorExcluded(selector: Selector): boolean {
         if (
             selector === BALANCE_OF_SELECTOR ||
@@ -486,6 +755,10 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return super.isSelectorExcluded(selector);
     }
 
+    /**
+     * Internal: Processes signature-based allowance decrease.
+     * @protected
+     */
     protected _decreaseAllowanceBySignature(
         owner: Address,
         spender: Address,
@@ -504,6 +777,10 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         this._decreaseAllowance(owner, spender, amount);
     }
 
+    /**
+     * Internal: Verifies EIP-712 typed signatures.
+     * @protected
+     */
     protected _verifySignature(
         typeHash: u8[],
         owner: Address,
@@ -547,6 +824,10 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         this._nonceMap.set(owner, SafeMath.add(nonce, u256.One));
     }
 
+    /**
+     * Internal: Builds EIP-712 domain separator.
+     * @protected
+     */
     protected _buildDomainSeparator(): Uint8Array {
         const writer = new BytesWriter(32 * 5 + ADDRESS_BYTE_LENGTH);
         writer.writeBytesU8Array(OP712_DOMAIN_TYPE_HASH);
@@ -559,11 +840,15 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return sha256(writer.getBuffer());
     }
 
+    /**
+     * Internal: Increases allowance with overflow protection.
+     * @protected
+     */
     protected _increaseAllowance(owner: Address, spender: Address, amount: u256): void {
-        if (owner === Address.zero() || owner === Address.dead()) {
+        if (owner === Address.zero()) {
             throw new Revert('Invalid approver');
         }
-        if (spender === Address.zero() || spender === Address.dead()) {
+        if (spender === Address.zero()) {
             throw new Revert('Invalid spender');
         }
 
@@ -580,11 +865,15 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         this.createApprovedEvent(owner, spender, newAllowance);
     }
 
+    /**
+     * Internal: Decreases allowance with underflow protection.
+     * @protected
+     */
     protected _decreaseAllowance(owner: Address, spender: Address, amount: u256): void {
-        if (owner === Address.zero() || owner === Address.dead()) {
+        if (owner === Address.zero()) {
             throw new Revert('Invalid approver');
         }
-        if (spender === Address.zero() || spender === Address.dead()) {
+        if (spender === Address.zero()) {
             throw new Revert('Invalid spender');
         }
 
@@ -602,8 +891,14 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         this.createApprovedEvent(owner, spender, newAllowance);
     }
 
+    /**
+     * Internal: Mints new tokens to an address.
+     * @protected
+     *
+     * @throws {Revert} If exceeds max supply
+     */
     protected _mint(to: Address, amount: u256): void {
-        if (to === Address.zero() || to === Address.dead()) {
+        if (to === Address.zero()) {
             throw new Revert('Invalid receiver');
         }
 
@@ -620,8 +915,12 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         this.createMintedEvent(to, amount);
     }
 
+    /**
+     * Internal: Burns tokens from an address.
+     * @protected
+     */
     protected _burn(from: Address, amount: u256): void {
-        if (from === Address.zero() || from === Address.dead()) {
+        if (from === Address.zero()) {
             throw new Revert('Invalid sender');
         }
 
@@ -635,6 +934,7 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         this.createBurnedEvent(from, amount);
     }
 
+    /** Event creation helpers */
     protected createBurnedEvent(from: Address, amount: u256): void {
         this.emitEvent(new BurnedEvent(from, amount));
     }