@btc-vision/btc-runtime 1.9.13 → 1.9.15

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@btc-vision/btc-runtime",
-    "version": "1.9.13",
+    "version": "1.9.15",
     "description": "Bitcoin Smart Contract Runtime",
     "main": "btc/index.ts",
     "scripts": {
@@ -25,8 +25,8 @@
         "@btc-vision/as-pect-assembly": "^8.2.0",
         "@btc-vision/as-pect-cli": "^8.2.0",
         "@btc-vision/as-pect-transform": "^8.2.0",
-        "@types/node": "^24.2.1",
-        "assemblyscript": "^0.28.4"
+        "@types/node": "^24.10.0",
+        "assemblyscript": "^0.28.9"
     },
     "repository": {
         "type": "git",
@@ -43,14 +43,13 @@
         "test/*.ts"
     ],
     "dependencies": {
-        "@assemblyscript/loader": "^0.28.4",
+        "@assemblyscript/loader": "^0.28.9",
         "@btc-vision/as-bignum": "^0.0.5",
-        "@btc-vision/opnet-transform": "^0.1.11",
-        "@eslint/js": "^9.33.0",
+        "@btc-vision/opnet-transform": "^0.1.12",
+        "@eslint/js": "9.39.1",
         "gulplog": "^2.2.0",
         "ts-node": "^10.9.2",
-        "typescript": "^5.9.2",
-        "typescript-eslint": "^8.39.0",
-        "yaml": "^2.8.1"
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.46.3"
     }
 }

package/runtime/contracts/OP20.ts

@@ -66,6 +66,9 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
     protected readonly _symbol: StoredString;
     protected readonly _nonceMap: AddressMemoryMap;
 
+    /** Intentionally public for inherited classes */
+    public _totalSupply: StoredU256;
+
     public constructor() {
         super();
 
@@ -81,38 +84,6 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         this._icon = new StoredString(stringPointer, 2);
     }
 
-    /** Intentionally public for inherited classes */
-    public _totalSupply: StoredU256;
-
-    public get totalSupply(): u256 {
-        return this._totalSupply.value;
-    }
-
-    public get name(): string {
-        if (!this._name) throw new Revert('Name not set');
-        return this._name.value;
-    }
-
-    public get symbol(): string {
-        if (!this._symbol) throw new Revert('Symbol not set');
-        return this._symbol.value;
-    }
-
-    public get icon(): string {
-        if (!this._icon) throw new Revert('Icon not set');
-        return this._icon.value;
-    }
-
-    public get decimals(): u8 {
-        if (!this._decimals) throw new Revert('Decimals not set');
-        return u8(this._decimals.value.toU32());
-    }
-
-    public get maxSupply(): u256 {
-        if (!this._maxSupply) throw new Revert('Max supply not set');
-        return this._maxSupply.value;
-    }
-
     public instantiate(
         params: OP20InitParameters,
         skipDeployerVerification: boolean = false,
@@ -128,51 +99,51 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         this._icon.value = params.icon;
     }
 
-    @method('name')
+    @method()
     @returns({ name: 'name', type: ABIDataTypes.STRING })
-    public fn_name(_: Calldata): BytesWriter {
-        const w = new BytesWriter(String.UTF8.byteLength(this.name) + 4);
-        w.writeStringWithLength(this.name);
+    public name(_: Calldata): BytesWriter {
+        const w = new BytesWriter(String.UTF8.byteLength(this._name.value) + 4);
+        w.writeStringWithLength(this._name.value);
         return w;
     }
 
-    @method('symbol')
+    @method()
     @returns({ name: 'symbol', type: ABIDataTypes.STRING })
-    public fn_symbol(_: Calldata): BytesWriter {
-        const w = new BytesWriter(String.UTF8.byteLength(this.symbol) + 4);
-        w.writeStringWithLength(this.symbol);
+    public symbol(_: Calldata): BytesWriter {
+        const w = new BytesWriter(String.UTF8.byteLength(this._symbol.value) + 4);
+        w.writeStringWithLength(this._symbol.value);
         return w;
     }
 
-    @method('icon')
+    @method()
     @returns({ name: 'icon', type: ABIDataTypes.STRING })
-    public fn_icon(_: Calldata): BytesWriter {
-        const w = new BytesWriter(String.UTF8.byteLength(this.icon) + 4);
-        w.writeStringWithLength(this.icon);
+    public icon(_: Calldata): BytesWriter {
+        const w = new BytesWriter(String.UTF8.byteLength(this._icon.value) + 4);
+        w.writeStringWithLength(this._icon.value);
         return w;
     }
 
-    @method('decimals')
+    @method()
     @returns({ name: 'decimals', type: ABIDataTypes.UINT8 })
-    public fn_decimals(_: Calldata): BytesWriter {
+    public decimals(_: Calldata): BytesWriter {
         const w = new BytesWriter(1);
-        w.writeU8(this.decimals);
+        w.writeU8(this._decimals.value.toU32());
         return w;
     }
 
-    @method('totalSupply')
+    @method()
     @returns({ name: 'totalSupply', type: ABIDataTypes.UINT256 })
-    public fn_totalSupply(_: Calldata): BytesWriter {
+    public totalSupply(_: Calldata): BytesWriter {
         const w = new BytesWriter(U256_BYTE_LENGTH);
-        w.writeU256(this.totalSupply);
+        w.writeU256(this._totalSupply.value);
         return w;
     }
 
-    @method('maximumSupply')
+    @method()
     @returns({ name: 'maximumSupply', type: ABIDataTypes.UINT256 })
-    public fn_maximumSupply(_: Calldata): BytesWriter {
+    public maximumSupply(_: Calldata): BytesWriter {
         const w = new BytesWriter(U256_BYTE_LENGTH);
-        w.writeU256(this.maxSupply);
+        w.writeU256(this._maxSupply.value);
         return w;
     }
 
@@ -363,9 +334,9 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         { name: 'domainSeparator', type: ABIDataTypes.BYTES32 },
     )
     public metadata(_: Calldata): BytesWriter {
-        const name = this.name;
-        const symbol = this.symbol;
-        const icon = this.icon;
+        const name = this._name.value;
+        const symbol = this._symbol.value;
+        const icon = this._icon.value;
         const domainSeparator = this._buildDomainSeparator();
 
         const nameLength = String.UTF8.byteLength(name);
@@ -385,8 +356,8 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         w.writeStringWithLength(name);
         w.writeStringWithLength(symbol);
         w.writeStringWithLength(icon);
-        w.writeU8(this.decimals);
-        w.writeU256(this.totalSupply);
+        w.writeU8(this._decimals.value.toU32());
+        w.writeU256(this._totalSupply.value);
         w.writeBytesWithLength(domainSeparator);
 
         return w;
@@ -583,7 +554,7 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
     protected _buildDomainSeparator(): Uint8Array {
         const writer = new BytesWriter(32 * 5 + ADDRESS_BYTE_LENGTH);
         writer.writeBytesU8Array(OP712_DOMAIN_TYPE_HASH);
-        writer.writeBytes(sha256String(this.name));
+        writer.writeBytes(sha256String(this._name.value));
         writer.writeBytesU8Array(OP712_VERSION_HASH);
         writer.writeBytes(Blockchain.chainId);
         writer.writeBytes(Blockchain.protocolId);
@@ -646,7 +617,7 @@ export abstract class OP20 extends ReentrancyGuard implements IOP20 {
         // @ts-expect-error AssemblyScript valid
         this._totalSupply += amount;
 
-        if (this._totalSupply.value > this.maxSupply) {
+        if (this._totalSupply.value > this._maxSupply.value) {
             throw new Revert('Max supply reached');
         }
 

package/runtime/contracts/interfaces/IOP20.ts

@@ -2,12 +2,21 @@ import { BytesWriter } from '../../buffer/BytesWriter';
 import { Calldata } from '../../types';
 
 export interface IOP20 {
+    name(callData: Calldata): BytesWriter;
+    symbol(callData: Calldata): BytesWriter;
+    icon(callData: Calldata): BytesWriter;
+    decimals(callData: Calldata): BytesWriter;
+    totalSupply(callData: Calldata): BytesWriter;
     domainSeparator(callData: Calldata): BytesWriter;
+    metadata(callData: Calldata): BytesWriter;
     balanceOf(callData: Calldata): BytesWriter;
     nonceOf(callData: Calldata): BytesWriter;
     allowance(callData: Calldata): BytesWriter;
     safeTransfer(callData: Calldata): BytesWriter;
     safeTransferFrom(callData: Calldata): BytesWriter;
+    transfer(callData: Calldata): BytesWriter;
+    transferFrom(callData: Calldata): BytesWriter;
+    burn(callData: Calldata): BytesWriter;
     increaseAllowance(callData: Calldata): BytesWriter;
     decreaseAllowance(callData: Calldata): BytesWriter;
     increaseAllowanceBySignature(callData: Calldata): BytesWriter;

package/runtime/contracts/interfaces/IOP20Receiver.ts

@@ -0,0 +1,6 @@
+import { BytesWriter } from '../../buffer/BytesWriter';
+import { Calldata } from '../../types';
+
+export interface IOP20Receiver {
+    onOP20Received(callData: Calldata): BytesWriter;
+}

package/runtime/events/predefined/ApprovedEvent.ts

@@ -6,11 +6,11 @@ import { NetEvent } from '../NetEvent';
 
 @final
 export class ApprovedEvent extends NetEvent {
-    constructor(owner: Address, spender: Address, value: u256) {
+    constructor(owner: Address, spender: Address, amount: u256) {
         const data: BytesWriter = new BytesWriter(ADDRESS_BYTE_LENGTH * 2 + U256_BYTE_LENGTH);
         data.writeAddress(owner);
         data.writeAddress(spender);
-        data.writeU256(value);
+        data.writeU256(amount);
 
         super('Approved', data);
     }

package/runtime/script/BitcoinCodec.ts

@@ -353,6 +353,7 @@ export class BitcoinCodec {
     /**
      * Validate that a witness script is within size limits
      * Bitcoin consensus rules limit witness scripts to 10,000 bytes
+     * Witness scripts above 3,600 bytes are non-standard and will not be relayed
      *
      * @param witnessScript - The script to validate
      * @returns true if the script is within limits

package/runtime/script/Segwit.ts

@@ -2,6 +2,7 @@ import { SegwitDecoded } from './ScriptUtils';
 import { hash160, sha256 } from '../env/global';
 import { Bech32 } from './Bech32';
 import { Revert } from '../types/Revert';
+import { BitcoinCodec } from './BitcoinCodec';
 
 /**
  * Segwit provides high-level functions for creating and decoding
@@ -23,6 +24,10 @@ export class Segwit {
      * @returns The Bech32-encoded address
      */
     public static p2wsh(hrp: string, witnessScript: Uint8Array): string {
+        if (BitcoinCodec.isValidWitnessScriptSize(witnessScript)) {
+            throw new Revert('Witness script size is invalid');
+        }
+
         // P2WSH uses SHA256 of the script as the witness program
         const program = sha256(witnessScript);
         return Bech32.encode(hrp, 0, program);
@@ -33,6 +38,10 @@ export class Segwit {
      * This is useful when you need to handle encoding failures gracefully
      */
     public static p2wshOrNull(hrp: string, witnessScript: Uint8Array): string | null {
+        if (BitcoinCodec.isValidWitnessScriptSize(witnessScript)) {
+            throw new Revert('Witness script size is invalid');
+        }
+
         const program = sha256(witnessScript);
         return Bech32.encodeOrNull(hrp, 0, program);
     }
@@ -49,8 +58,8 @@ export class Segwit {
      * @returns The Bech32-encoded address
      */
     public static p2wpkh(hrp: string, pubkey: Uint8Array): string {
-        if (pubkey.length !== 33 && pubkey.length !== 65) {
-            throw new Revert('Public key must be 33 bytes (compressed) or 65 bytes (uncompressed)');
+        if (pubkey.length !== 33) {
+            throw new Revert('Public key must be 33 bytes');
         }
 
         // P2WPKH uses HASH160 of the public key as the witness program