@btc-vision/btc-runtime 1.10.6 → 1.10.7

package/LICENSE.md

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 [ORANGE PILLS INC, 2140 S DUPONT HWY CAMDEN, DE 19934]
+Copyright (c) 2025 [Orange Pill Labs Holding Ltd.]
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

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

package/runtime/contracts/OP20S.ts

@@ -5,83 +5,51 @@ import { Calldata } from '../types';
 import { Address } from '../types/Address';
 import { Revert } from '../types/Revert';
 import { StoredU256 } from '../storage/StoredU256';
-import { StoredAddress } from '../storage/StoredAddress';
 import { EMPTY_POINTER } from '../math/bytes';
 import { OP20 } from './OP20';
-import { IOP20S } from './interfaces/IOP20S';
-import { OP20InitParameters } from './interfaces/OP20InitParameters';
-import { ADDRESS_BYTE_LENGTH, U256_BYTE_LENGTH, U64_BYTE_LENGTH } from '../utils';
 import { Selector } from '../math/abi';
-
-const pegRatePointer: u16 = Blockchain.nextPointer;
-const pegAuthorityPointer: u16 = Blockchain.nextPointer;
-const pegUpdatedAtPointer: u16 = Blockchain.nextPointer;
-const maxStalenessPointer: u16 = Blockchain.nextPointer;
-const pendingAuthorityPointer: u16 = Blockchain.nextPointer;
-
-// "pegRate()"
+import { AddressMemoryMap } from '../memory/AddressMemoryMap';
+import {
+    MaxStalenessUpdatedEvent,
+    PegAuthorityRenouncedEvent,
+    PegAuthorityTransferredEvent,
+    PegAuthorityTransferStartedEvent,
+    PegRateUpdatedEvent,
+} from '../events/op20s/OP20SEvents';
+
+// Selectors: sha256 first 4 bytes
 export const PEG_RATE_SELECTOR: u32 = 0x4d1f6caf;
-
-// "pegAuthority()"
 export const PEG_AUTHORITY_SELECTOR: u32 = 0xd767a583;
-
-// "pegUpdatedAt()"
 export const PEG_UPDATED_AT_SELECTOR: u32 = 0x1e99d1a1;
-
-// "maxStaleness()"
 export const MAX_STALENESS_SELECTOR: u32 = 0x0b17a602;
-
-// "isStale()"
 export const IS_STALE_SELECTOR: u32 = 0x147c08ef;
 
-export interface OP20SInitParameters extends OP20InitParameters {
-    pegAuthority: Address;
-    initialPegRate: u256;
-    maxStaleness: u64;
-}
+const pegRatePointer: u16 = Blockchain.nextPointer;
+const pegAuthorityPointer: u16 = Blockchain.nextPointer;
+const pegUpdatedAtPointer: u16 = Blockchain.nextPointer;
+const maxStalenessPointer: u16 = Blockchain.nextPointer;
+const pendingAuthorityPointer: u16 = Blockchain.nextPointer;
 
-export abstract class OP20S extends OP20 implements IOP20S {
+export abstract class OP20S extends OP20 {
     protected readonly _pegRate: StoredU256;
-    protected readonly _pegAuthority: StoredAddress;
+    protected readonly _pegAuthorityMap: AddressMemoryMap;
     protected readonly _pegUpdatedAt: StoredU256;
     protected readonly _maxStaleness: StoredU256;
-    protected readonly _pendingAuthority: StoredAddress;
+    protected readonly _pendingAuthorityMap: AddressMemoryMap;
 
     public constructor() {
         super();
         this._pegRate = new StoredU256(pegRatePointer, EMPTY_POINTER);
-        this._pegAuthority = new StoredAddress(pegAuthorityPointer);
+        this._pegAuthorityMap = new AddressMemoryMap(pegAuthorityPointer);
         this._pegUpdatedAt = new StoredU256(pegUpdatedAtPointer, EMPTY_POINTER);
         this._maxStaleness = new StoredU256(maxStalenessPointer, EMPTY_POINTER);
-        this._pendingAuthority = new StoredAddress(pendingAuthorityPointer);
-    }
-
-    public override instantiate(
-        params: OP20SInitParameters,
-        skipDeployerVerification: boolean = false,
-    ): void {
-        super.instantiate(params, skipDeployerVerification);
-
-        if (params.pegAuthority === Address.zero()) {
-            throw new Revert('Invalid peg authority');
-        }
-        if (params.initialPegRate.isZero()) {
-            throw new Revert('Invalid initial peg rate');
-        }
-        if (params.maxStaleness === 0) {
-            throw new Revert('Invalid max staleness');
-        }
-
-        this._pegAuthority.value = params.pegAuthority;
-        this._pegRate.value = params.initialPegRate;
-        this._pegUpdatedAt.value = u256.fromU64(Blockchain.block.number);
-        this._maxStaleness.value = u256.fromU64(params.maxStaleness);
+        this._pendingAuthorityMap = new AddressMemoryMap(pendingAuthorityPointer);
     }
 
     @method()
     @returns({ name: 'rate', type: ABIDataTypes.UINT256 })
     public pegRate(_: Calldata): BytesWriter {
-        const w = new BytesWriter(U256_BYTE_LENGTH);
+        const w = new BytesWriter(32);
         w.writeU256(this._pegRate.value);
         return w;
     }
@@ -89,15 +57,15 @@ export abstract class OP20S extends OP20 implements IOP20S {
     @method()
     @returns({ name: 'authority', type: ABIDataTypes.ADDRESS })
     public pegAuthority(_: Calldata): BytesWriter {
-        const w = new BytesWriter(ADDRESS_BYTE_LENGTH);
-        w.writeAddress(this._pegAuthority.value);
+        const w = new BytesWriter(32);
+        w.writeAddress(this._getPegAuthority());
         return w;
     }
 
     @method()
     @returns({ name: 'updatedAt', type: ABIDataTypes.UINT64 })
     public pegUpdatedAt(_: Calldata): BytesWriter {
-        const w = new BytesWriter(U64_BYTE_LENGTH);
+        const w = new BytesWriter(8);
         w.writeU64(this._pegUpdatedAt.value.toU64());
         return w;
     }
@@ -105,7 +73,7 @@ export abstract class OP20S extends OP20 implements IOP20S {
     @method()
     @returns({ name: 'staleness', type: ABIDataTypes.UINT64 })
     public maxStaleness(_: Calldata): BytesWriter {
-        const w = new BytesWriter(U64_BYTE_LENGTH);
+        const w = new BytesWriter(8);
         w.writeU64(this._maxStaleness.value.toU64());
         return w;
     }
@@ -119,74 +87,115 @@ export abstract class OP20S extends OP20 implements IOP20S {
     }
 
     @method({ name: 'newRate', type: ABIDataTypes.UINT256 })
+    @emit('PegRateUpdated')
     public updatePegRate(calldata: Calldata): BytesWriter {
-        this.onlyPegAuthority();
+        this._onlyPegAuthority();
 
         const newRate = calldata.readU256();
         if (newRate.isZero()) {
             throw new Revert('Invalid peg rate');
         }
 
+        const oldRate = this._pegRate.value;
+        const blockNumber = Blockchain.block.number;
+
         this._pegRate.value = newRate;
-        this._pegUpdatedAt.value = u256.fromU64(Blockchain.block.number);
+        this._pegUpdatedAt.value = u256.fromU64(blockNumber);
+
+        this.emitEvent(new PegRateUpdatedEvent(oldRate, newRate, blockNumber));
 
         return new BytesWriter(0);
     }
 
     @method({ name: 'newStaleness', type: ABIDataTypes.UINT64 })
+    @emit('MaxStalenessUpdated')
     public updateMaxStaleness(calldata: Calldata): BytesWriter {
-        this.onlyPegAuthority();
+        this._onlyPegAuthority();
 
         const newStaleness = calldata.readU64();
-        if (newStaleness === 0) {
+        if (newStaleness == 0) {
             throw new Revert('Invalid max staleness');
         }
 
+        const oldStaleness = this._maxStaleness.value.toU64();
         this._maxStaleness.value = u256.fromU64(newStaleness);
 
+        this.emitEvent(new MaxStalenessUpdatedEvent(oldStaleness, newStaleness));
+
         return new BytesWriter(0);
     }
 
     @method({ name: 'newAuthority', type: ABIDataTypes.ADDRESS })
+    @emit('PegAuthorityTransferStarted')
     public transferPegAuthority(calldata: Calldata): BytesWriter {
-        this.onlyPegAuthority();
+        this._onlyPegAuthority();
 
         const newAuthority = calldata.readAddress();
-        if (newAuthority === Address.zero()) {
+        if (newAuthority.equals(Address.zero())) {
             throw new Revert('Invalid new authority');
         }
 
-        this._pendingAuthority.value = newAuthority;
+        const currentAuthority = this._getPegAuthority();
+        this._setPendingAuthority(newAuthority);
+
+        this.emitEvent(new PegAuthorityTransferStartedEvent(currentAuthority, newAuthority));
 
         return new BytesWriter(0);
     }
 
     @method()
+    @emit('PegAuthorityTransferred')
     public acceptPegAuthority(_: Calldata): BytesWriter {
-        const pending = this._pendingAuthority.value;
-        if (pending === Address.zero()) {
+        const pending = this._getPendingAuthority();
+        if (pending.equals(Address.zero())) {
             throw new Revert('No pending authority');
         }
         if (!Blockchain.tx.sender.equals(pending)) {
             throw new Revert('Not pending authority');
         }
 
-        this._pegAuthority.value = pending;
-        this._pendingAuthority.value = Address.zero();
+        const previousAuthority = this._getPegAuthority();
+        this._setPegAuthority(pending);
+        this._setPendingAuthority(Address.zero());
+
+        this.emitEvent(new PegAuthorityTransferredEvent(previousAuthority, pending));
 
         return new BytesWriter(0);
     }
 
     @method()
+    @emit('PegAuthorityRenounced')
     public renouncePegAuthority(_: Calldata): BytesWriter {
-        this.onlyPegAuthority();
+        this._onlyPegAuthority();
+
+        const previousAuthority = this._getPegAuthority();
+        this._setPegAuthority(Address.zero());
+        this._setPendingAuthority(Address.zero());
 
-        this._pegAuthority.value = Address.zero();
-        this._pendingAuthority.value = Address.zero();
+        this.emitEvent(new PegAuthorityRenouncedEvent(previousAuthority));
 
         return new BytesWriter(0);
     }
 
+    protected initializePeg(pegAuthority: Address, initialPegRate: u256, maxStaleness: u64): void {
+        if (pegAuthority.equals(Address.zero())) {
+            throw new Revert('Invalid peg authority');
+        }
+        if (initialPegRate.isZero()) {
+            throw new Revert('Invalid initial peg rate');
+        }
+        if (maxStaleness == 0) {
+            throw new Revert('Invalid max staleness');
+        }
+
+        this._setPegAuthority(pegAuthority);
+        this._pegRate.value = initialPegRate;
+        this._pegUpdatedAt.value = u256.fromU64(Blockchain.block.number);
+        this._maxStaleness.value = u256.fromU64(maxStaleness);
+
+        this.emitEvent(new PegRateUpdatedEvent(u256.Zero, initialPegRate, Blockchain.block.number));
+    }
+
     protected _isStale(): boolean {
         const currentBlock = Blockchain.block.number;
         const updatedAt = this._pegUpdatedAt.value.toU64();
@@ -201,19 +210,49 @@ export abstract class OP20S extends OP20 implements IOP20S {
         }
     }
 
-    protected onlyPegAuthority(): void {
-        if (!Blockchain.tx.sender.equals(this._pegAuthority.value)) {
+    protected _onlyPegAuthority(): void {
+        if (!Blockchain.tx.sender.equals(this._getPegAuthority())) {
             throw new Revert('Not peg authority');
         }
     }
 
+    protected _getPegAuthority(): Address {
+        const stored = this._pegAuthorityMap.get(Address.zero());
+        if (stored.isZero()) return Address.zero();
+        return this._u256ToAddress(stored);
+    }
+
+    protected _setPegAuthority(addr: Address): void {
+        this._pegAuthorityMap.set(Address.zero(), this._addressToU256(addr));
+    }
+
+    protected _getPendingAuthority(): Address {
+        const stored = this._pendingAuthorityMap.get(Address.zero());
+        if (stored.isZero()) return Address.zero();
+        return this._u256ToAddress(stored);
+    }
+
+    protected _setPendingAuthority(addr: Address): void {
+        this._pendingAuthorityMap.set(Address.zero(), this._addressToU256(addr));
+    }
+
+    protected _addressToU256(addr: Address): u256 {
+        return u256.fromUint8ArrayBE(addr);
+    }
+
+    protected _u256ToAddress(val: u256): Address {
+        if (val.isZero()) return Address.zero();
+        const bytes = val.toUint8Array(true);
+        return Address.fromUint8Array(bytes);
+    }
+
     protected override isSelectorExcluded(selector: Selector): boolean {
         if (
-            selector === PEG_RATE_SELECTOR ||
-            selector === PEG_AUTHORITY_SELECTOR ||
-            selector === PEG_UPDATED_AT_SELECTOR ||
-            selector === MAX_STALENESS_SELECTOR ||
-            selector === IS_STALE_SELECTOR
+            selector == PEG_RATE_SELECTOR ||
+            selector == PEG_AUTHORITY_SELECTOR ||
+            selector == PEG_UPDATED_AT_SELECTOR ||
+            selector == MAX_STALENESS_SELECTOR ||
+            selector == IS_STALE_SELECTOR
         ) {
             return true;
         }

package/runtime/events/op20s/OP20SEvents.ts

@@ -0,0 +1,60 @@
+import { u256 } from '@btc-vision/as-bignum/assembly';
+import { NetEvent } from '../NetEvent';
+import { BytesWriter } from '../../buffer/BytesWriter';
+import { ADDRESS_BYTE_LENGTH, U256_BYTE_LENGTH, U64_BYTE_LENGTH } from '../../utils';
+import { Address } from '../../types/Address';
+
+@final
+export class PegRateUpdatedEvent extends NetEvent {
+    constructor(oldRate: u256, newRate: u256, updatedAt: u64) {
+        const data: BytesWriter = new BytesWriter(U256_BYTE_LENGTH * 2 + U64_BYTE_LENGTH);
+        data.writeU256(oldRate);
+        data.writeU256(newRate);
+        data.writeU64(updatedAt);
+
+        super('PegRateUpdated', data);
+    }
+}
+
+@final
+export class PegAuthorityTransferStartedEvent extends NetEvent {
+    constructor(currentAuthority: Address, pendingAuthority: Address) {
+        const data: BytesWriter = new BytesWriter(ADDRESS_BYTE_LENGTH * 2);
+        data.writeAddress(currentAuthority);
+        data.writeAddress(pendingAuthority);
+
+        super('PegAuthorityTransferStarted', data);
+    }
+}
+
+@final
+export class PegAuthorityTransferredEvent extends NetEvent {
+    constructor(previousAuthority: Address, newAuthority: Address) {
+        const data: BytesWriter = new BytesWriter(ADDRESS_BYTE_LENGTH * 2);
+        data.writeAddress(previousAuthority);
+        data.writeAddress(newAuthority);
+
+        super('PegAuthorityTransferred', data);
+    }
+}
+
+@final
+export class PegAuthorityRenouncedEvent extends NetEvent {
+    constructor(previousAuthority: Address) {
+        const data: BytesWriter = new BytesWriter(ADDRESS_BYTE_LENGTH);
+        data.writeAddress(previousAuthority);
+
+        super('PegAuthorityRenounced', data);
+    }
+}
+
+@final
+export class MaxStalenessUpdatedEvent extends NetEvent {
+    constructor(oldStaleness: u64, newStaleness: u64) {
+        const data: BytesWriter = new BytesWriter(U64_BYTE_LENGTH * 2);
+        data.writeU64(oldStaleness);
+        data.writeU64(newStaleness);
+
+        super('MaxStalenessUpdated', data);
+    }
+}

package/runtime/index.ts

@@ -19,6 +19,7 @@ export * from './interfaces/IBTC';
 /** Events */
 export * from './events/NetEvent';
 export * from './events/predefined';
+export * from './events/op20s/OP20SEvents';
 
 /** Env */
 export * from './env/classes/UTXO';