@btc-vision/btc-runtime 1.3.20 → 1.4.0

package/package.json

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

package/runtime/contracts/DeployableOP_20.ts

@@ -12,10 +12,11 @@ import { Revert } from '../types/Revert';
 import { SafeMath } from '../types/SafeMath';
 
 import { Calldata } from '../types';
-import { BOOLEAN_BYTE_LENGTH, U256_BYTE_LENGTH } from '../utils/lengths';
+import { ADDRESS_BYTE_LENGTH, BOOLEAN_BYTE_LENGTH, U256_BYTE_LENGTH } from '../utils';
 import { IOP_20 } from './interfaces/IOP_20';
 import { OP20InitParameters } from './interfaces/OP20InitParameters';
 import { OP_NET } from './OP_NET';
+import { sha256 } from '../env/global';
 
 const maxSupplyPointer: u16 = Blockchain.nextPointer;
 const decimalsPointer: u16 = Blockchain.nextPointer;
@@ -124,6 +125,23 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         return response;
     }
 
+    public approveFrom(callData: Calldata): BytesWriter {
+        const response = new BytesWriter(BOOLEAN_BYTE_LENGTH);
+        const owner: Address = Blockchain.tx.origin;
+        const spender: Address = callData.readAddress();
+        const value: u256 = callData.readU256();
+
+        const signature = callData.readBytesWithLength();
+        if (signature.length !== 64) {
+            throw new Revert('Invalid signature length');
+        }
+
+        const resp = this._approveFrom(owner, spender, value, signature);
+        response.writeBoolean(resp);
+
+        return response;
+    }
+
     public balanceOf(callData: Calldata): BytesWriter {
         const response = new BytesWriter(U256_BYTE_LENGTH);
         const address: Address = callData.readAddress();
@@ -188,17 +206,19 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
                 response = new BytesWriter(U256_BYTE_LENGTH);
                 response.writeU256(this.maxSupply);
                 break;
-            case encodeSelector('allowance'):
+            case encodeSelector('allowance(address,address)'):
                 return this.allowance(calldata);
-            case encodeSelector('approve'):
+            case encodeSelector('approve(address,uint256)'):
                 return this.approve(calldata);
-            case encodeSelector('balanceOf'):
+            case encodeSelector('approveFrom(address,address,uint256,bytes)'):
+                return this.approveFrom(calldata);
+            case encodeSelector('balanceOf(address)'):
                 return this.balanceOf(calldata);
-            case encodeSelector('burn'):
+            case encodeSelector('burn(uint256)'):
                 return this.burn(calldata);
-            case encodeSelector('transfer'):
+            case encodeSelector('transfer(address,uint256)'):
                 return this.transfer(calldata);
-            case encodeSelector('transferFrom'):
+            case encodeSelector('transferFrom(address,address,uint256)'):
                 return this.transferFrom(calldata);
             default:
                 return super.execute(method, calldata);
@@ -214,6 +234,34 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         return senderMap.get(spender);
     }
 
+    protected _approveFrom(owner: Address, spender: Address, value: u256, signature: Uint8Array): boolean {
+        if (owner === Blockchain.DEAD_ADDRESS) {
+            throw new Revert('Address can not be dead address');
+        }
+
+        if (spender === Blockchain.DEAD_ADDRESS) {
+            throw new Revert('Spender cannot be dead address');
+        }
+
+        // Regenerate the hash
+        const writer = new BytesWriter(ADDRESS_BYTE_LENGTH * 2 + U256_BYTE_LENGTH);
+        writer.writeAddress(owner);
+        writer.writeAddress(spender);
+        writer.writeU256(value);
+
+        const hash = sha256(writer.getBuffer());
+        if (!Blockchain.verifySchnorrSignature(owner, signature, hash)) {
+            throw new Revert('ApproveFrom: Invalid signature');
+        }
+
+        const senderMap = this.allowanceMap.get(owner);
+        senderMap.set(spender, value);
+
+        this.createApproveEvent(owner, spender, value);
+
+        return true;
+    }
+
     protected _approve(owner: Address, spender: Address, value: u256): boolean {
         if (owner === Blockchain.DEAD_ADDRESS) {
             throw new Revert('Address can not be dead address');

package/runtime/contracts/OP_NET.ts

@@ -6,7 +6,7 @@ import { encodeSelector, Selector } from '../math/abi';
 import { Calldata } from '../types';
 import { Address } from '../types/Address';
 import { Revert } from '../types/Revert';
-import { ADDRESS_BYTE_LENGTH } from '../utils/lengths';
+import { ADDRESS_BYTE_LENGTH } from '../utils';
 
 export class OP_NET implements IBTC {
     public get address(): Address {
@@ -17,9 +17,11 @@ export class OP_NET implements IBTC {
         return Blockchain.contractDeployer;
     }
 
-    public onDeployment(_calldata: Calldata): void {}
+    public onDeployment(_calldata: Calldata): void {
+    }
 
-    public onExecutionCompleted(): void {}
+    public onExecutionCompleted(): void {
+    }
 
     public execute(method: Selector, _calldata: Calldata): BytesWriter {
         let response: BytesWriter;