@btc-vision/btc-runtime 1.9.12 → 1.9.13

package/package.json

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

package/runtime/constants/Exports.ts

@@ -64,7 +64,13 @@ export const OP712_VERSION_HASH: u8[] = [
 // sha256("OP721Approval(address owner,address spender,uint256 tokenId,uint256 nonce,uint64 deadline)")
 export const OP721_APPROVAL_TYPE_HASH: u8[] = [
     0xb8, 0x6e, 0x99, 0xda, 0xc0, 0x47, 0x4b, 0x4a, 0x9f, 0xc3, 0x32, 0x3a, 0xd6, 0xed, 0x2f, 0x39,
-    0x55, 0xe7, 0xb8, 0x6d, 0xc6, 0x8c, 0x62, 0x42, 0x82, 0x1c, 0xbc, 0xac, 0xa2, 0xd8, 0x79, 0xde
+    0x55, 0xe7, 0xb8, 0x6d, 0xc6, 0x8c, 0x62, 0x42, 0x82, 0x1c, 0xbc, 0xac, 0xa2, 0xd8, 0x79, 0xde,
+];
+
+// sha256("OP721ApprovalForAll(address owner,address spender,bool approved,uint256 nonce,uint64 deadline)")
+export const OP721_APPROVAL_FOR_ALL_TYPE_HASH: u8[] = [
+    0x4f, 0x48, 0x06, 0x5d, 0x9e, 0xf1, 0x45, 0x25, 0x6b, 0xf7, 0x7f, 0xd2, 0xe5, 0x8b, 0x79, 0xe6,
+    0xf6, 0x0c, 0xd0, 0xd3, 0x47, 0x70, 0x14, 0x32, 0x34, 0x50, 0xc9, 0x65, 0xb7, 0x4b, 0x80, 0xed,
 ];
 
 // sha256("OP721Transfer(address from,address to,uint256 tokenId,uint256 nonce,uint64 deadline)")

package/runtime/contracts/OP721.ts

@@ -14,6 +14,7 @@ import { Revert } from '../types/Revert';
 import { SafeMath } from '../types/SafeMath';
 import {
     ADDRESS_BYTE_LENGTH,
+    BOOLEAN_BYTE_LENGTH,
     SELECTOR_BYTE_LENGTH,
     U256_BYTE_LENGTH,
     U32_BYTE_LENGTH,
@@ -29,6 +30,7 @@ import {
     ON_OP721_RECEIVED_SELECTOR,
     OP712_DOMAIN_TYPE_HASH,
     OP712_VERSION_HASH,
+    OP721_APPROVAL_FOR_ALL_TYPE_HASH,
     OP721_APPROVAL_TYPE_HASH,
 } from '../constants/Exports';
 
@@ -339,19 +341,6 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
         const operator = calldata.readAddress();
         const tokenId = calldata.readU256();
 
-        // Validate to address
-        if (operator === Address.zero()) throw new Revert('Cannot approve zero address');
-
-        const owner = this._ownerOf(tokenId);
-        if (operator === owner) throw new Revert('Approval to current owner');
-
-        if (
-            owner !== Blockchain.tx.sender &&
-            !this._isApprovedForAll(owner, Blockchain.tx.sender)
-        ) {
-            throw new Revert('Not authorized to approve');
-        }
-
         this._approve(operator, tokenId);
 
         return new BytesWriter(0);
@@ -673,18 +662,31 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
         // Transfer ownership
         this.ownerOfMap.set(tokenId, this._u256FromAddress(to));
 
+        this.createTransferEvent(from, to, tokenId);
+
         // External call happens after all state changes
         if (Blockchain.isContract(to)) {
             this._checkOnOP721Received(from, to, tokenId, data);
         }
-
-        this.createTransferEvent(from, to, tokenId);
     }
 
-    protected _approve(to: Address, tokenId: u256): void {
-        this.tokenApprovalMap.set(tokenId, this._u256FromAddress(to));
+    protected _approve(operator: Address, tokenId: u256): void {
+        // Validate to address
+        if (operator === Address.zero()) throw new Revert('Cannot approve zero address');
+
         const owner = this._ownerOf(tokenId);
-        this.createApprovedEvent(owner, to, tokenId);
+        if (operator === owner) throw new Revert('Approval to current owner');
+
+        if (
+            owner !== Blockchain.tx.sender &&
+            !this._isApprovedForAll(owner, Blockchain.tx.sender)
+        ) {
+            throw new Revert('Not authorized to approve');
+        }
+
+        this.tokenApprovalMap.set(tokenId, this._u256FromAddress(operator));
+
+        this.createApprovedEvent(owner, operator, tokenId);
     }
 
     protected _setApprovalForAll(owner: Address, operator: Address, approved: boolean): void {
@@ -822,9 +824,9 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
         const nonce = this._approveNonceMap.get(owner);
 
         const structWriter = new BytesWriter(
-            32 + ADDRESS_BYTE_LENGTH * 2 + U256_BYTE_LENGTH * 2 + U64_BYTE_LENGTH,
+            32 + ADDRESS_BYTE_LENGTH * 2 + BOOLEAN_BYTE_LENGTH + U256_BYTE_LENGTH + U64_BYTE_LENGTH,
         );
-        structWriter.writeBytesU8Array(OP721_APPROVAL_TYPE_HASH);
+        structWriter.writeBytesU8Array(OP721_APPROVAL_FOR_ALL_TYPE_HASH);
         structWriter.writeAddress(owner);
         structWriter.writeAddress(spender);
         structWriter.writeBoolean(approved);

package/runtime/index.ts

@@ -101,7 +101,6 @@ export * from './script/Segwit';
 export * from './constants/Exports';
 export * from './contracts/OP721';
 export * from './contracts/interfaces/IOP721';
-export * from './contracts/OP1155';
 export * from './contracts/interfaces/IOP1155';
 export * from './contracts/interfaces/OP721InitParameters';
 export * from './contracts/ReentrancyGuard';

package/runtime/contracts/OP1155.ts

@@ -1,1042 +0,0 @@
-import { u256 } from '@btc-vision/as-bignum/assembly';
-import { BytesWriter } from '../buffer/BytesWriter';
-import { Blockchain } from '../env';
-import { sha256, sha256String } from '../env/global';
-import { encodePointerUnknownLength } from '../math/abi';
-import { EMPTY_POINTER } from '../math/bytes';
-import { MapOfMap } from '../memory/MapOfMap';
-import { AddressMemoryMap } from '../memory/AddressMemoryMap';
-import { StoredString } from '../storage/StoredString';
-import { StoredU256 } from '../storage/StoredU256';
-import { Calldata } from '../types';
-import { Address } from '../types/Address';
-import { Revert } from '../types/Revert';
-import { SafeMath } from '../types/SafeMath';
-import {
-    ADDRESS_BYTE_LENGTH,
-    SELECTOR_BYTE_LENGTH,
-    U256_BYTE_LENGTH,
-    U32_BYTE_LENGTH,
-    U64_BYTE_LENGTH,
-} from '../utils';
-
-import { IOP1155 } from './interfaces/IOP1155';
-import { OP1155InitParameters } from './interfaces/OP1155InitParameters';
-import {
-    ApprovedForAllEvent,
-    TransferredBatchEvent,
-    TransferredSingleEvent,
-    URIEvent,
-} from '../events/predefined';
-import {
-    INTERFACE_ID_ERC165,
-    INTERFACE_ID_OP1155,
-    INTERFACE_ID_OP1155_METADATA_URI,
-    ON_OP1155_BATCH_RECEIVED_MAGIC,
-    ON_OP1155_RECEIVED_MAGIC,
-    OP1155_BATCH_TRANSFER_TYPE_HASH,
-    OP1155_TRANSFER_TYPE_HASH,
-    OP712_DOMAIN_TYPE_HASH,
-    OP712_VERSION_HASH,
-} from '../constants/Exports';
-import { ReentrancyGuard } from './ReentrancyGuard';
-
-// Storage pointers
-const namePointer: u16 = Blockchain.nextPointer;
-const symbolPointer: u16 = Blockchain.nextPointer;
-const baseUriPointer: u16 = Blockchain.nextPointer;
-const balanceMapPointer: u16 = Blockchain.nextPointer;
-const operatorApprovalMapPointer: u16 = Blockchain.nextPointer;
-const totalSupplyMapPointer: u16 = Blockchain.nextPointer;
-const nonceMapPointer: u16 = Blockchain.nextPointer;
-const initializedPointer: u16 = Blockchain.nextPointer;
-
-export abstract class OP1155 extends ReentrancyGuard implements IOP1155 {
-    // Nested mapping: account -> (id -> balance)
-    protected readonly balances: MapOfMap<u256>;
-
-    // Nested mapping: account -> (operator -> approved)
-    protected readonly operatorApprovals: MapOfMap<boolean>;
-
-    // Nonce mapping for signatures
-    protected readonly _nonceMap: AddressMemoryMap;
-
-    // Metadata
-    protected readonly _name: StoredString;
-    protected readonly _symbol: StoredString;
-    protected readonly _baseUri: StoredString;
-    protected readonly _initialized: StoredU256;
-
-    public constructor() {
-        super();
-
-        this.balances = new MapOfMap<u256>(balanceMapPointer);
-        this.operatorApprovals = new MapOfMap<boolean>(operatorApprovalMapPointer);
-        this._nonceMap = new AddressMemoryMap(nonceMapPointer);
-
-        this._name = new StoredString(namePointer, 0);
-        this._symbol = new StoredString(symbolPointer, 1);
-        this._baseUri = new StoredString(baseUriPointer, 0);
-        this._initialized = new StoredU256(initializedPointer, EMPTY_POINTER);
-    }
-
-    public get name(): string {
-        const nameValue = this._name.value;
-        if (!nameValue || nameValue.length === 0) throw new Revert('Name not set');
-        return nameValue;
-    }
-
-    public get symbol(): string {
-        const symbolValue = this._symbol.value;
-        if (!symbolValue || symbolValue.length === 0) throw new Revert('Symbol not set');
-        return symbolValue;
-    }
-
-    public instantiate(
-        params: OP1155InitParameters,
-        skipDeployerVerification: boolean = false,
-    ): void {
-        if (!this._initialized.value.isZero()) throw new Revert('Already initialized');
-        if (!skipDeployerVerification) this.onlyDeployer(Blockchain.tx.sender);
-
-        if (params.name.length == 0) throw new Revert('Name cannot be empty');
-        if (params.symbol.length == 0) throw new Revert('Symbol cannot be empty');
-
-        if (params.baseUri.length > 0 && !params.baseUri.includes('{id}')) {
-            throw new Revert('Base URI must contain {id} placeholder or be empty');
-        }
-
-        this._name.value = params.name;
-        this._symbol.value = params.symbol;
-        this._baseUri.value = params.baseUri;
-        this._initialized.value = u256.One;
-    }
-
-    @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({ name: 'interfaceId', type: ABIDataTypes.BYTES4 })
-    @returns({ name: 'supported', type: ABIDataTypes.BOOL })
-    public supportsInterface(calldata: Calldata): BytesWriter {
-        const interfaceId = calldata.readU32();
-
-        let supported = false;
-        if (
-            interfaceId === INTERFACE_ID_ERC165 ||
-            interfaceId === INTERFACE_ID_OP1155 ||
-            interfaceId === INTERFACE_ID_OP1155_METADATA_URI
-        ) {
-            supported = true;
-        }
-
-        const w = new BytesWriter(1);
-        w.writeBoolean(supported);
-        return w;
-    }
-
-    @method(
-        { name: 'account', type: ABIDataTypes.ADDRESS },
-        { name: 'id', type: ABIDataTypes.UINT256 },
-    )
-    @returns({ name: 'balance', type: ABIDataTypes.UINT256 })
-    public balanceOf(calldata: Calldata): BytesWriter {
-        const account = calldata.readAddress();
-        const id = calldata.readU256();
-
-        if (account.equals(Address.zero())) {
-            throw new Revert('Balance query for zero address');
-        }
-
-        const balance = this._balanceOf(account, id);
-        const w = new BytesWriter(U256_BYTE_LENGTH);
-        w.writeU256(balance);
-        return w;
-    }
-
-    @method(
-        { name: 'accounts', type: ABIDataTypes.ARRAY_OF_ADDRESSES },
-        { name: 'ids', type: ABIDataTypes.ARRAY_OF_UINT256 },
-    )
-    @returns({ name: 'balances', type: ABIDataTypes.ARRAY_OF_UINT256 })
-    public balanceOfBatch(calldata: Calldata): BytesWriter {
-        const accountsLength = calldata.readU32();
-        if (accountsLength === 0) {
-            throw new Revert('Empty arrays');
-        }
-
-        const accounts: Address[] = [];
-        for (let i: u32 = 0; i < accountsLength; i++) {
-            accounts.push(calldata.readAddress());
-        }
-
-        const idsLength = calldata.readU32();
-        const ids: u256[] = [];
-        for (let i: u32 = 0; i < idsLength; i++) {
-            ids.push(calldata.readU256());
-        }
-
-        if (accounts.length != ids.length) {
-            throw new Revert('Array length mismatch');
-        }
-
-        const w = new BytesWriter(U32_BYTE_LENGTH + accounts.length * U256_BYTE_LENGTH);
-        w.writeU32(u32(accounts.length));
-
-        for (let i: i32 = 0; i < accounts.length; i++) {
-            if (accounts[i].equals(Address.zero())) {
-                throw new Revert('Balance query for zero address');
-            }
-            w.writeU256(this._balanceOf(accounts[i], ids[i]));
-        }
-
-        return w;
-    }
-
-    @method(
-        { name: 'from', type: ABIDataTypes.ADDRESS },
-        { name: 'to', type: ABIDataTypes.ADDRESS },
-        { name: 'id', type: ABIDataTypes.UINT256 },
-        { name: 'amount', type: ABIDataTypes.UINT256 },
-        { name: 'data', type: ABIDataTypes.BYTES },
-    )
-    @emit('TransferredSingle')
-    public safeTransferFrom(calldata: Calldata): BytesWriter {
-        const from = calldata.readAddress();
-        const to = calldata.readAddress();
-        const id = calldata.readU256();
-        const amount = calldata.readU256();
-        const data = calldata.readBytesWithLength();
-
-        const operator = Blockchain.tx.sender;
-
-        // Check approval
-        if (!from.equals(operator) && !this._isApprovedForAll(from, operator)) {
-            throw new Revert('Caller is not owner nor approved');
-        }
-
-        this._safeTransferFrom(operator, from, to, id, amount, data);
-
-        return new BytesWriter(0);
-    }
-
-    @method(
-        { name: 'from', type: ABIDataTypes.ADDRESS },
-        { name: 'to', type: ABIDataTypes.ADDRESS },
-        { name: 'ids', type: ABIDataTypes.ARRAY_OF_UINT256 },
-        { name: 'amounts', type: ABIDataTypes.ARRAY_OF_UINT256 },
-        { name: 'data', type: ABIDataTypes.BYTES },
-    )
-    @emit('TransferredBatch')
-    public safeBatchTransferFrom(calldata: Calldata): BytesWriter {
-        const from = calldata.readAddress();
-        const to = calldata.readAddress();
-
-        const idsLength = calldata.readU32();
-        if (idsLength === 0) {
-            throw new Revert('Empty arrays');
-        }
-
-        const ids: u256[] = [];
-        for (let i: u32 = 0; i < idsLength; i++) {
-            ids.push(calldata.readU256());
-        }
-
-        const amountsLength = calldata.readU32();
-        const amounts: u256[] = [];
-        for (let i: u32 = 0; i < amountsLength; i++) {
-            amounts.push(calldata.readU256());
-        }
-
-        const data = calldata.readBytesWithLength();
-
-        const operator = Blockchain.tx.sender;
-
-        // Check approval
-        if (!from.equals(operator) && !this._isApprovedForAll(from, operator)) {
-            throw new Revert('Caller is not owner nor approved');
-        }
-
-        this._safeBatchTransferFrom(operator, from, to, ids, amounts, data);
-
-        return new BytesWriter(0);
-    }
-
-    @method(
-        { name: 'operator', type: ABIDataTypes.ADDRESS },
-        { name: 'approved', type: ABIDataTypes.BOOL },
-    )
-    @emit('ApprovedForAll')
-    public setApprovalForAll(calldata: Calldata): BytesWriter {
-        const operator = calldata.readAddress();
-        const approved = calldata.readBoolean();
-
-        this._setApprovalForAll(Blockchain.tx.sender, operator, approved);
-
-        return new BytesWriter(0);
-    }
-
-    @method(
-        { name: 'account', type: ABIDataTypes.ADDRESS },
-        { name: 'operator', type: ABIDataTypes.ADDRESS },
-    )
-    @returns({ name: 'approved', type: ABIDataTypes.BOOL })
-    public isApprovedForAll(calldata: Calldata): BytesWriter {
-        const account = calldata.readAddress();
-        const operator = calldata.readAddress();
-
-        const approved: boolean = this._isApprovedForAll(account, operator);
-        const w = new BytesWriter(1);
-        w.writeBoolean(approved);
-        return w;
-    }
-
-    @method({ name: 'id', type: ABIDataTypes.UINT256 })
-    @returns({ name: 'uri', type: ABIDataTypes.STRING })
-    public uri(calldata: Calldata): BytesWriter {
-        const id = calldata.readU256();
-        const tokenURI = this._uri(id);
-
-        const w = new BytesWriter(String.UTF8.byteLength(tokenURI) + 4);
-        w.writeStringWithLength(tokenURI);
-        return w;
-    }
-
-    @method({ name: 'id', type: ABIDataTypes.UINT256 })
-    @returns({ name: 'totalSupply', type: ABIDataTypes.UINT256 })
-    public totalSupply(calldata: Calldata): BytesWriter {
-        const id = calldata.readU256();
-        const supply = this._totalSupply(id);
-
-        const w = new BytesWriter(U256_BYTE_LENGTH);
-        w.writeU256(supply);
-        return w;
-    }
-
-    @method({ name: 'id', type: ABIDataTypes.UINT256 })
-    @returns({ name: 'exists', type: ABIDataTypes.BOOL })
-    public exists(calldata: Calldata): BytesWriter {
-        const id = calldata.readU256();
-        const exists = this._exists(id);
-
-        const w = new BytesWriter(1);
-        w.writeBoolean(exists);
-        return w;
-    }
-
-    @method(
-        { name: 'account', type: ABIDataTypes.ADDRESS },
-        { name: 'id', type: ABIDataTypes.UINT256 },
-        { name: 'amount', type: ABIDataTypes.UINT256 },
-    )
-    @emit('TransferredSingle')
-    public burn(calldata: Calldata): BytesWriter {
-        const account = calldata.readAddress();
-        const id = calldata.readU256();
-        const amount = calldata.readU256();
-
-        // Check if sender is authorized
-        if (
-            !account.equals(Blockchain.tx.sender) &&
-            !this._isApprovedForAll(account, Blockchain.tx.sender)
-        ) {
-            throw new Revert('Not authorized to burn');
-        }
-
-        this._burn(account, id, amount);
-        return new BytesWriter(0);
-    }
-
-    @method(
-        { name: 'account', type: ABIDataTypes.ADDRESS },
-        { name: 'ids', type: ABIDataTypes.ARRAY_OF_UINT256 },
-        { name: 'amounts', type: ABIDataTypes.ARRAY_OF_UINT256 },
-    )
-    @emit('TransferredBatch')
-    public burnBatch(calldata: Calldata): BytesWriter {
-        const account = calldata.readAddress();
-
-        const idsLength = calldata.readU32();
-        const ids: u256[] = [];
-        for (let i: u32 = 0; i < idsLength; i++) {
-            ids.push(calldata.readU256());
-        }
-
-        const amountsLength = calldata.readU32();
-        const amounts: u256[] = [];
-        for (let i: u32 = 0; i < amountsLength; i++) {
-            amounts.push(calldata.readU256());
-        }
-
-        // Check if sender is authorized
-        if (
-            !account.equals(Blockchain.tx.sender) &&
-            !this._isApprovedForAll(account, Blockchain.tx.sender)
-        ) {
-            throw new Revert('Not authorized to burn');
-        }
-
-        this._burnBatch(account, ids, amounts);
-        return new BytesWriter(0);
-    }
-
-    @method(
-        { name: 'from', type: ABIDataTypes.ADDRESS },
-        { name: 'to', type: ABIDataTypes.ADDRESS },
-        { name: 'id', type: ABIDataTypes.UINT256 },
-        { name: 'amount', type: ABIDataTypes.UINT256 },
-        { name: 'deadline', type: ABIDataTypes.UINT64 },
-        { name: 'signature', type: ABIDataTypes.BYTES },
-    )
-    @emit('TransferredSingle')
-    public transferBySignature(calldata: Calldata): BytesWriter {
-        const from = calldata.readAddress();
-        const to = calldata.readAddress();
-        const id = calldata.readU256();
-        const amount = calldata.readU256();
-        const deadline = calldata.readU64();
-        const signature = calldata.readBytesWithLength();
-
-        this._verifyTransferSignature(from, to, id, amount, deadline, signature);
-        this._safeTransferFrom(from, from, to, id, amount, new Uint8Array(0));
-
-        return new BytesWriter(0);
-    }
-
-    @method(
-        { name: 'from', type: ABIDataTypes.ADDRESS },
-        { name: 'to', type: ABIDataTypes.ADDRESS },
-        { name: 'ids', type: ABIDataTypes.ARRAY_OF_UINT256 },
-        { name: 'amounts', type: ABIDataTypes.ARRAY_OF_UINT256 },
-        { name: 'deadline', type: ABIDataTypes.UINT64 },
-        { name: 'signature', type: ABIDataTypes.BYTES },
-    )
-    @emit('TransferredBatch')
-    public batchTransferBySignature(calldata: Calldata): BytesWriter {
-        const from = calldata.readAddress();
-        const to = calldata.readAddress();
-
-        const idsLength = calldata.readU32();
-        const ids: u256[] = [];
-        for (let i: u32 = 0; i < idsLength; i++) {
-            ids.push(calldata.readU256());
-        }
-
-        const amountsLength = calldata.readU32();
-        const amounts: u256[] = [];
-        for (let i: u32 = 0; i < amountsLength; i++) {
-            amounts.push(calldata.readU256());
-        }
-
-        const deadline = calldata.readU64();
-        const signature = calldata.readBytesWithLength();
-
-        this._verifyBatchTransferSignature(from, to, ids, amounts, deadline, signature);
-        this._safeBatchTransferFrom(from, from, to, ids, amounts, new Uint8Array(0));
-
-        return new BytesWriter(0);
-    }
-
-    @method()
-    @returns({ name: 'domainSeparator', type: ABIDataTypes.BYTES32 })
-    public domainSeparator(_: Calldata): BytesWriter {
-        const w = new BytesWriter(32);
-        w.writeBytes(this._buildDomainSeparator());
-        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;
-    }
-
-    // Internal functions
-    protected _balanceOf(account: Address, id: u256): u256 {
-        const accountBalances = this.balances.get(account);
-        const idKey = id.toUint8Array(true);
-        const balance = accountBalances.get(idKey);
-        return balance ? balance : u256.Zero;
-    }
-
-    protected _isApprovedForAll(account: Address, operator: Address): boolean {
-        const accountApprovals = this.operatorApprovals.get(account);
-        return accountApprovals.get(operator);
-    }
-
-    protected _exists(id: u256): boolean {
-        return this._totalSupply(id) > u256.Zero;
-    }
-
-    protected _setApprovalForAll(owner: Address, operator: Address, approved: boolean): void {
-        if (owner.equals(operator)) {
-            throw new Revert('Setting approval status for self');
-        }
-
-        const ownerApprovals = this.operatorApprovals.get(owner);
-        ownerApprovals.set(operator, approved);
-
-        this.emitEvent(new ApprovedForAllEvent(owner, operator, approved));
-    }
-
-    protected _safeTransferFrom(
-        operator: Address,
-        from: Address,
-        to: Address,
-        id: u256,
-        amount: u256,
-        data: Uint8Array,
-    ): void {
-        if (amount.isZero()) {
-            throw new Revert('Transfer amount must be greater than zero');
-        }
-
-        if (to.equals(Address.zero())) {
-            throw new Revert('Transfer to zero address');
-        }
-
-        this._beforeTokenTransfer(operator, from, to, [id], [amount], data);
-
-        const idKey = id.toUint8Array(true);
-
-        // Update from balance
-        const fromBalances = this.balances.get(from);
-        const fromBalance = fromBalances.get(idKey);
-
-        if (!fromBalance || fromBalance < amount) {
-            throw new Revert('Insufficient balance for transfer');
-        }
-
-        fromBalances.set(idKey, SafeMath.sub(fromBalance, amount));
-
-        // Update to balance
-        const toBalances = this.balances.get(to);
-        const toBalance = toBalances.get(idKey);
-        const newToBalance = toBalance ? SafeMath.add(toBalance, amount) : amount;
-        toBalances.set(idKey, newToBalance);
-
-        // Call receiver hook if contract
-        this._doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
-
-        this.emitEvent(new TransferredSingleEvent(operator, from, to, id, amount));
-
-        this._afterTokenTransfer(operator, from, to, [id], [amount], data);
-    }
-
-    protected _safeBatchTransferFrom(
-        operator: Address,
-        from: Address,
-        to: Address,
-        ids: u256[],
-        amounts: u256[],
-        data: Uint8Array,
-    ): void {
-        if (ids.length != amounts.length) {
-            throw new Revert('Array length mismatch');
-        }
-
-        if (to.equals(Address.zero())) {
-            throw new Revert('Transfer to zero address');
-        }
-
-        this._beforeTokenTransfer(operator, from, to, ids, amounts, data);
-
-        const fromBalances = this.balances.get(from);
-        const toBalances = this.balances.get(to);
-
-        for (let i = 0; i < ids.length; i++) {
-            const id = ids[i];
-            const amount = amounts[i];
-            if (amount.isZero()) {
-                throw new Revert('Transfer amount must be greater than zero');
-            }
-
-            const idKey = id.toUint8Array(true);
-
-            const fromBalance = fromBalances.get(idKey);
-            if (!fromBalance || fromBalance < amount) {
-                throw new Revert('Insufficient balance for transfer');
-            }
-
-            fromBalances.set(idKey, SafeMath.sub(fromBalance, amount));
-
-            const toBalance = toBalances.get(idKey);
-            const newToBalance = toBalance ? SafeMath.add(toBalance, amount) : amount;
-            toBalances.set(idKey, newToBalance);
-        }
-
-        const maxBatchSize: i32 = 3;
-        for (let i: i32 = 0; i < ids.length; i += maxBatchSize) {
-            const endIndex = min(i + maxBatchSize, ids.length);
-            const batchIds = ids.slice(i, endIndex);
-            const batchAmounts = amounts.slice(i, endIndex);
-            this.emitEvent(new TransferredBatchEvent(operator, from, to, batchIds, batchAmounts));
-        }
-
-        this._afterTokenTransfer(operator, from, to, ids, amounts, data);
-
-        // Call receiver hook if contract
-        this._doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
-    }
-
-    protected _mint(to: Address, id: u256, amount: u256, data: Uint8Array): void {
-        if (to.equals(Address.zero())) {
-            throw new Revert('Mint to zero address');
-        }
-
-        if (amount.isZero()) {
-            throw new Revert('Transfer amount must be greater than zero');
-        }
-
-        const operator = Blockchain.tx.sender;
-
-        this._beforeTokenTransfer(operator, Address.zero(), to, [id], [amount], data);
-
-        const idKey = id.toUint8Array(true);
-
-        // Update balance
-        const toBalances = this.balances.get(to);
-        const toBalance = toBalances.get(idKey);
-        const newBalance = toBalance ? SafeMath.add(toBalance, amount) : amount;
-        toBalances.set(idKey, newBalance);
-
-        // Update total supply
-        const currentSupply = this._totalSupply(id);
-        this._setTotalSupply(id, SafeMath.add(currentSupply, amount));
-
-        this.emitEvent(new TransferredSingleEvent(operator, Address.zero(), to, id, amount));
-
-        this._afterTokenTransfer(operator, Address.zero(), to, [id], [amount], data);
-
-        // Call receiver hook if contract
-        this._doSafeTransferAcceptanceCheck(operator, Address.zero(), to, id, amount, data);
-    }
-
-    protected _mintBatch(to: Address, ids: u256[], amounts: u256[], data: Uint8Array): void {
-        if (to.equals(Address.zero())) {
-            throw new Revert('Mint to zero address');
-        }
-
-        if (ids.length != amounts.length) {
-            throw new Revert('Array length mismatch');
-        }
-
-        const operator = Blockchain.tx.sender;
-
-        this._beforeTokenTransfer(operator, Address.zero(), to, ids, amounts, data);
-
-        const toBalances = this.balances.get(to);
-
-        for (let i: i32 = 0; i < ids.length; i++) {
-            const id = ids[i];
-            const amount = amounts[i];
-            if (amount.isZero()) {
-                throw new Revert('Transfer amount must be greater than zero');
-            }
-
-            const idKey = id.toUint8Array(true);
-
-            const toBalance = toBalances.get(idKey);
-            const newBalance = toBalance ? SafeMath.add(toBalance, amount) : amount;
-            toBalances.set(idKey, newBalance);
-
-            // Update total supply
-            const currentSupply = this._totalSupply(id);
-            this._setTotalSupply(id, SafeMath.add(currentSupply, amount));
-        }
-
-        // Emit events in batches of 3 due to event size limit
-        const maxBatchSize = 3;
-        for (let i: i32 = 0; i < ids.length; i += maxBatchSize) {
-            const endIndex = min(i + maxBatchSize, ids.length);
-            const batchIds = ids.slice(i, endIndex);
-            const batchAmounts = amounts.slice(i, endIndex);
-            this.emitEvent(
-                new TransferredBatchEvent(operator, Address.zero(), to, batchIds, batchAmounts),
-            );
-        }
-
-        this._afterTokenTransfer(operator, Address.zero(), to, ids, amounts, data);
-
-        // Call receiver hook if contract
-        this._doSafeBatchTransferAcceptanceCheck(operator, Address.zero(), to, ids, amounts, data);
-    }
-
-    protected _burn(from: Address, id: u256, amount: u256): void {
-        if (from.equals(Address.zero())) {
-            throw new Revert('Burn from zero address');
-        }
-
-        if (amount.isZero()) {
-            throw new Revert('Transfer amount must be greater than zero');
-        }
-
-        const operator = Blockchain.tx.sender;
-
-        this._beforeTokenTransfer(
-            operator,
-            from,
-            Address.zero(),
-            [id],
-            [amount],
-            new Uint8Array(0),
-        );
-
-        const idKey = id.toUint8Array(true);
-
-        const fromBalances = this.balances.get(from);
-        const fromBalance = fromBalances.get(idKey);
-
-        if (!fromBalance || fromBalance < amount) {
-            throw new Revert('Burn amount exceeds balance');
-        }
-
-        fromBalances.set(idKey, SafeMath.sub(fromBalance, amount));
-
-        // Update total supply
-        const currentSupply = this._totalSupply(id);
-        this._setTotalSupply(id, SafeMath.sub(currentSupply, amount));
-
-        this.emitEvent(new TransferredSingleEvent(operator, from, Address.zero(), id, amount));
-
-        this._afterTokenTransfer(operator, from, Address.zero(), [id], [amount], new Uint8Array(0));
-    }
-
-    protected _burnBatch(from: Address, ids: u256[], amounts: u256[]): void {
-        if (from.equals(Address.zero())) {
-            throw new Revert('Burn from zero address');
-        }
-
-        if (ids.length != amounts.length) {
-            throw new Revert('Array length mismatch');
-        }
-
-        const operator = Blockchain.tx.sender;
-
-        this._beforeTokenTransfer(operator, from, Address.zero(), ids, amounts, new Uint8Array(0));
-
-        const fromBalances = this.balances.get(from);
-
-        for (let i: i32 = 0; i < ids.length; i++) {
-            const id = ids[i];
-            const amount = amounts[i];
-            if (amount.isZero()) {
-                throw new Revert('Transfer amount must be greater than zero');
-            }
-
-            const idKey = id.toUint8Array(true);
-
-            const fromBalance = fromBalances.get(idKey);
-            if (!fromBalance || fromBalance < amount) {
-                throw new Revert('Burn amount exceeds balance');
-            }
-
-            fromBalances.set(idKey, SafeMath.sub(fromBalance, amount));
-
-            // Update total supply
-            const currentSupply = this._totalSupply(id);
-            this._setTotalSupply(id, SafeMath.sub(currentSupply, amount));
-        }
-
-        const maxBatchSize: i32 = 3;
-        for (let i: i32 = 0; i < ids.length; i += maxBatchSize) {
-            const endIndex = min(i + maxBatchSize, ids.length);
-            const batchIds = ids.slice(i, endIndex);
-            const batchAmounts = amounts.slice(i, endIndex);
-            this.emitEvent(
-                new TransferredBatchEvent(operator, from, Address.zero(), batchIds, batchAmounts),
-            );
-        }
-
-        this._afterTokenTransfer(operator, from, Address.zero(), ids, amounts, new Uint8Array(0));
-    }
-
-    protected _setURI(newuri: string): void {
-        this._baseUri.value = newuri;
-
-        this.emitEvent(new URIEvent(newuri, u256.Zero));
-    }
-
-    protected _uri(id: u256): string {
-        const baseUri = this._baseUri.value;
-        if (!baseUri || baseUri.length === 0) {
-            return '';
-        }
-
-        // Replace {id} with actual token ID in hex format
-        const idHex = this._toHexString(id);
-        return baseUri.replace('{id}', idHex);
-    }
-
-    protected _totalSupply(id: u256): u256 {
-        const key = this._getTokenStorageKey(totalSupplyMapPointer, id);
-        const supplyBytes = Blockchain.getStorageAt(key);
-        if (supplyBytes.length === 0) return u256.Zero;
-        return u256.fromUint8ArrayBE(supplyBytes);
-    }
-
-    protected _setTotalSupply(id: u256, supply: u256): void {
-        const key = this._getTokenStorageKey(totalSupplyMapPointer, id);
-        Blockchain.setStorageAt(key, supply.toUint8Array(true));
-    }
-
-    // Signature verification
-    protected _verifyTransferSignature(
-        from: Address,
-        to: Address,
-        id: u256,
-        amount: u256,
-        deadline: u64,
-        signature: Uint8Array,
-    ): void {
-        if (signature.length !== 64) {
-            throw new Revert('Invalid signature length');
-        }
-        if (Blockchain.block.number > deadline) {
-            throw new Revert('Signature expired');
-        }
-
-        const nonce = this._nonceMap.get(from);
-
-        const structWriter = new BytesWriter(
-            32 + ADDRESS_BYTE_LENGTH * 2 + U256_BYTE_LENGTH * 3 + U64_BYTE_LENGTH,
-        );
-        structWriter.writeBytesU8Array(OP1155_TRANSFER_TYPE_HASH);
-        structWriter.writeAddress(from);
-        structWriter.writeAddress(to);
-        structWriter.writeU256(id);
-        structWriter.writeU256(amount);
-        structWriter.writeU256(nonce);
-        structWriter.writeU64(deadline);
-
-        const structHash = sha256(structWriter.getBuffer());
-
-        const messageWriter = new BytesWriter(2 + 32 + 32);
-        messageWriter.writeU16(0x1901);
-        messageWriter.writeBytes(this._buildDomainSeparator());
-        messageWriter.writeBytes(structHash);
-
-        const hash = sha256(messageWriter.getBuffer());
-
-        if (!Blockchain.verifySchnorrSignature(from, signature, hash)) {
-            throw new Revert('Invalid signature');
-        }
-
-        this._nonceMap.set(from, SafeMath.add(nonce, u256.One));
-    }
-
-    protected _verifyBatchTransferSignature(
-        from: Address,
-        to: Address,
-        ids: u256[],
-        amounts: u256[],
-        deadline: u64,
-        signature: Uint8Array,
-    ): void {
-        if (signature.length !== 64) {
-            throw new Revert('Invalid signature length');
-        }
-
-        if (Blockchain.block.number > deadline) {
-            throw new Revert('Signature expired');
-        }
-
-        const nonce = this._nonceMap.get(from);
-
-        // Calculate arrays hash
-        const idsWriter = new BytesWriter(ids.length * U256_BYTE_LENGTH);
-        for (let i: i32 = 0; i < ids.length; i++) {
-            idsWriter.writeU256(ids[i]);
-        }
-
-        const idsHash = sha256(idsWriter.getBuffer());
-        const amountsWriter = new BytesWriter(amounts.length * U256_BYTE_LENGTH);
-
-        for (let i: i32 = 0; i < amounts.length; i++) {
-            amountsWriter.writeU256(amounts[i]);
-        }
-
-        const amountsHash = sha256(amountsWriter.getBuffer());
-        const structWriter = new BytesWriter(
-            32 * 4 + ADDRESS_BYTE_LENGTH * 2 + U256_BYTE_LENGTH + U64_BYTE_LENGTH,
-        );
-
-        structWriter.writeBytesU8Array(OP1155_BATCH_TRANSFER_TYPE_HASH);
-        structWriter.writeAddress(from);
-        structWriter.writeAddress(to);
-        structWriter.writeBytes(idsHash);
-        structWriter.writeBytes(amountsHash);
-        structWriter.writeU256(nonce);
-        structWriter.writeU64(deadline);
-
-        const structHash = sha256(structWriter.getBuffer());
-        const messageWriter = new BytesWriter(2 + 32 + 32);
-        messageWriter.writeU16(0x1901);
-        messageWriter.writeBytes(this._buildDomainSeparator());
-        messageWriter.writeBytes(structHash);
-
-        const hash = sha256(messageWriter.getBuffer());
-        if (!Blockchain.verifySchnorrSignature(from, signature, hash)) {
-            throw new Revert('Invalid signature');
-        }
-
-        this._nonceMap.set(from, SafeMath.add(nonce, u256.One));
-    }
-
-    protected _buildDomainSeparator(): Uint8Array {
-        const writer = new BytesWriter(32 * 5 + ADDRESS_BYTE_LENGTH);
-        writer.writeBytesU8Array(OP712_DOMAIN_TYPE_HASH);
-        writer.writeBytes(sha256String(this.name));
-        writer.writeBytesU8Array(OP712_VERSION_HASH);
-        writer.writeBytes(Blockchain.chainId);
-        writer.writeBytes(Blockchain.protocolId);
-        writer.writeAddress(this.address);
-
-        return sha256(writer.getBuffer());
-    }
-
-    // Hooks for extensions
-    protected _beforeTokenTransfer(
-        operator: Address,
-        from: Address,
-        to: Address,
-        ids: u256[],
-        amounts: u256[],
-        data: Uint8Array,
-    ): void {
-        // Hook that can be overridden by extensions
-    }
-
-    protected _afterTokenTransfer(
-        operator: Address,
-        from: Address,
-        to: Address,
-        ids: u256[],
-        amounts: u256[],
-        data: Uint8Array,
-    ): void {
-        // Hook that can be overridden by extensions
-    }
-
-    // Helper to get storage key for token-specific data
-    private _getTokenStorageKey(pointer: u16, id: u256): Uint8Array {
-        const idBytes = id.toUint8Array(true);
-        return encodePointerUnknownLength(pointer, idBytes);
-    }
-
-    // Helper to convert u256 to hex string
-    private _toHexString(value: u256): string {
-        const bytes = value.toUint8Array(true);
-        let hex: string = '';
-
-        // Convert each byte to hex
-        for (let i: i32 = 0; i < bytes.length; i++) {
-            const byte = bytes[i];
-            const hi = byte >> 4;
-            const lo = byte & 0x0f;
-            hex += hi < 10 ? String.fromCharCode(48 + hi) : String.fromCharCode(87 + hi);
-            hex += lo < 10 ? String.fromCharCode(48 + lo) : String.fromCharCode(87 + lo);
-        }
-
-        // Remove leading zeros, but keep at least one character
-        let startIndex = 0;
-        while (startIndex < hex.length - 1 && hex.charCodeAt(startIndex) === 48) {
-            startIndex++;
-        }
-
-        return startIndex > 0 ? hex.substring(startIndex) : hex;
-    }
-
-    private _doSafeTransferAcceptanceCheck(
-        operator: Address,
-        from: Address,
-        to: Address,
-        id: u256,
-        amount: u256,
-        data: Uint8Array,
-    ): void {
-        if (Blockchain.isContract(to)) {
-            const calldata = new BytesWriter(
-                SELECTOR_BYTE_LENGTH +
-                    ADDRESS_BYTE_LENGTH * 2 +
-                    U256_BYTE_LENGTH * 2 +
-                    U32_BYTE_LENGTH +
-                    data.length,
-            );
-            calldata.writeSelector(ON_OP1155_RECEIVED_MAGIC);
-            calldata.writeAddress(operator);
-            calldata.writeAddress(from);
-            calldata.writeU256(id);
-            calldata.writeU256(amount);
-            calldata.writeBytesWithLength(data);
-
-            const response = Blockchain.call(to, calldata);
-            if (response.data.byteLength < SELECTOR_BYTE_LENGTH) {
-                throw new Revert('Transfer to non-OP1155Receiver implementer');
-            }
-
-            const retVal = response.data.readSelector();
-            if (retVal !== ON_OP1155_RECEIVED_MAGIC) {
-                throw new Revert('OP1155Receiver rejected tokens');
-            }
-        }
-    }
-
-    private _doSafeBatchTransferAcceptanceCheck(
-        operator: Address,
-        from: Address,
-        to: Address,
-        ids: u256[],
-        amounts: u256[],
-        data: Uint8Array,
-    ): void {
-        if (Blockchain.isContract(to)) {
-            const calldata = new BytesWriter(
-                SELECTOR_BYTE_LENGTH +
-                    ADDRESS_BYTE_LENGTH * 2 +
-                    U32_BYTE_LENGTH * 2 +
-                    ids.length * U256_BYTE_LENGTH +
-                    amounts.length * U256_BYTE_LENGTH +
-                    U32_BYTE_LENGTH +
-                    data.length,
-            );
-            calldata.writeSelector(ON_OP1155_BATCH_RECEIVED_MAGIC);
-            calldata.writeAddress(operator);
-            calldata.writeAddress(from);
-            calldata.writeU32(u32(ids.length));
-            for (let i: i32 = 0; i < ids.length; i++) {
-                calldata.writeU256(ids[i]);
-            }
-            calldata.writeU32(u32(amounts.length));
-            for (let i: i32 = 0; i < amounts.length; i++) {
-                calldata.writeU256(amounts[i]);
-            }
-            calldata.writeBytesWithLength(data);
-
-            const response = Blockchain.call(to, calldata);
-            if (response.data.byteLength < SELECTOR_BYTE_LENGTH) {
-                throw new Revert('Transfer to non-OP1155Receiver implementer');
-            }
-
-            const retVal = response.data.readSelector();
-            if (retVal !== ON_OP1155_BATCH_RECEIVED_MAGIC) {
-                throw new Revert('OP1155Receiver rejected tokens');
-            }
-        }
-    }
-}