@btc-vision/btc-runtime 1.9.10 → 1.9.12

package/package.json

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

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): 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');
@@ -397,6 +422,10 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         this.balanceOfMap.set(to, SafeMath.add(toBal, amount));
 
         this.createTransferredEvent(Blockchain.tx.sender, from, to, amount);
+    }
+
+    protected _safeTransfer(from: Address, to: Address, amount: u256, data: Uint8Array): void {
+        this._transfer(from,  to, amount);
 
         if (Blockchain.isContract(to)) {
             // In CALLBACK mode, the guard allows depth up to 1

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/shared-libraries/TransferHelper.ts

@@ -10,6 +10,8 @@ import {
     U32_BYTE_LENGTH,
 } from '../utils';
 
+export const transferSignature = 'transfer(address,uint256)';
+export const transferFromSignature = 'transferFrom(address,address,uint256)';
 export const SafeTransferSignature = 'safeTransfer(address,uint256,bytes)';
 export const SafeTransferFromSignature = 'safeTransferFrom(address,address,uint256,bytes)';
 export const IncreaseAllowanceSignature = 'increaseAllowance(address,uint256)';
@@ -26,14 +28,22 @@ export class TransferHelper {
     }
 
     public static get TRANSFER_SELECTOR(): Selector {
-        return encodeSelector(SafeTransferSignature);
+        return encodeSelector(transferSignature);
     }
 
     public static get TRANSFER_FROM_SELECTOR(): Selector {
+        return encodeSelector(transferFromSignature);
+    }
+
+    public static get SAFE_TRANSFER_SELECTOR(): Selector {
+        return encodeSelector(SafeTransferSignature);
+    }
+
+    public static get SAFE_TRANSFER_FROM_SELECTOR(): Selector {
         return encodeSelector(SafeTransferFromSignature);
     }
 
-    public static safeIncreaseAllowance(token: Address, spender: Address, amount: u256): void {
+    public static increaseAllowance(token: Address, spender: Address, amount: u256): void {
         const calldata = new BytesWriter(
             SELECTOR_BYTE_LENGTH + ADDRESS_BYTE_LENGTH + U256_BYTE_LENGTH,
         );
@@ -44,7 +54,7 @@ export class TransferHelper {
         Blockchain.call(token, calldata);
     }
 
-    public static safeDecreaseAllowance(token: Address, spender: Address, amount: u256): void {
+    public static decreaseAllowance(token: Address, spender: Address, amount: u256): void {
         const calldata = new BytesWriter(
             SELECTOR_BYTE_LENGTH + ADDRESS_BYTE_LENGTH + U256_BYTE_LENGTH,
         );
@@ -55,6 +65,42 @@ export class TransferHelper {
         Blockchain.call(token, calldata);
     }
 
+    public static transfer(
+        token: Address,
+        to: Address,
+        amount: u256
+    ): void {
+        const calldata = new BytesWriter(
+            SELECTOR_BYTE_LENGTH +
+            ADDRESS_BYTE_LENGTH +
+            U256_BYTE_LENGTH
+        );
+        calldata.writeSelector(this.TRANSFER_SELECTOR);
+        calldata.writeAddress(to);
+        calldata.writeU256(amount);
+
+        Blockchain.call(token, calldata);
+    }
+
+    public static transferFrom(
+        token: Address,
+        from: Address,
+        to: Address,
+        amount: u256
+    ): void {
+        const calldata = new BytesWriter(
+            SELECTOR_BYTE_LENGTH +
+            ADDRESS_BYTE_LENGTH * 2 +
+            U256_BYTE_LENGTH
+        );
+        calldata.writeSelector(this.TRANSFER_FROM_SELECTOR);
+        calldata.writeAddress(from);
+        calldata.writeAddress(to);
+        calldata.writeU256(amount);
+
+        Blockchain.call(token, calldata);
+    }
+
     public static safeTransfer(
         token: Address,
         to: Address,
@@ -68,7 +114,7 @@ export class TransferHelper {
                 U32_BYTE_LENGTH +
                 data.length,
         );
-        calldata.writeSelector(this.TRANSFER_SELECTOR);
+        calldata.writeSelector(this.SAFE_TRANSFER_SELECTOR);
         calldata.writeAddress(to);
         calldata.writeU256(amount);
         calldata.writeBytesWithLength(data);
@@ -104,7 +150,7 @@ export class TransferHelper {
                 U32_BYTE_LENGTH +
                 data.length,
         );
-        calldata.writeSelector(this.TRANSFER_FROM_SELECTOR);
+        calldata.writeSelector(this.SAFE_TRANSFER_FROM_SELECTOR);
         calldata.writeAddress(from);
         calldata.writeAddress(to);
         calldata.writeU256(amount);