@btc-vision/btc-runtime 1.8.1 → 1.9.0

package/runtime/shared-libraries/TransferHelper.ts

@@ -3,72 +3,113 @@ import { BytesWriter } from '../buffer/BytesWriter';
 import { Blockchain } from '../env';
 import { encodeSelector, Selector } from '../math/abi';
 import { Address } from '../types/Address';
-import { Revert } from '../types/Revert';
-import { ADDRESS_BYTE_LENGTH, SELECTOR_BYTE_LENGTH, U256_BYTE_LENGTH } from '../utils';
+import {
+    ADDRESS_BYTE_LENGTH,
+    SELECTOR_BYTE_LENGTH,
+    U256_BYTE_LENGTH,
+    U32_BYTE_LENGTH,
+} from '../utils';
 
-export const TransferStr = 'transfer(address,uint256)';
-export const ApproveStr = 'approve(address,uint256)';
-export const TransferFromStr = '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)';
+export const DecreaseAllowanceSignature = 'decreaseAllowance(address,uint256)';
+export const BurnSignature = 'burn(uint256)';
 
 export class TransferHelper {
-    public static get APPROVE_SELECTOR(): Selector {
-        return encodeSelector(ApproveStr);
+    public static get INCREASE_ALLOWANCE_SELECTOR(): Selector {
+        return encodeSelector(IncreaseAllowanceSignature);
+    }
+
+    public static get DECREASE_ALLOWANCE_SELECTOR(): Selector {
+        return encodeSelector(DecreaseAllowanceSignature);
     }
 
     public static get TRANSFER_SELECTOR(): Selector {
-        return encodeSelector(TransferStr);
+        return encodeSelector(SafeTransferSignature);
     }
 
     public static get TRANSFER_FROM_SELECTOR(): Selector {
-        return encodeSelector(TransferFromStr);
+        return encodeSelector(SafeTransferFromSignature);
     }
 
-    public static safeApprove(token: Address, spender: Address, amount: u256): void {
+    public static safeIncreaseAllowance(token: Address, spender: Address, amount: u256): void {
         const calldata = new BytesWriter(
             SELECTOR_BYTE_LENGTH + ADDRESS_BYTE_LENGTH + U256_BYTE_LENGTH,
         );
-        calldata.writeSelector(this.APPROVE_SELECTOR);
+        calldata.writeSelector(this.INCREASE_ALLOWANCE_SELECTOR);
         calldata.writeAddress(spender);
         calldata.writeU256(amount);
 
-        const response = Blockchain.call(token, calldata);
-        const isOk = response.readBoolean();
-
-        if (!isOk) {
-            throw new Revert(`TransferHelper: APPROVE_FAILED`);
-        }
+        Blockchain.call(token, calldata);
     }
 
-    public static safeTransfer(token: Address, to: Address, amount: u256): void {
+    public static safeDecreaseAllowance(token: Address, spender: Address, amount: u256): void {
         const calldata = new BytesWriter(
             SELECTOR_BYTE_LENGTH + ADDRESS_BYTE_LENGTH + U256_BYTE_LENGTH,
         );
+        calldata.writeSelector(this.DECREASE_ALLOWANCE_SELECTOR);
+        calldata.writeAddress(spender);
+        calldata.writeU256(amount);
+
+        Blockchain.call(token, calldata);
+    }
+
+    public static safeTransfer(
+        token: Address,
+        to: Address,
+        amount: u256,
+        data: Uint8Array = new Uint8Array(0),
+    ): void {
+        const calldata = new BytesWriter(
+            SELECTOR_BYTE_LENGTH +
+                ADDRESS_BYTE_LENGTH +
+                U256_BYTE_LENGTH +
+                U32_BYTE_LENGTH +
+                data.length,
+        );
         calldata.writeSelector(this.TRANSFER_SELECTOR);
         calldata.writeAddress(to);
         calldata.writeU256(amount);
+        calldata.writeBytesWithLength(data);
 
-        const response = Blockchain.call(token, calldata);
-        const isOk = response.readBoolean();
+        Blockchain.call(token, calldata);
+    }
 
-        if (!isOk) {
-            throw new Revert(`TransferHelper: TRANSFER_FAILED`);
-        }
+    /**
+     * Burns the specified amount of tokens from the contract.
+     * This function is used to destroy tokens, reducing the total supply.
+     * @param token The address of the token contract.
+     * @param amount The amount of tokens to burn.
+     */
+    public static burn(token: Address, amount: u256): void {
+        const calldata = new BytesWriter(SELECTOR_BYTE_LENGTH + U256_BYTE_LENGTH);
+        calldata.writeSelector(encodeSelector(BurnSignature));
+        calldata.writeU256(amount);
+
+        Blockchain.call(token, calldata);
     }
 
-    public static safeTransferFrom(token: Address, from: Address, to: Address, amount: u256): void {
+    public static safeTransferFrom(
+        token: Address,
+        from: Address,
+        to: Address,
+        amount: u256,
+        data: Uint8Array = new Uint8Array(0),
+    ): void {
         const calldata = new BytesWriter(
-            SELECTOR_BYTE_LENGTH + ADDRESS_BYTE_LENGTH * 2 + U256_BYTE_LENGTH,
+            SELECTOR_BYTE_LENGTH +
+                ADDRESS_BYTE_LENGTH * 2 +
+                U256_BYTE_LENGTH +
+                U32_BYTE_LENGTH +
+                data.length,
         );
         calldata.writeSelector(this.TRANSFER_FROM_SELECTOR);
         calldata.writeAddress(from);
         calldata.writeAddress(to);
         calldata.writeU256(amount);
+        calldata.writeBytesWithLength(data);
 
-        const response = Blockchain.call(token, calldata);
-        const isOk = response.readBoolean();
-
-        if (!isOk) {
-            throw new Revert(`TransferHelper: TRANSFER_FROM_FAILED`);
-        }
+        Blockchain.call(token, calldata);
     }
 }

package/runtime/storage/AdvancedStoredString.ts

@@ -44,7 +44,7 @@ export class AdvancedStoredString {
      * chunkIndex=0 => header slot, 1 => second slot, etc.
      */
     private getPointer(chunkIndex: u64): Uint8Array {
-        const base = encodePointer(this.pointer, this.subPointer);
+        const base = encodePointer(this.pointer, this.subPointer, true, 'AdvancedStoredString');
         return bigEndianAdd(base, chunkIndex);
     }
 

package/runtime/storage/StoredAddress.ts

@@ -12,7 +12,7 @@ export class StoredAddress {
     private readonly addressPointer: Uint8Array;
 
     constructor(public pointer: u16) {
-        this.addressPointer = encodePointer(pointer, EMPTY_POINTER);
+        this.addressPointer = encodePointer(pointer, EMPTY_POINTER, true, 'StoredAddress');
     }
 
     private _value: Address = Address.dead();

package/runtime/storage/StoredBoolean.ts

@@ -12,7 +12,7 @@ export class StoredBoolean {
     ) {
         const pointerBuffer = GET_EMPTY_BUFFER();
         pointerBuffer[0] = pointer & 255;
-        pointerBuffer[1] = (pointer << 8) & 255;
+        pointerBuffer[1] = (pointer >> 8) & 255;
 
         this.pointerBuffer = pointerBuffer;
 
@@ -49,8 +49,6 @@ export class StoredBoolean {
     }
 
     private ensureValue(): void {
-        this._value = Blockchain.getStorageAt(
-            this.pointerBuffer,
-        );
+        this._value = Blockchain.getStorageAt(this.pointerBuffer);
     }
 }

package/runtime/storage/StoredString.ts

@@ -21,7 +21,10 @@ const MAX_LENGTH_U256 = u256.fromU32(<u32>MAX_LENGTH);
 export class StoredString {
     private readonly subPointer: Uint8Array;
 
-    constructor(public pointer: u16, index: u64 = 0) {
+    constructor(
+        public pointer: u16,
+        index: u64 = 0,
+    ) {
         const indexed = SafeMath.mul(u256.fromU64(index), MAX_LENGTH_U256);
         this.subPointer = indexed.toUint8Array(true).slice(0, 30);
     }
@@ -49,7 +52,7 @@ export class StoredString {
      * chunkIndex=0 => header slot, 1 => second slot, etc.
      */
     private getPointer(chunkIndex: u64): Uint8Array {
-        const base = encodePointer(this.pointer, this.subPointer);
+        const base = encodePointer(this.pointer, this.subPointer, true, 'StoredString');
         return bigEndianAdd(base, chunkIndex);
     }
 
@@ -201,4 +204,4 @@ export class StoredString {
         // Decode UTF-8 into a normal string
         this._value = String.UTF8.decode(out.buffer, false);
     }
-}
+}

package/runtime/storage/StoredU256.ts

@@ -11,9 +11,7 @@ export class StoredU256 {
         public pointer: u16,
         public subPointer: Uint8Array,
     ) {
-        assert(subPointer.length <= 30, `You must pass a 30 bytes sub-pointer. (Address, got ${subPointer.length})`);
-
-        this.pointerBuffer = encodePointer(pointer, subPointer);
+        this.pointerBuffer = encodePointer(pointer, subPointer, true, 'StoredU256');
     }
 
     private _value: u256 = u256.Zero;

package/runtime/storage/StoredU32.ts

@@ -30,12 +30,7 @@ export class StoredU32 {
         public pointer: u16,
         public subPointer: Uint8Array,
     ) {
-        assert(
-            subPointer.length <= 30,
-            `You must pass a 30 bytes sub-pointer. (StoredU32, got ${subPointer.length})`,
-        );
-
-        this.bufferPointer = encodePointer(pointer, subPointer);
+        this.bufferPointer = encodePointer(pointer, subPointer, true, 'StoredU32');
     }
 
     /**

package/runtime/storage/StoredU64.ts

@@ -30,9 +30,7 @@ export class StoredU64 {
         public pointer: u16,
         public subPointer: Uint8Array,
     ) {
-        assert(subPointer.length <= 30, `You must pass a 30 bytes sub-pointer. (StoredU64, got ${subPointer.length})`);
-
-        this.bufferPointer = encodePointer(pointer, subPointer);
+        this.bufferPointer = encodePointer(pointer, subPointer, true, 'StoredU64');
     }
 
     /**
@@ -118,7 +116,6 @@ export class StoredU64 {
         return `[${this._values[0].toString()}, ${this._values[1].toString()}, ${this._values[2].toString()}, ${this._values[3].toString()}]`;
     }
 
-
     /**
      * @method reset
      * @description Resets the cached values to default and marks as changed.

package/runtime/storage/arrays/StoredBooleanArray.ts

@@ -1,17 +1,17 @@
-import {BytesWriter} from '../../buffer/BytesWriter';
-import {Blockchain} from '../../env';
-import {Revert} from '../../types/Revert';
+import { BytesWriter } from '../../buffer/BytesWriter';
+import { Blockchain } from '../../env';
+import { Revert } from '../../types/Revert';
 import {
     addUint8ArraysBE,
     bigEndianAdd,
-    encodeBasePointer,
     GET_EMPTY_BUFFER,
     getBit,
     readLengthAndStartIndex,
     setBit,
     u64ToBE32Bytes,
 } from '../../math/bytes';
-import {DEFAULT_MAX_LENGTH} from './StoredPackedArray';
+import { DEFAULT_MAX_LENGTH } from './StoredPackedArray';
+import { encodePointer } from '../../math/abi';
 
 /**
  * @class StoredBooleanArray
@@ -52,12 +52,7 @@ export class StoredBooleanArray {
         public subPtr: Uint8Array,
         protected MAX_LENGTH: u32 = DEFAULT_MAX_LENGTH,
     ) {
-        assert(
-            subPtr.length <= 30,
-            `You must pass a 30 bytes sub-pointer. (StoredBooleanArray, got ${subPtr.length})`,
-        );
-
-        const basePointer = encodeBasePointer(pointer, subPtr);
+        const basePointer = encodePointer(pointer, subPtr, true, 'StoredBooleanArray');
         this.lengthPointer = Uint8Array.wrap(basePointer.buffer);
         this.basePointer = bigEndianAdd(basePointer, 1);
 
@@ -72,7 +67,7 @@ export class StoredBooleanArray {
     public get previousOffset(): u32 {
         return <u32>(
             ((this._startIndex +
-                    <u64>(this.nextItemOffset === 0 ? this.nextItemOffset : this.nextItemOffset - 1)) %
+                <u64>(this.nextItemOffset === 0 ? this.nextItemOffset : this.nextItemOffset - 1)) %
                 this.MAX_LENGTH)
         );
     }

package/runtime/storage/arrays/StoredPackedArray.ts

@@ -1,12 +1,7 @@
-import {
-    bigEndianAdd,
-    encodeBasePointer,
-    GET_EMPTY_BUFFER,
-    readLengthAndStartIndex,
-    writeLengthAndStartIndex,
-} from '../../math/bytes';
+import { bigEndianAdd, GET_EMPTY_BUFFER, readLengthAndStartIndex, writeLengthAndStartIndex, } from '../../math/bytes';
 import { Blockchain } from '../../env';
 import { Revert } from '../../types/Revert';
+import { encodePointer } from '../../math/abi';
 
 export const DEFAULT_MAX_LENGTH: u32 = u32.MAX_VALUE - 1;
 
@@ -55,12 +50,7 @@ export abstract class StoredPackedArray<T> {
         protected defaultValue: T,
         protected MAX_LENGTH: u32 = DEFAULT_MAX_LENGTH,
     ) {
-        assert(
-            subPointer.length <= 30,
-            `You must pass a 30 bytes sub-pointer. (Array, got ${subPointer.length})`,
-        );
-
-        const basePointer = encodeBasePointer(pointer, subPointer);
+        const basePointer = encodePointer(pointer, subPointer, true, 'StoredPackedArray');
         this.lengthPointer = Uint8Array.wrap(basePointer.buffer);
         this.basePointer = bigEndianAdd(basePointer, 1);
 

package/runtime/storage/maps/StoredMapU256.ts

@@ -1,8 +1,8 @@
-import {u256} from '@btc-vision/as-bignum/assembly';
-import {Blockchain} from '../../env';
-import {EMPTY_BUFFER} from "../../math/bytes";
-import {BytesWriter} from "../../buffer/BytesWriter";
-import {encodePointerUnknownLength} from "../../math/abi";
+import { u256 } from '@btc-vision/as-bignum/assembly';
+import { Blockchain } from '../../env';
+import { EMPTY_BUFFER } from '../../math/bytes';
+import { BytesWriter } from '../../buffer/BytesWriter';
+import { encodePointerUnknownLength } from '../../math/abi';
 
 /**
  * StoredMap<K, V> implementation using u256 as keys.

package/runtime/types/Address.ts

@@ -1,7 +1,9 @@
 import { Potential } from '../lang/Definitions';
 import { ADDRESS_BYTE_LENGTH, decodeHexArray, encodeHexFromBuffer } from '../utils';
-import { bech32m as _bech32m, toWords } from '../utils/b32';
 import { Revert } from './Revert';
+import { BitcoinAddresses } from '../script/BitcoinAddresses';
+import { Blockchain } from '../env';
+import { Network } from '../script/Networks';
 
 @final
 export class Address extends Uint8Array {
@@ -35,6 +37,23 @@ export class Address extends Uint8Array {
         return new Address(decodeHexArray(pubKey));
     }
 
+    public static fromUint8Array(bytes: Uint8Array): Address {
+        const cloned = new Address();
+        // Copy the raw memory directly:
+        memory.copy(cloned.dataStart, bytes.dataStart, ADDRESS_BYTE_LENGTH);
+
+        return cloned;
+    }
+
+    public static toCSV(address: Uint8Array, blocks: u32): string {
+        return BitcoinAddresses.csvP2wshAddress(address, blocks, Network.hrp(Blockchain.network))
+            .address;
+    }
+
+    public static p2wpkh(address: Uint8Array): string {
+        return BitcoinAddresses.p2wpkh(address, Network.hrp(Blockchain.network));
+    }
+
     public isZero(): bool {
         for (let i = 0; i < this.length; i++) {
             if (this[i] != 0) {
@@ -45,6 +64,19 @@ export class Address extends Uint8Array {
         return true;
     }
 
+    public isDead(): bool {
+        for (let i = 0; i < this.length; i++) {
+            if (this[i] != DEAD_ADDRESS[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public p2tr(): string {
+        return BitcoinAddresses.p2trKeyPathAddress(this, Network.hrp(Blockchain.network));
+    }
+
     /**
      * Create a new Address that is a copy of the current Address.
      * @returns {Address}
@@ -60,47 +92,10 @@ export class Address extends Uint8Array {
         return cloned;
     }
 
-    public static fromUint8Array(bytes: Uint8Array): Address {
-        const cloned = new Address();
-        // Copy the raw memory directly:
-        memory.copy(cloned.dataStart, bytes.dataStart, ADDRESS_BYTE_LENGTH);
-
-        return cloned;
-    }
-
     public toHex(): string {
         return encodeHexFromBuffer(this.buffer);
     }
 
-    public empty(): bool {
-        for (let i = 0; i < this.length; i++) {
-            if (this[i] != 0) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-
-    /**
-     * Set the public key
-     * @param {ArrayLike} publicKey The public key
-     * @returns {void}
-     */
-    public newSet(publicKey: u8[]): void {
-        if (publicKey.length !== 32) {
-            throw new Error('Invalid public key length');
-        }
-
-        super.set(publicKey);
-
-        this.isDefined = true;
-    }
-
-    public toBech32m(): string {
-        return String.UTF8.decode(_bech32m(String.UTF8.encode('bc'), toWords(this.buffer)));
-    }
-
     @operator('==')
     public equals(a: Address): bool {
         if (a.length != this.length) {
@@ -166,7 +161,22 @@ export class Address extends Uint8Array {
     }
 
     public toString(): string {
-        return this.toBech32m();
+        return this.p2tr();
+    }
+
+    /**
+     * Set the public key
+     * @param {ArrayLike} publicKey The public key
+     * @returns {void}
+     */
+    private newSet(publicKey: u8[]): void {
+        if (publicKey.length !== 32) {
+            throw new Revert(`Invalid public key length (${publicKey.length})`);
+        }
+
+        super.set(publicKey);
+
+        this.isDefined = true;
     }
 
     @operator('[]')

package/runtime/types/SafeMath.ts

@@ -1,4 +1,5 @@
 import { u128, u256 } from '@btc-vision/as-bignum/assembly';
+import { Revert } from './Revert';
 
 export class SafeMath {
     public static ZERO: u256 = u256.fromU32(0);
@@ -6,7 +7,7 @@ export class SafeMath {
     public static add(a: u256, b: u256): u256 {
         const c: u256 = u256.add(a, b);
         if (c < a) {
-            throw new Error('SafeMath: addition overflow');
+            throw new Revert('SafeMath: addition overflow');
         }
         return c;
     }
@@ -14,7 +15,7 @@ export class SafeMath {
     public static add128(a: u128, b: u128): u128 {
         const c: u128 = u128.add(a, b);
         if (c < a) {
-            throw new Error('SafeMath: addition overflow');
+            throw new Revert('SafeMath: addition overflow');
         }
         return c;
     }
@@ -23,14 +24,14 @@ export class SafeMath {
         const c: u64 = a + b;
 
         if (c < a) {
-            throw new Error('SafeMath: addition overflow');
+            throw new Revert('SafeMath: addition overflow');
         }
         return c;
     }
 
     public static sub(a: u256, b: u256): u256 {
         if (a < b) {
-            throw new Error('SafeMath: subtraction overflow');
+            throw new Revert('SafeMath: subtraction overflow');
         }
 
         return u256.sub(a, b);
@@ -38,7 +39,7 @@ export class SafeMath {
 
     public static sub128(a: u128, b: u128): u128 {
         if (a < b) {
-            throw new Error('SafeMath: subtraction overflow');
+            throw new Revert('SafeMath: subtraction overflow');
         }
 
         return u128.sub(a, b);
@@ -46,7 +47,7 @@ export class SafeMath {
 
     public static sub64(a: u64, b: u64): u64 {
         if (a < b) {
-            throw new Error('SafeMath: subtraction overflow');
+            throw new Revert('SafeMath: subtraction overflow');
         }
 
         return a - b;
@@ -54,7 +55,7 @@ export class SafeMath {
 
     // Computes (a * b) % modulus with full precision
     public static mulmod(a: u256, b: u256, modulus: u256): u256 {
-        if (u256.eq(modulus, u256.Zero)) throw new Error('SafeMath: modulo by zero');
+        if (u256.eq(modulus, u256.Zero)) throw new Revert('SafeMath: modulo by zero');
 
         const mul = SafeMath.mul(a, b);
         return SafeMath.mod(mul, modulus);
@@ -64,7 +65,7 @@ export class SafeMath {
     @operator('%')
     public static mod(a: u256, b: u256): u256 {
         if (u256.eq(b, u256.Zero)) {
-            throw new Error('SafeMath: modulo by zero');
+            throw new Revert('SafeMath: modulo by zero');
         }
 
         const divResult = SafeMath.div(a, b);
@@ -85,7 +86,7 @@ export class SafeMath {
             {
                 // old_r - (quotient * r)
                 const tmp = r;
-                r = u256.sub(old_r, u256.mul(quotient, r));  // unchecked subtract
+                r = u256.sub(old_r, u256.mul(quotient, r)); // unchecked subtract
                 old_r = tmp;
             }
 
@@ -93,7 +94,7 @@ export class SafeMath {
             {
                 // old_s - (quotient * s)
                 const tmp = s;
-                s = u256.sub(old_s, u256.mul(quotient, s));  // unchecked subtract
+                s = u256.sub(old_s, u256.mul(quotient, s)); // unchecked subtract
                 old_s = tmp;
             }
         }
@@ -133,7 +134,7 @@ export class SafeMath {
         const d: u256 = SafeMath.div(c, a);
 
         if (u256.ne(d, b)) {
-            throw new Error('SafeMath: multiplication overflow');
+            throw new Revert('SafeMath: multiplication overflow');
         }
 
         return c;
@@ -148,7 +149,7 @@ export class SafeMath {
         const d: u128 = SafeMath.div128(c, a);
 
         if (u128.ne(d, b)) {
-            throw new Error('SafeMath: multiplication overflow');
+            throw new Revert('SafeMath: multiplication overflow');
         }
 
         return c;
@@ -162,7 +163,7 @@ export class SafeMath {
         const c: u64 = a * b;
 
         if (c / a !== b) {
-            throw new Error('SafeMath: multiplication overflow');
+            throw new Revert('SafeMath: multiplication overflow');
         }
 
         return c;
@@ -170,7 +171,7 @@ export class SafeMath {
 
     public static div64(a: u64, b: u64): u64 {
         if (b === 0) {
-            throw new Error('Division by zero');
+            throw new Revert('Division by zero');
         }
 
         if (a === 0) {
@@ -190,7 +191,7 @@ export class SafeMath {
 
     public static div128(a: u128, b: u128): u128 {
         if (b.isZero()) {
-            throw new Error('Division by zero');
+            throw new Revert('Division by zero');
         }
 
         if (a.isZero()) {
@@ -227,7 +228,7 @@ export class SafeMath {
     @operator('/')
     public static div(a: u256, b: u256): u256 {
         if (b.isZero()) {
-            throw new Error('Division by zero');
+            throw new Revert('Division by zero');
         }
 
         if (a.isZero()) {
@@ -431,7 +432,7 @@ export class SafeMath {
      */
     static inc(value: u256): u256 {
         if (u256.eq(value, u256.Max)) {
-            throw new Error('SafeMath: increment overflow');
+            throw new Revert('SafeMath: increment overflow');
         }
 
         return value.preInc();
@@ -444,7 +445,7 @@ export class SafeMath {
      */
     public static dec(value: u256): u256 {
         if (u256.eq(value, u256.Zero)) {
-            throw new Error('SafeMath: decrement overflow');
+            throw new Revert('SafeMath: decrement overflow');
         }
 
         return value.preDec();