@btc-vision/btc-runtime 1.1.0 → 1.1.2

package/package.json

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

package/runtime/contracts/DeployableOP_20.ts

@@ -14,48 +14,56 @@ import { MultiAddressMemoryMap } from '../memory/MultiAddressMemoryMap';
 import { StoredU256 } from '../storage/StoredU256';
 import { ApproveEvent, BurnEvent, MintEvent, TransferEvent } from '../events/predefined';
 import { StoredString } from '../storage/StoredString';
+import { OP20InitParameters } from './interfaces/OP20InitParameters';
 
-export class OP20InitParameters {
-    readonly maxSupply: u256;
-    readonly decimals: u8;
-    readonly name: string;
-    readonly symbol: string;
-
-    constructor(maxSupply: u256, decimals: u8, name: string, symbol: string) {
-        this.maxSupply = maxSupply;
-        this.decimals = decimals;
-        this.name = name;
-        this.symbol = symbol;
-    }
-}
+const maxSupplyPointer: u16 = Blockchain.nextPointer;
+const decimalsPointer: u16 = Blockchain.nextPointer;
+const namePointer: u16 = Blockchain.nextPointer;
+const symbolPointer: u16 = Blockchain.nextPointer;
+const totalSupplyPointer: u16 = Blockchain.nextPointer;
+const allowanceMapPointer: u16 = Blockchain.nextPointer;
+const balanceOfMapPointer: u16 = Blockchain.nextPointer;
 
 export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     protected readonly allowanceMap: MultiAddressMemoryMap<Address, Address, MemorySlotData<u256>>;
     protected readonly balanceOfMap: AddressMemoryMap<Address, MemorySlotData<u256>>;
 
+    protected readonly _maxSupply: StoredU256;
+    protected readonly _decimals: StoredU256;
+    protected readonly _name: StoredString;
+    protected readonly _symbol: StoredString;
+
     protected constructor(params?: OP20InitParameters) {
         super();
 
-        if (params) {
-            this.instantiate(params);
-        } else {
-            this.instantiate(new OP20InitParameters(u256.Zero, 0, '', ''));
-        }
-
         this.allowanceMap = new MultiAddressMemoryMap<Address, Address, MemorySlotData<u256>>(
-            Blockchain.nextPointer,
+            allowanceMapPointer,
             u256.Zero,
         );
 
         this.balanceOfMap = new AddressMemoryMap<Address, MemorySlotData<u256>>(
-            Blockchain.nextPointer,
+            balanceOfMapPointer,
             u256.Zero,
         );
 
-        this._totalSupply = new StoredU256(Blockchain.nextPointer, u256.Zero, u256.Zero);
+        this._totalSupply = new StoredU256(totalSupplyPointer, u256.Zero, u256.Zero);
+
+        this._maxSupply = new StoredU256(maxSupplyPointer, u256.Zero, u256.Zero);
+        this._decimals = new StoredU256(decimalsPointer, u256.Zero, u256.Zero);
+
+        this._name = new StoredString(namePointer, '');
+        this._symbol = new StoredString(symbolPointer, '');
+
+        if (params && this._maxSupply.value.isZero()) {
+            this.instantiate(params, true);
+        }
     }
 
-    private _maxSupply: StoredU256 | undefined;
+    public _totalSupply: StoredU256;
+
+    public get totalSupply(): u256 {
+        return this._totalSupply.value;
+    }
 
     public get maxSupply(): u256 {
         if (!this._maxSupply) throw new Revert('Max supply not set');
@@ -63,54 +71,39 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         return this._maxSupply.value;
     }
 
-    private _decimals: StoredU256 | undefined;
-
     public get decimals(): u8 {
         if (!this._decimals) throw new Revert('Decimals not set');
 
-        return u8(this._decimals.value);
+        return u8(this._decimals.value.toU32());
     }
 
-    private _name: StoredString | undefined;
-
     public get name(): string {
         if (!this._name) throw new Revert('Name not set');
 
         return this._name.value;
     }
 
-    private _symbol: StoredString | undefined;
-
     public get symbol(): string {
         if (!this._symbol) throw new Revert('Symbol not set');
 
         return this._symbol.value;
     }
 
-    public _totalSupply: StoredU256;
-
-    public get totalSupply(): u256 {
-        return this._totalSupply.value;
-    }
+    public instantiate(params: OP20InitParameters, skipOwnerVerification: boolean = false): void {
+        if (!skipOwnerVerification) this.onlyOwner(Blockchain.origin());
 
-    public instantiate(params: OP20InitParameters): void {
-        this.onlyOwner(Blockchain.from());
-
-        this._maxSupply = new StoredU256(Blockchain.nextPointer, u256.Zero, u256.Zero);
-        if (u256.ne(this._maxSupply.value, u256.Zero)) {
+        if (!this._maxSupply.value.isZero()) {
             throw new Revert('Already initialized');
         }
 
-        this._maxSupply.value = params.maxSupply;
-
-        this._decimals = new StoredU256(
-            Blockchain.nextPointer,
-            u256.Zero,
-            u256.fromU32(u32(params.decimals)),
-        );
+        if (params.decimals > 32) {
+            throw new Revert('Decimals can not be more than 32');
+        }
 
-        this._name = new StoredString(Blockchain.nextPointer, params.name);
-        this._symbol = new StoredString(Blockchain.nextPointer, params.symbol);
+        this._maxSupply.value = params.maxSupply;
+        this._decimals.value = u256.fromU32(u32(params.decimals));
+        this._name.value = params.name;
+        this._symbol.value = params.symbol;
     }
 
     /** METHODS */
@@ -132,7 +125,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
         const resp = this._approve(spender, value);
         response.writeBoolean(resp);
 
-        this.createApproveEvent(Blockchain.from(), spender, value);
+        this.createApproveEvent(Blockchain.origin(), spender, value);
 
         return response;
     }
@@ -241,7 +234,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     protected _approve(spender: Address, value: u256): boolean {
-        const callee = Blockchain.from();
+        const callee = Blockchain.origin();
 
         const senderMap = this.allowanceMap.get(callee);
         senderMap.set(spender, value);
@@ -261,7 +254,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
             throw new Revert(`No tokens`);
         }
 
-        const callee = Blockchain.from();
+        const callee = Blockchain.origin();
         const caller = Blockchain.sender();
 
         if (onlyOwner) this.onlyOwner(callee); // only indexers can burn tokens
@@ -283,7 +276,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     protected _mint(to: Address, value: u256, onlyOwner: boolean = true): boolean {
-        const callee = Blockchain.from();
+        const callee = Blockchain.origin();
 
         if (onlyOwner) this.onlyOwner(callee);
 
@@ -306,7 +299,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     protected _transfer(to: string, value: u256): boolean {
-        const caller = Blockchain.from();
+        const caller = Blockchain.origin();
 
         if (!this.balanceOfMap.has(caller)) throw new Revert();
         if (this.isSelf(caller)) throw new Revert('Can not transfer from self account');
@@ -362,7 +355,7 @@ export abstract class DeployableOP_20 extends OP_NET implements IOP_20 {
     }
 
     protected _transferFrom(from: Address, to: Address, value: u256): boolean {
-        const spender = Blockchain.from();
+        const spender = Blockchain.origin();
         if (Blockchain.sender() !== from) {
             throw new Revert('Not caller.');
         }

package/runtime/contracts/OP_20.ts

@@ -1,5 +1,6 @@
-import { DeployableOP_20, OP20InitParameters } from './DeployableOP_20';
-import { u256 } from 'as-bignum';
+import { DeployableOP_20 } from './DeployableOP_20';
+import { u256 } from 'as-bignum/assembly';
+import { OP20InitParameters } from './interfaces/OP20InitParameters';
 
 export abstract class OP_20 extends DeployableOP_20 {
     protected constructor(maxSupply: u256, decimals: u8, name: string, symbol: string) {

package/runtime/contracts/interfaces/OP20InitParameters.ts

@@ -0,0 +1,15 @@
+import { u256 } from 'as-bignum/assembly';
+
+export class OP20InitParameters {
+    readonly maxSupply: u256;
+    readonly decimals: u8;
+    readonly name: string;
+    readonly symbol: string;
+
+    constructor(maxSupply: u256, decimals: u8, name: string, symbol: string) {
+        this.maxSupply = maxSupply;
+        this.decimals = decimals;
+        this.name = name;
+        this.symbol = symbol;
+    }
+}

package/runtime/env/BTCEnvironment.ts

@@ -32,7 +32,7 @@ export class BlockchainEnvironment {
     private storage: PointerStorage = new MapU256();
     private events: NetEvent[] = [];
 
-    private _from: PotentialAddress = null;
+    private _origin: PotentialAddress = null;
     private _sender: PotentialAddress = null;
     private currentBlock: u256 = u256.Zero;
 
@@ -98,12 +98,12 @@ export class BlockchainEnvironment {
         return this.currentBlock.toU64();
     }
 
-    public from(): Address {
-        if (!this._from) {
+    public origin(): Address {
+        if (!this._origin) {
             throw this.error('Callee is required');
         }
 
-        return this._from as Address;
+        return this._origin as Address;
     }
 
     public sender(): Address {
@@ -118,7 +118,7 @@ export class BlockchainEnvironment {
         const reader: BytesReader = new BytesReader(data);
 
         this._sender = reader.readAddress();
-        this._from = reader.readAddress();
+        this._origin = reader.readAddress();
         this.currentBlock = reader.readU256();
 
         this._owner = reader.readAddress();
@@ -128,7 +128,7 @@ export class BlockchainEnvironment {
     }
 
     public call(destinationContract: Address, calldata: BytesWriter): BytesReader {
-        if (destinationContract === this._from) {
+        if (destinationContract === this._origin) {
             throw this.error('Cannot call self');
         }
 

package/runtime/index.ts

@@ -6,6 +6,7 @@ export * from './contracts/interfaces/IOP_20';
 export * from './contracts/OP_20';
 export * from './contracts/DeployableOP_20';
 export * from './contracts/OP_NET';
+export * from './contracts/interfaces/OP20InitParameters';
 
 /** Buffer */
 export * from './buffer/BytesReader';

package/runtime/shared-libraries/TransferHelper.ts

@@ -1,4 +1,4 @@
-import { u256 } from 'as-bignum/assembly/integer/u256';
+import { u256 } from 'as-bignum/assembly';
 import { encodeSelector, Selector } from '../math/abi';
 import { Address } from '../types/Address';
 import { BytesWriter } from '../buffer/BytesWriter';