@btc-vision/btc-runtime 1.9.9 → 1.9.11

package/package.json

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

package/runtime/buffer/BytesReader.ts

@@ -203,8 +203,7 @@ export class BytesReader {
     }
 
     /**
-     * [u32 length][raw bytes]. By default big-endian for the length,
-     * to match AS BytesWriter's `writeBytesWithLength`.
+     * [u32 length][raw bytes]. By default big-endian for the length
      */
     public readBytesWithLength(be: boolean = true): Uint8Array {
         const length = this.readU32(be);
@@ -248,8 +247,17 @@ export class BytesReader {
 
     // ------------------- Arrays ------------------- //
 
+    public readArrayOfBuffer(be: boolean = true): Uint8Array[] {
+        const length = this.readU16(be);
+        const result: Uint8Array[] = new Array<Uint8Array>(length);
+        for (let i: u32 = 0; i < length; i++) {
+            result[i] = this.readBytesWithLength();
+        }
+        return result;
+    }
+
     public readU256Array(be: boolean = true): u256[] {
-        const length = this.readU16();
+        const length = this.readU16(be);
         const result = new Array<u256>(length);
         for (let i: u32 = 0; i < length; i++) {
             result[i] = this.readU256(be);

package/runtime/buffer/BytesWriter.ts

@@ -19,6 +19,8 @@ import {
 } from '../utils';
 import { BytesReader } from './BytesReader';
 
+const arrayTooLargeError: string = 'Array is too large';
+
 @final
 export class BytesWriter {
     private currentOffset: u32 = 0;
@@ -30,6 +32,17 @@ export class BytesWriter {
         this.buffer = new DataView(typedArray.buffer);
     }
 
+    public static estimateArrayOfBufferLength(values: Uint8Array[]): u32 {
+        if (values.length > 65535) throw new Revert(arrayTooLargeError);
+        let totalLength: u32 = U16_BYTE_LENGTH;
+
+        for (let i = 0; i < values.length; i++) {
+            totalLength += U32_BYTE_LENGTH + u32(values[i].length); // each entry has a u32 length prefix
+        }
+
+        return totalLength;
+    }
+
     public bufferLength(): u32 {
         return this.buffer.byteLength;
     }
@@ -197,8 +210,20 @@ export class BytesWriter {
 
     // ------------------ Array Writers ------------------ //
 
+    public writeArrayOfBuffer(values: Uint8Array[], be: boolean = true): void {
+        const totalLength = BytesWriter.estimateArrayOfBufferLength(values);
+
+        this.allocSafe(totalLength);
+        this.writeU16(u16(values.length), be);
+
+        for (let i = 0; i < values.length; i++) {
+            this.writeU32(u32(values[i].length), be);
+            this.writeBytes(values[i]);
+        }
+    }
+
     public writeU8Array(value: u8[], be: boolean = true): void {
-        if (value.length > 65535) throw new Revert('Array size is too large');
+        if (value.length > 65535) throw new Revert(arrayTooLargeError);
         this.allocSafe(U16_BYTE_LENGTH + value.length);
         this.writeU16(u16(value.length), be);
 
@@ -208,7 +233,7 @@ export class BytesWriter {
     }
 
     public writeU16Array(value: u16[], be: boolean = true): void {
-        if (value.length > 65535) throw new Revert('Array size is too large');
+        if (value.length > 65535) throw new Revert(arrayTooLargeError);
         this.allocSafe(U16_BYTE_LENGTH + value.length * U16_BYTE_LENGTH);
         this.writeU16(u16(value.length), be);
 
@@ -218,7 +243,7 @@ export class BytesWriter {
     }
 
     public writeU32Array(value: u32[], be: boolean = true): void {
-        if (value.length > 65535) throw new Revert('Array size is too large');
+        if (value.length > 65535) throw new Revert(arrayTooLargeError);
         this.allocSafe(U16_BYTE_LENGTH + value.length * U32_BYTE_LENGTH);
         this.writeU16(u16(value.length), be);
 
@@ -228,7 +253,7 @@ export class BytesWriter {
     }
 
     public writeU64Array(value: u64[], be: boolean = true): void {
-        if (value.length > 65535) throw new Revert('Array size is too large');
+        if (value.length > 65535) throw new Revert(arrayTooLargeError);
         this.allocSafe(U16_BYTE_LENGTH + value.length * U64_BYTE_LENGTH);
         this.writeU16(u16(value.length), be);
 
@@ -238,7 +263,7 @@ export class BytesWriter {
     }
 
     public writeU128Array(value: u128[], be: boolean = true): void {
-        if (value.length > 65535) throw new Revert('Array size is too large');
+        if (value.length > 65535) throw new Revert(arrayTooLargeError);
         this.allocSafe(U16_BYTE_LENGTH + value.length * U128_BYTE_LENGTH);
         this.writeU16(u16(value.length), be);
 
@@ -248,7 +273,7 @@ export class BytesWriter {
     }
 
     public writeU256Array(value: u256[], be: boolean = true): void {
-        if (value.length > 65535) throw new Revert('Array size is too large');
+        if (value.length > 65535) throw new Revert(arrayTooLargeError);
         this.allocSafe(U16_BYTE_LENGTH + value.length * U256_BYTE_LENGTH);
         this.writeU16(u16(value.length), be);
 
@@ -258,7 +283,7 @@ export class BytesWriter {
     }
 
     public writeAddressArray(value: Address[]): void {
-        if (value.length > 65535) throw new Revert('Array size is too large');
+        if (value.length > 65535) throw new Revert(arrayTooLargeError);
         this.writeU16(u16(value.length));
 
         for (let i: i32 = 0; i < value.length; i++) {

package/runtime/constants/Exports.ts

@@ -14,7 +14,7 @@ export const ALLOWANCE_DECREASE_TYPE_HASH: u8[] = [
 ];
 
 // onOP721Received(address,address,uint256,bytes)
-export const ON_OP721_RECEIVED_SELECTOR: u32 = 0xd83e7dbc;
+export const ON_OP721_RECEIVED_SELECTOR: u32 = 0x5349f6de;
 
 // onOP1155Received(address,address,uint256,uint256,bytes)
 export const ON_OP1155_RECEIVED_MAGIC: u32 = 0xcedc9fdf;
@@ -61,10 +61,10 @@ export const OP712_VERSION_HASH: u8[] = [
     0x47, 0xad, 0xa4, 0xea, 0xa2, 0x2f, 0x1d, 0x49, 0xc0, 0x1e, 0x52, 0xdd, 0xb7, 0x87, 0x5b, 0x4b,
 ];
 
-// sha256("OP721Approve(address owner,address spender,uint256 tokenId,uint256 nonce,uint64 deadline)")
-export const OP721_APPROVE_TYPE_HASH: u8[] = [
-    0x2e, 0x4b, 0x1b, 0xb9, 0x26, 0xd1, 0xfe, 0x9c, 0x56, 0x8a, 0xca, 0xc1, 0xb9, 0xfc, 0x8b, 0x98,
-    0xf5, 0xfe, 0x67, 0xcb, 0x7b, 0x6d, 0x12, 0x03, 0x69, 0xaf, 0x3d, 0xb8, 0x44, 0x67, 0xb4, 0xcb,
+// 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
 ];
 
 // sha256("OP721Transfer(address from,address to,uint256 tokenId,uint256 nonce,uint64 deadline)")

package/runtime/contracts/OP20.ts

@@ -214,6 +214,37 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return w;
     }
 
+    @method(
+        { name: 'to', type: ABIDataTypes.ADDRESS },
+        { name: 'amount', type: ABIDataTypes.UINT256 },
+    )
+    @emit('Transferred')
+    public transfer(calldata: Calldata): BytesWriter {
+        this._transfer(
+            Blockchain.tx.sender,
+            calldata.readAddress(),
+            calldata.readU256(),
+        );
+        return new BytesWriter(0);
+    }
+
+    @method(
+        { name: 'from', type: ABIDataTypes.ADDRESS },
+        { name: 'to', type: ABIDataTypes.ADDRESS },
+        { name: 'amount', type: ABIDataTypes.UINT256 },
+    )
+    @emit('Transferred')
+    public transferFrom(calldata: Calldata): BytesWriter {
+        const from = calldata.readAddress();
+        const to = calldata.readAddress();
+        const amount = calldata.readU256();
+
+        this._spendAllowance(from, Blockchain.tx.sender, amount);
+        this._transfer(from, to, amount);
+
+        return new BytesWriter(0);
+    }
+
     @method(
         { name: 'to', type: ABIDataTypes.ADDRESS },
         { name: 'amount', type: ABIDataTypes.UINT256 },
@@ -221,7 +252,7 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
     )
     @emit('Transferred')
     public safeTransfer(calldata: Calldata): BytesWriter {
-        this._transfer(
+        this._safeTransfer(
             Blockchain.tx.sender,
             calldata.readAddress(),
             calldata.readU256(),
@@ -244,7 +275,7 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         const data = calldata.readBytesWithLength();
 
         this._spendAllowance(from, Blockchain.tx.sender, amount);
-        this._transfer(from, to, amount, data);
+        this._safeTransfer(from, to, amount, data);
 
         return new BytesWriter(0);
     }
@@ -326,10 +357,9 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
     @returns(
         { name: 'name', type: ABIDataTypes.STRING },
         { name: 'symbol', type: ABIDataTypes.STRING },
+        { name: 'icon', type: ABIDataTypes.STRING },
         { name: 'decimals', type: ABIDataTypes.UINT8 },
         { name: 'totalSupply', type: ABIDataTypes.UINT256 },
-        { name: 'maximumSupply', type: ABIDataTypes.UINT256 },
-        { name: 'icon', type: ABIDataTypes.STRING },
         { name: 'domainSeparator', type: ABIDataTypes.BYTES32 },
     )
     public metadata(_: Calldata): BytesWriter {
@@ -354,10 +384,9 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         const w = new BytesWriter(totalSize);
         w.writeStringWithLength(name);
         w.writeStringWithLength(symbol);
+        w.writeStringWithLength(icon);
         w.writeU8(this.decimals);
         w.writeU256(this.totalSupply);
-        w.writeU256(this.maxSupply);
-        w.writeStringWithLength(icon);
         w.writeBytesWithLength(domainSeparator);
 
         return w;
@@ -373,7 +402,7 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         return senderMap.get(spender);
     }
 
-    protected _transfer(from: Address, to: Address, amount: u256, data: Uint8Array): void {
+    protected _transfer(from: Address, to: Address, amount: u256, emitEvent: boolean = true): void {
         if (from === Address.zero() || from === Address.dead()) {
             throw new Revert('Invalid sender');
         }
@@ -382,10 +411,6 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
             throw new Revert('Invalid receiver');
         }
 
-        if (amount.isZero()) {
-            throw new Revert('Amount must be greater than zero');
-        }
-
         const balance: u256 = this.balanceOfMap.get(from);
         if (balance < amount) {
             throw new Revert('Insufficient balance');
@@ -396,13 +421,22 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         const toBal: u256 = this.balanceOfMap.get(to);
         this.balanceOfMap.set(to, SafeMath.add(toBal, amount));
 
-        this.createTransferredEvent(Blockchain.tx.sender, from, to, amount);
+        if (emitEvent) {
+            this.createTransferredEvent(Blockchain.tx.sender, from, to, amount);
+        }
+    }
+
+    protected _safeTransfer(from: Address, to: Address, amount: u256, data: Uint8Array): void {
+        this._transfer(from,  to, amount, false);
 
         if (Blockchain.isContract(to)) {
             // In CALLBACK mode, the guard allows depth up to 1
             // In STANDARD mode, the guard blocks all reentrancy
             this._callOnOP20Received(from, to, amount, data);
         }
+
+        // Fire event at the end if everything succeeded indicating a successful transfer
+        this.createTransferredEvent(Blockchain.tx.sender, from, to, amount);
     }
 
     protected _spendAllowance(owner: Address, spender: Address, amount: u256): void {

package/runtime/contracts/OP721.ts

@@ -24,19 +24,12 @@ import { IOP721 } from './interfaces/IOP721';
 import { OP721InitParameters } from './interfaces/OP721InitParameters';
 import { ReentrancyGuard } from './ReentrancyGuard';
 import { StoredMapU256 } from '../storage/maps/StoredMapU256';
-import {
-    ApprovedEvent,
-    ApprovedForAllEvent,
-    MAX_URI_LENGTH,
-    TransferredEvent,
-    URIEvent,
-} from '../events/predefined';
+import { ApprovedEvent, ApprovedForAllEvent, MAX_URI_LENGTH, TransferredEvent, URIEvent } from '../events/predefined';
 import {
     ON_OP721_RECEIVED_SELECTOR,
     OP712_DOMAIN_TYPE_HASH,
     OP712_VERSION_HASH,
-    OP721_APPROVE_TYPE_HASH,
-    OP721_TRANSFER_TYPE_HASH,
+    OP721_APPROVAL_TYPE_HASH,
 } from '../constants/Exports';
 
 const stringPointer: u16 = Blockchain.nextPointer;
@@ -52,7 +45,6 @@ const ownerTokensMapPointer: u16 = Blockchain.nextPointer;
 const tokenIndexMapPointer: u16 = Blockchain.nextPointer;
 const initializedPointer: u16 = Blockchain.nextPointer;
 const tokenURICounterPointer: u16 = Blockchain.nextPointer;
-const transferNonceMapPointer: u16 = Blockchain.nextPointer;
 const approveNonceMapPointer: u16 = Blockchain.nextPointer;
 
 export abstract class OP721 extends ReentrancyGuard implements IOP721 {
@@ -75,8 +67,6 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
     protected readonly balanceOfMap: AddressMemoryMap;
     protected readonly operatorApprovalMap: MapOfMap<u256>;
 
-    // Separate nonces for different operations
-    protected readonly _transferNonceMap: AddressMemoryMap;
     protected readonly _approveNonceMap: AddressMemoryMap;
 
     // Token URI storage - stores index to StoredString array
@@ -112,7 +102,6 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
         this.operatorApprovalMap = new MapOfMap<u256>(operatorApprovalMapPointer);
 
         // Initialize separate nonce maps
-        this._transferNonceMap = new AddressMemoryMap(transferNonceMapPointer);
         this._approveNonceMap = new AddressMemoryMap(approveNonceMapPointer);
 
         this.tokenURIIndices = new StoredMapU256(tokenURIMapPointer);
@@ -308,25 +297,17 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
     }
 
     @method(
-        { name: 'from', type: ABIDataTypes.ADDRESS },
         { name: 'to', type: ABIDataTypes.ADDRESS },
         { name: 'tokenId', type: ABIDataTypes.UINT256 },
         { name: 'data', type: ABIDataTypes.BYTES },
     )
     @emit('Transferred')
-    public safeTransferFrom(calldata: Calldata): BytesWriter {
-        const from = calldata.readAddress();
+    public safeTransfer(calldata: Calldata): BytesWriter {
         const to = calldata.readAddress();
         const tokenId = calldata.readU256();
         const data = calldata.readBytesWithLength();
 
-        // All state changes happen before external call
-        this._transfer(from, to, tokenId);
-
-        // External call happens after all state changes
-        if (Blockchain.isContract(to)) {
-            this._checkOnOP721Received(from, to, tokenId, data);
-        }
+        this._transfer(Blockchain.tx.sender, to, tokenId, data);
 
         return new BytesWriter(0);
     }
@@ -335,32 +316,34 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
         { name: 'from', type: ABIDataTypes.ADDRESS },
         { name: 'to', type: ABIDataTypes.ADDRESS },
         { name: 'tokenId', type: ABIDataTypes.UINT256 },
+        { name: 'data', type: ABIDataTypes.BYTES },
     )
     @emit('Transferred')
-    public transferFrom(calldata: Calldata): BytesWriter {
+    public safeTransferFrom(calldata: Calldata): BytesWriter {
         const from = calldata.readAddress();
         const to = calldata.readAddress();
         const tokenId = calldata.readU256();
+        const data = calldata.readBytesWithLength();
 
-        this._transfer(from, to, tokenId);
+        this._transfer(from, to, tokenId, data);
 
         return new BytesWriter(0);
     }
 
     @method(
-        { name: 'to', type: ABIDataTypes.ADDRESS },
+        { name: 'operator', type: ABIDataTypes.ADDRESS },
         { name: 'tokenId', type: ABIDataTypes.UINT256 },
     )
     @emit('Approved')
     public approve(calldata: Calldata): BytesWriter {
-        const to = calldata.readAddress();
+        const operator = calldata.readAddress();
         const tokenId = calldata.readU256();
 
         // Validate to address
-        if (to === Address.zero()) throw new Revert('Cannot approve to zero address');
+        if (operator === Address.zero()) throw new Revert('Cannot approve zero address');
 
         const owner = this._ownerOf(tokenId);
-        if (to === owner) throw new Revert('Approval to current owner');
+        if (operator === owner) throw new Revert('Approval to current owner');
 
         if (
             owner !== Blockchain.tx.sender &&
@@ -369,13 +352,12 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
             throw new Revert('Not authorized to approve');
         }
 
-        this._approve(to, tokenId);
+        this._approve(operator, tokenId);
 
         return new BytesWriter(0);
     }
 
     @method({ name: 'tokenId', type: ABIDataTypes.UINT256 })
-    @returns({ name: 'approved', type: ABIDataTypes.ADDRESS })
     public getApproved(calldata: Calldata): BytesWriter {
         const tokenId = calldata.readU256();
         if (!this._exists(tokenId)) throw new Revert('Token does not exist');
@@ -419,47 +401,50 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
 
     @method(
         { name: 'owner', type: ABIDataTypes.ADDRESS },
-        { name: 'to', type: ABIDataTypes.ADDRESS },
+        { name: 'operator', type: ABIDataTypes.ADDRESS },
         { name: 'tokenId', type: ABIDataTypes.UINT256 },
         { name: 'deadline', type: ABIDataTypes.UINT64 },
         { name: 'signature', type: ABIDataTypes.BYTES },
     )
-    @emit('Transferred')
-    public transferBySignature(calldata: Calldata): BytesWriter {
+    @emit('Approved')
+    public approveBySignature(calldata: Calldata): BytesWriter {
         const owner = calldata.readAddress();
-        const to = calldata.readAddress();
+        const operator = calldata.readAddress();
         const tokenId = calldata.readU256();
         const deadline = calldata.readU64();
         const signature = calldata.readBytesWithLength();
 
-        this._verifyTransferSignature(owner, to, tokenId, deadline, signature);
-        this._transfer(owner, to, tokenId);
+        // Verify ownership
+        const tokenOwner = this._ownerOf(tokenId);
+        if (tokenOwner !== owner) throw new Revert('Not token owner');
+
+        this._verifyApproveSignature(owner, operator, tokenId, deadline, signature);
+
+        this._approve(operator, tokenId);
 
         return new BytesWriter(0);
     }
 
     @method(
         { name: 'owner', type: ABIDataTypes.ADDRESS },
-        { name: 'spender', type: ABIDataTypes.ADDRESS },
-        { name: 'tokenId', type: ABIDataTypes.UINT256 },
+        { name: 'operator', type: ABIDataTypes.ADDRESS },
+        { name: 'approved', type: ABIDataTypes.BOOL },
         { name: 'deadline', type: ABIDataTypes.UINT64 },
         { name: 'signature', type: ABIDataTypes.BYTES },
     )
     @emit('Approved')
-    public approveBySignature(calldata: Calldata): BytesWriter {
+    public setApprovalForAllBySignature(calldata: Calldata): BytesWriter {
         const owner = calldata.readAddress();
-        const spender = calldata.readAddress();
-        const tokenId = calldata.readU256();
+        const operator = calldata.readAddress();
+        const approved = calldata.readBoolean();
         const deadline = calldata.readU64();
         const signature = calldata.readBytesWithLength();
 
-        // Verify ownership
-        const tokenOwner = this._ownerOf(tokenId);
-        if (tokenOwner !== owner) throw new Revert('Not token owner');
+        if (owner === operator) throw new Revert('Cannot approve self');
 
-        this._verifyApproveSignature(owner, spender, tokenId, deadline, signature);
+        this._verifySetApprovalForAllSignature(owner, operator, approved, deadline, signature);
 
-        this._approve(spender, tokenId);
+        this._setApprovalForAll(owner, operator, approved);
 
         return new BytesWriter(0);
     }
@@ -500,16 +485,6 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
         return w;
     }
 
-    @method({ name: 'owner', type: ABIDataTypes.ADDRESS })
-    @returns({ name: 'nonce', type: ABIDataTypes.UINT256 })
-    public getTransferNonce(calldata: Calldata): BytesWriter {
-        const owner = calldata.readAddress();
-        const nonce = this._transferNonceMap.get(owner);
-        const w = new BytesWriter(U256_BYTE_LENGTH);
-        w.writeU256(nonce);
-        return w;
-    }
-
     @method({ name: 'owner', type: ABIDataTypes.ADDRESS })
     @returns({ name: 'nonce', type: ABIDataTypes.UINT256 })
     public getApproveNonce(calldata: Calldata): BytesWriter {
@@ -546,7 +521,6 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
         { name: 'description', type: ABIDataTypes.STRING },
         { name: 'website', type: ABIDataTypes.STRING },
         { name: 'totalSupply', type: ABIDataTypes.UINT256 },
-        { name: 'maximumSupply', type: ABIDataTypes.UINT256 },
         { name: 'domainSeparator', type: ABIDataTypes.BYTES32 },
     )
     public metadata(_: Calldata): BytesWriter {
@@ -657,7 +631,7 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
         this.createTransferEvent(owner, Address.zero(), tokenId);
     }
 
-    protected _transfer(from: Address, to: Address, tokenId: u256): void {
+    protected _transfer(from: Address, to: Address, tokenId: u256, data: Uint8Array): void {
         // Skip self-transfers
         if (from === to) return;
 
@@ -699,6 +673,11 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
         // Transfer ownership
         this.ownerOfMap.set(tokenId, this._u256FromAddress(to));
 
+        // External call happens after all state changes
+        if (Blockchain.isContract(to)) {
+            this._checkOnOP721Received(from, to, tokenId, data);
+        }
+
         this.createTransferEvent(from, to, tokenId);
     }
 
@@ -774,10 +753,10 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
     ): void {
         const calldata = new BytesWriter(
             SELECTOR_BYTE_LENGTH +
-                ADDRESS_BYTE_LENGTH * 2 +
-                U256_BYTE_LENGTH +
-                U32_BYTE_LENGTH +
-                data.length,
+            ADDRESS_BYTE_LENGTH * 2 +
+            U256_BYTE_LENGTH +
+            U32_BYTE_LENGTH +
+            data.length,
         );
         calldata.writeSelector(ON_OP721_RECEIVED_SELECTOR);
         calldata.writeAddress(Blockchain.tx.sender);
@@ -796,9 +775,9 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
         }
     }
 
-    protected _verifyTransferSignature(
+    protected _verifyApproveSignature(
         owner: Address,
-        to: Address,
+        spender: Address,
         tokenId: u256,
         deadline: u64,
         signature: Uint8Array,
@@ -810,38 +789,26 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
             throw new Revert('Signature expired');
         }
 
-        const nonce = this._transferNonceMap.get(owner);
+        const nonce = this._approveNonceMap.get(owner);
 
         const structWriter = new BytesWriter(
             32 + ADDRESS_BYTE_LENGTH * 2 + U256_BYTE_LENGTH * 2 + U64_BYTE_LENGTH,
         );
-        structWriter.writeBytesU8Array(OP721_TRANSFER_TYPE_HASH);
+        structWriter.writeBytesU8Array(OP721_APPROVAL_TYPE_HASH);
         structWriter.writeAddress(owner);
-        structWriter.writeAddress(to);
+        structWriter.writeAddress(spender);
         structWriter.writeU256(tokenId);
         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(owner, signature, hash)) {
-            throw new Revert('Invalid signature');
-        }
-
-        this._transferNonceMap.set(owner, SafeMath.add(nonce, u256.One));
+        this._verifySignature(structHash, owner, signature, nonce);
     }
 
-    protected _verifyApproveSignature(
+    protected _verifySetApprovalForAllSignature(
         owner: Address,
         spender: Address,
-        tokenId: u256,
+        approved: boolean,
         deadline: u64,
         signature: Uint8Array,
     ): void {
@@ -857,15 +824,23 @@ export abstract class OP721 extends ReentrancyGuard implements IOP721 {
         const structWriter = new BytesWriter(
             32 + ADDRESS_BYTE_LENGTH * 2 + U256_BYTE_LENGTH * 2 + U64_BYTE_LENGTH,
         );
-        structWriter.writeBytesU8Array(OP721_APPROVE_TYPE_HASH);
+        structWriter.writeBytesU8Array(OP721_APPROVAL_TYPE_HASH);
         structWriter.writeAddress(owner);
         structWriter.writeAddress(spender);
-        structWriter.writeU256(tokenId);
+        structWriter.writeBoolean(approved);
         structWriter.writeU256(nonce);
         structWriter.writeU64(deadline);
 
         const structHash = sha256(structWriter.getBuffer());
+        this._verifySignature(structHash, owner, signature, nonce);
+    }
 
+    protected _verifySignature(
+        structHash: Uint8Array,
+        owner: Address,
+        signature: Uint8Array,
+        nonce: u256,
+    ): void {
         const messageWriter = new BytesWriter(2 + 32 + 32);
         messageWriter.writeU16(0x1901);
         messageWriter.writeBytes(this._buildDomainSeparator());

package/runtime/contracts/interfaces/IOP721.ts

@@ -13,7 +13,7 @@ export interface IOP721 {
     ownerOf(calldata: Calldata): BytesWriter;
 
     // Transfer functions
-    transferFrom(calldata: Calldata): BytesWriter;
+    safeTransfer(calldata: Calldata): BytesWriter;
     safeTransferFrom(calldata: Calldata): BytesWriter;
 
     // Approval functions
@@ -21,9 +21,10 @@ export interface IOP721 {
     getApproved(calldata: Calldata): BytesWriter;
     setApprovalForAll(calldata: Calldata): BytesWriter;
     isApprovedForAll(calldata: Calldata): BytesWriter;
+    approveBySignature(calldata: Calldata): BytesWriter;
+    setApprovalForAllBySignature(calldata: Calldata): BytesWriter;
 
     // Advanced functions
     burn(calldata: Calldata): BytesWriter;
-    transferBySignature(calldata: Calldata): BytesWriter;
     domainSeparator(calldata: Calldata): BytesWriter;
 }

package/runtime/env/classes/UTXO.ts

@@ -7,12 +7,17 @@ export class TransactionInput {
         public readonly txId: Uint8Array,
         public readonly outputIndex: u16,
         public readonly scriptSig: Uint8Array,
+        public readonly witnesses: Uint8Array[] | null,
         public readonly coinbase: Uint8Array | null,
     ) {}
 
     public get isCoinbase(): boolean {
         return (this.flags & TransactionInputFlags.hasCoinbase) !== 0;
     }
+
+    public get hasWitnesses(): boolean {
+        return (this.flags & TransactionInputFlags.hasWitnesses) !== 0;
+    }
 }
 
 @final

package/runtime/env/decoders/TransactionDecoder.ts

@@ -35,7 +35,14 @@ export class TransactionDecoder {
             ? buffer.readBytesWithLength()
             : null;
 
-        return new TransactionInput(flags, txId, outputIndex, scriptSig, coinbase);
+        const witnesses: Uint8Array[] | null = this.hasFlag(
+            flags,
+            TransactionInputFlags.hasWitnesses,
+        )
+            ? buffer.readArrayOfBuffer()
+            : null;
+
+        return new TransactionInput(flags, txId, outputIndex, scriptSig, witnesses, coinbase);
     }
 
     private decodeOutput(buffer: BytesReader): TransactionOutput {

package/runtime/env/enums/TransactionFlags.ts

@@ -1,5 +1,6 @@
 export enum TransactionInputFlags {
     hasCoinbase = 0b00000001,
+    hasWitnesses = 0b00000010,
 }
 
 export enum TransactionOutputFlags {