@btc-vision/btc-runtime 1.10.11 → 1.11.0-alpha

package/runtime/generic/ExtendedAddressMap.ts

@@ -0,0 +1,147 @@
+import { ExtendedAddress } from '../types/ExtendedAddress';
+import { Revert } from '../types/Revert';
+import { IMap } from './Map';
+
+/**
+ * A map implementation using ExtendedAddress (64 bytes) as keys.
+ * Uses hyper-optimized search with prefix filtering for performance.
+ */
+@final
+export class ExtendedAddressMap<V> implements IMap<ExtendedAddress, V> {
+    protected _keys: ExtendedAddress[] = [];
+    protected _values: V[] = [];
+
+    // CACHE: Stores the index of the last successful lookup to make repeated access O(1)
+    private _lastIndex: i32 = -1;
+
+    @inline
+    public get size(): i32 {
+        return this._keys.length;
+    }
+
+    @inline
+    public keys(): ExtendedAddress[] {
+        return this._keys;
+    }
+
+    @inline
+    public values(): V[] {
+        return this._values;
+    }
+
+    public set(key: ExtendedAddress, value: V): this {
+        const index = this.indexOf(key);
+
+        if (index === -1) {
+            this._keys.push(key);
+            this._values.push(value);
+            this._lastIndex = this._keys.length - 1;
+        } else {
+            unchecked((this._values[index] = value));
+            this._lastIndex = index;
+        }
+
+        return this;
+    }
+
+    /**
+     * HYPER-OPTIMIZED SEARCH
+     * Compares both the ML-DSA key hash (inherited) and tweakedPublicKey.
+     */
+    public indexOf(searchKey: ExtendedAddress): i32 {
+        if (this.isLastIndex(searchKey)) {
+            return this._lastIndex;
+        }
+
+        const len = this._keys.length;
+        if (len === 0) return -1;
+
+        const searchMldsaData = searchKey.dataStart;
+        const searchTweakedData = searchKey.tweakedPublicKey.dataStart;
+
+        // Loop Backwards (finding most recently added items first)
+        for (let i = len - 1; i >= 0; i--) {
+            const key = unchecked(this._keys[i]);
+
+            // Quick prefix check on ML-DSA key hash (first 8 bytes)
+            if (load<u64>(key.dataStart) !== load<u64>(searchMldsaData)) continue;
+
+            // Quick prefix check on tweaked public key (first 8 bytes)
+            if (
+                load<u64>(key.tweakedPublicKey.dataStart) !== load<u64>(searchTweakedData)
+            )
+                continue;
+
+            // Full comparison of ML-DSA key hash (32 bytes)
+            if (memory.compare(key.dataStart, searchMldsaData, 32) !== 0) continue;
+
+            // Full comparison of tweaked public key (32 bytes)
+            if (memory.compare(key.tweakedPublicKey.dataStart, searchTweakedData, 32) === 0) {
+                this._lastIndex = i;
+                return i;
+            }
+        }
+
+        return -1;
+    }
+
+    private isLastIndex(key: ExtendedAddress): bool {
+        if (this._lastIndex !== -1) {
+            const cachedKey = unchecked(this._keys[this._lastIndex]);
+
+            // Check ML-DSA key hash equality
+            if (memory.compare(cachedKey.dataStart, key.dataStart, 32) !== 0) {
+                return false;
+            }
+
+            // Check tweaked public key equality
+            if (
+                memory.compare(
+                    cachedKey.tweakedPublicKey.dataStart,
+                    key.tweakedPublicKey.dataStart,
+                    32,
+                ) === 0
+            ) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    @inline
+    public has(key: ExtendedAddress): bool {
+        return this.indexOf(key) !== -1;
+    }
+
+    public get(key: ExtendedAddress): V {
+        const index = this.indexOf(key);
+        if (index === -1) {
+            throw new Revert('Key not found in map');
+        }
+        return unchecked(this._values[index]);
+    }
+
+    public delete(key: ExtendedAddress): bool {
+        const index = this.indexOf(key);
+        if (index === -1) return false;
+
+        this._keys.splice(index, 1);
+        this._values.splice(index, 1);
+
+        this._lastIndex = -1;
+
+        return true;
+    }
+
+    @inline
+    public clear(): void {
+        this._keys = [];
+        this._values = [];
+        this._lastIndex = -1;
+    }
+
+    public toString(): string {
+        return `ExtendedAddressMap(size=${this._keys.length})`;
+    }
+}

package/runtime/generic/MapUint8Array.ts

@@ -34,23 +34,7 @@ export class MapUint8Array implements IMap<Uint8Array, Uint8Array> {
     }
 
     public set(key: Uint8Array, value: Uint8Array): this {
-        let index = -1;
-
-        // Check Cache (Fastest)
-        if (this._lastIndex !== -1) {
-            const cachedKey = unchecked(this._keys[this._lastIndex]);
-            // Check length first, then full content equality
-            if (cachedKey.length === key.length) {
-                if (memory.compare(cachedKey.dataStart, key.dataStart, key.length) === 0) {
-                    index = this._lastIndex;
-                }
-            }
-        }
-
-        // Full Scan if cache missed
-        if (index === -1) {
-            index = this.indexOf(key);
-        }
+        let index = this.indexOf(key);
 
         if (index === -1) {
             this._keys.push(key);
@@ -58,7 +42,7 @@ export class MapUint8Array implements IMap<Uint8Array, Uint8Array> {
             this._lastIndex = this._keys.length - 1;
         } else {
             unchecked((this._values[index] = value));
-            // Cache is already pointing to this index (from indexOf or the check above)
+            // Cache is already pointing to this index (from indexOf)
             this._lastIndex = index;
         }
 
@@ -71,6 +55,10 @@ export class MapUint8Array implements IMap<Uint8Array, Uint8Array> {
      * Uses a "Prefix Filter" to skip expensive memory comparisons.
      */
     public indexOf(pointerHash: Uint8Array): i32 {
+        if (this.isLastIndex(pointerHash)) {
+            return this._lastIndex;
+        }
+
         const len = this._keys.length;
         if (len === 0) return -1;
 
@@ -119,6 +107,20 @@ export class MapUint8Array implements IMap<Uint8Array, Uint8Array> {
         return -1;
     }
 
+    private isLastIndex(key: Uint8Array): bool {
+        if (this._lastIndex !== -1) {
+            const cachedKey = unchecked(this._keys[this._lastIndex]);
+            // Check length first, then full content equality
+            if (cachedKey.length === key.length) {
+                if (memory.compare(cachedKey.dataStart, key.dataStart, key.length) === 0) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
     @inline
     public has(key: Uint8Array): bool {
         return this.indexOf(key) !== -1;

package/runtime/index.ts

@@ -20,6 +20,7 @@ export * from './interfaces/IBTC';
 export * from './events/NetEvent';
 export * from './events/predefined';
 export * from './events/op20s/OP20SEvents';
+export * from './events/upgradeable/UpgradeableEvents';
 
 /** Env */
 export * from './env/classes/UTXO';
@@ -35,6 +36,7 @@ export * from './env/consensus/MLDSAMetadata';
 export * from './generic/Map';
 export * from './generic/MapU256';
 export * from './generic/AddressMap';
+export * from './generic/ExtendedAddressMap';
 
 /** Types */
 export * from './types';
@@ -43,6 +45,7 @@ export * from './types';
 export * from './lang/Definitions';
 export * from './types/Address';
 export * from './types/ExtendedAddress';
+export * from './types/SchnorrSignature';
 export * from './types/Revert';
 export * from './types/SafeMath';
 export * from './types/SafeMathI128';
@@ -106,4 +109,9 @@ export * from './contracts/interfaces/IOP721';
 export * from './contracts/interfaces/IOP1155';
 export * from './contracts/interfaces/OP721InitParameters';
 export * from './contracts/ReentrancyGuard';
+export * from './contracts/Upgradeable';
 export * from './contracts/interfaces/OP1155InitParameters';
+
+/** Plugins */
+export * from './plugins/Plugin';
+export * from './plugins/UpgradeablePlugin';

package/runtime/plugins/Plugin.ts

@@ -1,10 +1,44 @@
 import { Calldata } from '../types';
 import { Selector } from '../math/abi';
+import { BytesWriter } from '../buffer/BytesWriter';
 
+/**
+ * Base class for plugins that can extend contract functionality.
+ *
+ * Plugins can be registered with OP_NET contracts to automatically
+ * handle method selectors without requiring manual delegation in execute().
+ *
+ * @example
+ * ```typescript
+ * class MyPlugin extends Plugin {
+ *     public execute(method: Selector, calldata: Calldata): BytesWriter | null {
+ *         switch (method) {
+ *             case encodeSelector('myMethod()'):
+ *                 return this.myMethod();
+ *             default:
+ *                 return null; // Not handled
+ *         }
+ *     }
+ * }
+ * ```
+ */
 export class Plugin {
     public onDeployment(_calldata: Calldata): void {}
 
+    public onUpdate(_calldata: Calldata): void {}
+
     public onExecutionStarted(_selector: Selector, _calldata: Calldata): void {}
 
     public onExecutionCompleted(_selector: Selector, _calldata: Calldata): void {}
+
+    /**
+     * Attempts to execute a method.
+     *
+     * @param _method - The method selector
+     * @param _calldata - The calldata
+     * @returns BytesWriter response if handled, null if not handled
+     */
+    public execute(_method: Selector, _calldata: Calldata): BytesWriter | null {
+        return null;
+    }
 }

package/runtime/plugins/UpgradeablePlugin.ts

@@ -0,0 +1,279 @@
+import { u256 } from '@btc-vision/as-bignum/assembly';
+import { Blockchain } from '../env';
+import { Plugin } from './Plugin';
+import { StoredAddress } from '../storage/StoredAddress';
+import { StoredU256 } from '../storage/StoredU256';
+import { Address } from '../types/Address';
+import { Revert } from '../types/Revert';
+import { BytesWriter } from '../buffer/BytesWriter';
+import { encodeSelector, Selector } from '../math/abi';
+import { ADDRESS_BYTE_LENGTH } from '../utils';
+import { Calldata } from '../types';
+import { EMPTY_POINTER } from '../math/bytes';
+import {
+    UpgradeSubmittedEvent,
+    UpgradeAppliedEvent,
+    UpgradeCancelledEvent,
+} from '../events/upgradeable/UpgradeableEvents';
+
+/**
+ * UpgradeablePlugin - Plugin for upgradeable contracts with timelock protection.
+ *
+ * This plugin provides a secure upgrade mechanism with a configurable delay period.
+ * Unlike extending the Upgradeable base class, this plugin can be added to any contract.
+ *
+ * The pattern prevents instant malicious upgrades by requiring:
+ * 1. submitUpgrade() - Submit the source contract address, starts the timelock
+ * 2. Wait for the delay period to pass
+ * 3. applyUpgrade() - Apply the upgrade after the delay
+ *
+ * @example
+ * ```typescript
+ * @final
+ * export class MyContract extends OP_NET {
+ *     public constructor() {
+ *         super();
+ *         // 144 blocks = ~24 hours
+ *         this.registerPlugin(new UpgradeablePlugin(144));
+ *     }
+ *
+ *     // No need to modify execute() - the plugin handles upgrade methods automatically!
+ * }
+ * ```
+ */
+export class UpgradeablePlugin extends Plugin {
+    // Method selectors
+    public static get SUBMIT_UPGRADE_SELECTOR(): Selector {
+        return encodeSelector('submitUpgrade(address)');
+    }
+
+    public static get APPLY_UPGRADE_SELECTOR(): Selector {
+        return encodeSelector('applyUpgrade(address)');
+    }
+
+    public static get CANCEL_UPGRADE_SELECTOR(): Selector {
+        return encodeSelector('cancelUpgrade()');
+    }
+
+    public static get PENDING_UPGRADE_SELECTOR(): Selector {
+        return encodeSelector('pendingUpgrade()');
+    }
+
+    public static get UPGRADE_DELAY_SELECTOR(): Selector {
+        return encodeSelector('upgradeDelay()');
+    }
+
+    private readonly _pendingUpgradeAddress: StoredAddress;
+    private readonly _pendingUpgradeBlock: StoredU256;
+    private readonly _upgradeDelay: u64;
+
+    /**
+     * Creates a new UpgradeablePlugin.
+     *
+     * @param upgradeDelay - Number of blocks to wait before upgrade can be applied.
+     *                       Default: 144 blocks (~24 hours)
+     *                       Common values:
+     *                       - 6 blocks = ~1 hour
+     *                       - 144 blocks = ~24 hours
+     *                       - 1008 blocks = ~1 week
+     * @param addressPointer - Storage pointer for pending upgrade address
+     * @param blockPointer - Storage pointer for pending upgrade block
+     */
+    public constructor(
+        upgradeDelay: u64 = 144,
+        addressPointer: u16 = Blockchain.nextPointer,
+        blockPointer: u16 = Blockchain.nextPointer,
+    ) {
+        super();
+        this._upgradeDelay = upgradeDelay;
+        this._pendingUpgradeAddress = new StoredAddress(addressPointer);
+        this._pendingUpgradeBlock = new StoredU256(blockPointer, EMPTY_POINTER);
+    }
+
+    /**
+     * Returns the pending upgrade source address.
+     */
+    public get pendingUpgradeAddress(): Address {
+        return this._pendingUpgradeAddress.value;
+    }
+
+    /**
+     * Returns the block number when the pending upgrade was submitted.
+     */
+    public get pendingUpgradeBlock(): u64 {
+        return this._pendingUpgradeBlock.value.lo1;
+    }
+
+    /**
+     * Returns the configured upgrade delay in blocks.
+     */
+    public get upgradeDelay(): u64 {
+        return this._upgradeDelay;
+    }
+
+    /**
+     * Returns the block number when the pending upgrade can be applied.
+     */
+    public get upgradeEffectiveBlock(): u64 {
+        const submitBlock = this.pendingUpgradeBlock;
+        if (submitBlock === 0) return 0;
+        return submitBlock + this._upgradeDelay;
+    }
+
+    /**
+     * Returns true if there is a pending upgrade.
+     */
+    public get hasPendingUpgrade(): bool {
+        return this.pendingUpgradeBlock !== 0;
+    }
+
+    /**
+     * Returns true if the pending upgrade can be applied (delay has passed).
+     */
+    public get canApplyUpgrade(): bool {
+        if (!this.hasPendingUpgrade) return false;
+        return Blockchain.block.number >= this.upgradeEffectiveBlock;
+    }
+
+    /**
+     * Attempts to execute an upgrade-related method.
+     * Returns the response if the method was handled, or null if not.
+     *
+     * @param method - The method selector
+     * @param calldata - The calldata
+     * @returns BytesWriter response if handled, null otherwise
+     */
+    public override execute(method: Selector, calldata: Calldata): BytesWriter | null {
+        switch (method) {
+            case UpgradeablePlugin.SUBMIT_UPGRADE_SELECTOR:
+                return this.submitUpgrade(calldata);
+            case UpgradeablePlugin.APPLY_UPGRADE_SELECTOR:
+                return this.applyUpgrade(calldata);
+            case UpgradeablePlugin.CANCEL_UPGRADE_SELECTOR:
+                return this.cancelUpgrade();
+            case UpgradeablePlugin.PENDING_UPGRADE_SELECTOR:
+                return this.getPendingUpgrade();
+            case UpgradeablePlugin.UPGRADE_DELAY_SELECTOR:
+                return this.getUpgradeDelay();
+            default:
+                return null;
+        }
+    }
+
+    /**
+     * Submits an upgrade for timelock.
+     */
+    private submitUpgrade(calldata: Calldata): BytesWriter {
+        this.onlyDeployer();
+
+        if (this.hasPendingUpgrade) {
+            throw new Revert('Upgrade already pending. Cancel first.');
+        }
+
+        const sourceAddress = calldata.readAddress();
+
+        if (!Blockchain.isContract(sourceAddress)) {
+            throw new Revert('Source must be a deployed contract');
+        }
+
+        const currentBlock = Blockchain.block.number;
+        this._pendingUpgradeAddress.value = sourceAddress;
+        this._pendingUpgradeBlock.value = u256.fromU64(currentBlock);
+
+        const effectiveBlock = currentBlock + this._upgradeDelay;
+        Blockchain.emit(new UpgradeSubmittedEvent(sourceAddress, currentBlock, effectiveBlock));
+
+        return new BytesWriter(0);
+    }
+
+    /**
+     * Applies a pending upgrade after the timelock period has passed.
+     * Any remaining calldata after the source address is passed to onUpdate.
+     */
+    private applyUpgrade(calldata: Calldata): BytesWriter {
+        this.onlyDeployer();
+
+        if (!this.hasPendingUpgrade) {
+            throw new Revert('No pending upgrade');
+        }
+
+        if (!this.canApplyUpgrade) {
+            throw new Revert('Upgrade delay not elapsed');
+        }
+
+        const sourceAddress = calldata.readAddress();
+        const pendingAddress = this._pendingUpgradeAddress.value;
+
+        if (!sourceAddress.equals(pendingAddress)) {
+            throw new Revert('Address does not match pending upgrade');
+        }
+
+        // Clear pending state before upgrade
+        this._pendingUpgradeAddress.value = Address.zero();
+        this._pendingUpgradeBlock.value = u256.Zero;
+
+        Blockchain.emit(new UpgradeAppliedEvent(sourceAddress, Blockchain.block.number));
+
+        // Extract remaining calldata for onUpdate
+        const remainingLength = calldata.byteLength - calldata.getOffset();
+        const updateCalldata = new BytesWriter(remainingLength);
+        if (remainingLength > 0) {
+            const remainingBytes = calldata.readBytes(remainingLength);
+            updateCalldata.writeBytes(remainingBytes);
+        }
+
+        // Perform upgrade - new bytecode takes effect next block
+        Blockchain.updateContractFromExisting(sourceAddress, updateCalldata);
+
+        return new BytesWriter(0);
+    }
+
+    /**
+     * Cancels a pending upgrade.
+     */
+    private cancelUpgrade(): BytesWriter {
+        this.onlyDeployer();
+
+        if (!this.hasPendingUpgrade) {
+            throw new Revert('No pending upgrade');
+        }
+
+        const pendingAddress = this._pendingUpgradeAddress.value;
+
+        this._pendingUpgradeAddress.value = Address.zero();
+        this._pendingUpgradeBlock.value = u256.Zero;
+
+        Blockchain.emit(new UpgradeCancelledEvent(pendingAddress, Blockchain.block.number));
+
+        return new BytesWriter(0);
+    }
+
+    /**
+     * Returns the pending upgrade info.
+     */
+    private getPendingUpgrade(): BytesWriter {
+        const response = new BytesWriter(ADDRESS_BYTE_LENGTH + 16);
+        response.writeAddress(this._pendingUpgradeAddress.value);
+        response.writeU64(this.pendingUpgradeBlock);
+        response.writeU64(this.upgradeEffectiveBlock);
+        return response;
+    }
+
+    /**
+     * Returns the upgrade delay.
+     */
+    private getUpgradeDelay(): BytesWriter {
+        const response = new BytesWriter(8);
+        response.writeU64(this._upgradeDelay);
+        return response;
+    }
+
+    /**
+     * Validates that the caller is the contract deployer.
+     */
+    private onlyDeployer(): void {
+        if (Blockchain.contractDeployer !== Blockchain.tx.sender) {
+            throw new Revert('Only deployer can call this method');
+        }
+    }
+}

package/runtime/storage/BaseStoredString.ts

@@ -83,7 +83,7 @@ export abstract class BaseStoredString {
         let chunkCount: u64 = 1;
 
         // In the header slot, we can store up to 28 bytes of data.
-        const remaining = oldLength > 28 ? oldLength - 28 : 0;
+        const remaining: u64 = oldLength > 28 ? oldLength - 28 : 0;
         if (remaining > 0) {
             // Each additional chunk is 32 bytes.
             // Use integer math ceiling: (remaining + 32 - 1) / 32

package/runtime/storage/arrays/StoredPackedArray.ts

@@ -353,6 +353,10 @@ export abstract class StoredPackedArray<T> {
 
     @inline
     public setMultiple(startIndex: u32, values: T[]): void {
+        if (startIndex > u32.MAX_VALUE - <u32>values.length) {
+            throw new Revert('setMultiple: end index overflow (packed array)');
+        }
+
         const end = startIndex + <u32>values.length;
         if (end > this._length) {
             throw new Revert('setMultiple: out of range (packed array)');

package/runtime/types/ExtendedAddress.ts

@@ -4,6 +4,14 @@ import { Blockchain } from '../env';
 import { Network } from '../script/Networks';
 import { Address } from './Address';
 import { BitcoinAddresses } from '../script/BitcoinAddresses';
+import {
+    DEAD_ARRAY,
+    getCachedDeadAddress,
+    getCachedZeroAddress,
+    setCachedDeadAddress,
+    setCachedZeroAddress,
+    ZERO_ARRAY,
+} from './ExtendedAddressCache';
 
 /**
  * Extended address implementation for Bitcoin with dual-key support.
@@ -86,7 +94,13 @@ export class ExtendedAddress extends Address {
      * ```
      */
     public static dead(): ExtendedAddress {
-        return DEAD_ADDRESS.clone();
+        let cached = getCachedDeadAddress();
+        if (cached === 0) {
+            const addr = new ExtendedAddress(DEAD_ARRAY, ZERO_ARRAY);
+            cached = changetype<usize>(addr);
+            setCachedDeadAddress(cached);
+        }
+        return changetype<ExtendedAddress>(cached).clone();
     }
 
     /**
@@ -103,7 +117,13 @@ export class ExtendedAddress extends Address {
      * ```
      */
     public static zero(): ExtendedAddress {
-        return ZERO_BITCOIN_ADDRESS.clone();
+        let cached = getCachedZeroAddress();
+        if (cached === 0) {
+            const addr = new ExtendedAddress(ZERO_ARRAY, ZERO_ARRAY);
+            cached = changetype<usize>(addr);
+            setCachedZeroAddress(cached);
+        }
+        return changetype<ExtendedAddress>(cached).clone();
     }
 
     /**
@@ -299,7 +319,7 @@ export class ExtendedAddress extends Address {
     /**
      * Checks if this address equals the canonical dead address.
      *
-     * @returns `true` if this address matches DEAD_ADDRESS, `false` otherwise
+     * @returns `true` if this address matches the dead address, `false` otherwise
      *
      * @example
      * ```typescript
@@ -310,8 +330,18 @@ export class ExtendedAddress extends Address {
      * ```
      */
     public isDead(): bool {
+        // Use cached dead address for comparison
+        const deadAddr = ExtendedAddress.dead();
+
+        // Compare both ML-DSA key hash (this) and tweaked key
         for (let i = 0; i < this.length; i++) {
-            if (this[i] != DEAD_ADDRESS[i]) {
+            if (this[i] != deadAddr[i]) {
+                return false;
+            }
+        }
+
+        for (let i = 0; i < this.tweakedPublicKey.length; i++) {
+            if (this.tweakedPublicKey[i] != deadAddr.tweakedPublicKey[i]) {
                 return false;
             }
         }
@@ -393,32 +423,14 @@ export class ExtendedAddress extends Address {
  * Pre-initialized zero ExtendedAddress constant.
  * Both the tweaked key and ML-DSA key hash are all zeros.
  */
-export const ZERO_BITCOIN_ADDRESS: ExtendedAddress = new ExtendedAddress(
-    [
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0,
-    ],
-    [
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0,
-    ],
-);
+export const ZERO_BITCOIN_ADDRESS: ExtendedAddress = new ExtendedAddress(ZERO_ARRAY, ZERO_ARRAY);
 
 /**
  * Pre-initialized dead ExtendedAddress constant.
  * The tweaked key is zero while the ML-DSA key hash represents the canonical dead address.
  * Hash: 284ae4acdb32a99ba3ebfa66a91ddb41a7b7a1d2fef415399922cd8a04485c02
  */
-export const DEAD_ADDRESS: ExtendedAddress = new ExtendedAddress(
-    [
-        40, 74, 228, 172, 219, 50, 169, 155, 163, 235, 250, 102, 169, 29, 219, 65, 167, 183, 161,
-        210, 254, 244, 21, 57, 153, 34, 205, 138, 4, 72, 92, 2,
-    ],
-    [
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0,
-    ],
-);
+export const DEAD_ADDRESS: ExtendedAddress = new ExtendedAddress(DEAD_ARRAY, ZERO_ARRAY);
 
 /**
  * Type alias for nullable ExtendedAddress references.