@btc-vision/transaction 1.4.0 → 1.5.0

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@btc-vision/transaction",
     "type": "module",
-    "version": "1.4.0",
+    "version": "1.5.0",
     "author": "BlobMaster41",
     "description": "OPNet transaction library allows you to create and sign transactions for the OPNet network.",
     "engines": {
@@ -64,16 +64,16 @@
         "docs": "typedoc --out docs --exclude 'src/tests/*.ts' --tsconfig tsconfig.json --readme README.md --name OPNet --plugin typedoc-material-theme --themeColor '#cb9820' --exclude src/tests/test.ts --exclude src/index.ts src"
     },
     "devDependencies": {
-        "@babel/core": "^7.26.9",
+        "@babel/core": "^7.27.1",
         "@babel/plugin-proposal-class-properties": "^7.18.6",
-        "@babel/plugin-transform-runtime": "^7.26.9",
-        "@babel/preset-env": "^7.26.9",
-        "@babel/preset-flow": "^7.25.9",
-        "@babel/preset-react": "^7.26.3",
-        "@babel/preset-typescript": "^7.26.0",
-        "@types/node": "^22.13.10",
+        "@babel/plugin-transform-runtime": "^7.27.1",
+        "@babel/preset-env": "^7.27.2",
+        "@babel/preset-flow": "^7.27.1",
+        "@babel/preset-react": "^7.27.1",
+        "@babel/preset-typescript": "^7.27.1",
+        "@types/node": "^22.15.21",
         "@types/sha.js": "^2.4.4",
-        "eslint": "^9.22.0",
+        "eslint": "^9.27.0",
         "gulp": "^5.0.0",
         "gulp-cached": "^1.1.1",
         "gulp-typescript": "^6.0.0-alpha.1",
@@ -82,20 +82,20 @@
         "prettier": "^3.5.3",
         "stream-browserify": "^3.0.0",
         "stream-http": "^3.2.0",
-        "typedoc": "^0.27.9",
-        "typescript-eslint": "^8.26.0",
+        "typedoc": "^0.28.5",
+        "typescript-eslint": "^8.32.1",
         "webpack-cli": "^6.0.1"
     },
     "dependencies": {
         "@babel/plugin-proposal-object-rest-spread": "^7.20.7",
         "@bitcoinerlab/secp256k1": "^1.1.1",
-        "@btc-vision/bitcoin": "^6.3.6",
-        "@btc-vision/bitcoin-rpc": "^1.0.0",
+        "@btc-vision/bitcoin": "^6.4.1",
+        "@btc-vision/bitcoin-rpc": "^1.0.1",
         "@btc-vision/logger": "^1.0.6",
-        "@eslint/js": "^9.22.0",
-        "@noble/secp256k1": "^2.1.0",
+        "@eslint/js": "^9.27.0",
+        "@noble/secp256k1": "^2.2.3",
         "assert": "^2.1.0",
-        "babel-loader": "^9.2.1",
+        "babel-loader": "^10.0.0",
         "babel-plugin-transform-import-meta": "^2.3.2",
         "babel-preset-react": "^6.24.1",
         "babelify": "^10.0.0",
@@ -112,7 +112,7 @@
         "sha.js": "^2.4.11",
         "ts-loader": "^9.5.2",
         "ts-node": "^10.9.2",
-        "typescript": "^5.7.3",
-        "webpack": "^5.98.0"
+        "typescript": "^5.8.3",
+        "webpack": "^5.99.9"
     }
 }

package/src/buffer/BinaryReader.ts

@@ -182,7 +182,7 @@ export class BinaryReader {
      * Reads a string of the given length in raw bytes. By default, do NOT zero-stop
      * (matching how we wrote the raw bytes).
      */
-    public readString(length: u16): string {
+    public readString(length: u32): string {
         const textDecoder = new TextDecoder();
         const bytes = this.readBytes(length, false);
         return textDecoder.decode(bytes);
@@ -192,7 +192,7 @@ export class BinaryReader {
      * Reads a string that was written as [u16 length][raw bytes].
      */
     public readStringWithLength(be: boolean = true): string {
-        const length = this.readU16(be);
+        const length = this.readU32(be);
         return this.readString(length);
     }
 

package/src/buffer/BinaryWriter.ts

@@ -160,9 +160,9 @@ export class BinaryWriter {
     }
 
     public writeStringWithLength(value: string): void {
-        this.allocSafe(U16_BYTE_LENGTH + value.length);
+        this.allocSafe(U32_BYTE_LENGTH + value.length);
 
-        this.writeU16(value.length);
+        this.writeU32(value.length);
         this.writeString(value);
     }
 

package/src/keypair/Address.ts

@@ -12,6 +12,7 @@ import { BitcoinUtils } from '../utils/BitcoinUtils.js';
  */
 export class Address extends Uint8Array {
     #p2tr: string | undefined;
+    #p2op: string | undefined;
     #network: Network | undefined;
     #originalPublicKey: Uint8Array | undefined;
     #keyPair: ECPairInterface | undefined;
@@ -316,6 +317,26 @@ export class Address extends Uint8Array {
         throw new Error('Public key not set');
     }
 
+    /**
+     * Get an opnet address encoded in bech32m format.
+     * @param network
+     */
+    public p2op(network: Network): string {
+        if (this.#p2op && this.#network === network) {
+            return this.#p2op;
+        }
+
+        const p2opAddy: string | undefined = EcKeyPair.p2op(this, network);
+        if (p2opAddy) {
+            this.#network = network;
+            this.#p2op = p2opAddy;
+
+            return p2opAddy;
+        }
+
+        throw new Error('Public key not set');
+    }
+
     public toTweakedHybridPublicKeyHex(): string {
         if (!this.#tweakedUncompressed) {
             throw new Error('Public key not set');

package/src/keypair/AddressVerificator.ts

@@ -7,6 +7,7 @@ initEccLib(ecc);
 
 export enum AddressTypes {
     P2PKH = 'P2PKH',
+    P2OP = 'P2OP',
     P2SH_OR_P2SH_P2WPKH = 'P2SH_OR_P2SH-P2WPKH',
     P2PK = 'P2PK',
     P2TR = 'P2TR',
@@ -169,11 +170,11 @@ export class AddressVerificator {
         try {
             // First, try to decode as a Base58Check address (P2PKH, P2SH, or P2SH-P2WPKH)
             const decodedBase58 = address.fromBase58Check(addy);
-
             if (decodedBase58.version === network.pubKeyHash) {
                 // P2PKH: Legacy address (starting with '1' for mainnet, 'm/n' for testnet)
                 return AddressTypes.P2PKH;
             }
+
             if (decodedBase58.version === network.scriptHash) {
                 // P2SH: Could be P2SH (general) or P2SH-P2WPKH (wrapped SegWit)
                 return AddressTypes.P2SH_OR_P2SH_P2WPKH;
@@ -183,12 +184,16 @@ export class AddressVerificator {
         try {
             // Try to decode as a Bech32 or Bech32m address (P2WPKH or P2TR)
             const decodedBech32 = address.fromBech32(addy);
+            if (decodedBech32.prefix === network.bech32Opnet && decodedBech32.version === 16) {
+                return AddressTypes.P2OP;
+            }
 
             if (decodedBech32.prefix === network.bech32) {
                 // P2WPKH: SegWit address (starting with 'bc1q' for mainnet, 'tb1q' for testnet)
                 if (decodedBech32.version === 0 && decodedBech32.data.length === 20) {
                     return AddressTypes.P2WPKH;
                 }
+
                 // P2TR: Taproot address (starting with 'bc1p' for mainnet, 'tb1p' for testnet)
                 if (decodedBech32.version === 1 && decodedBech32.data.length === 32) {
                     return AddressTypes.P2TR;

package/src/keypair/EcKeyPair.ts

@@ -1,18 +1,23 @@
 import * as ecc from '@bitcoinerlab/secp256k1';
 import bip32, { BIP32API, BIP32Factory, BIP32Interface } from 'bip32';
-import {
+import bitcoin, {
     address,
+    fromOutputScript,
     initEccLib,
     Network,
     networks,
+    opcodes,
     payments,
+    script,
     Signer,
-    taggedHash,
     toXOnly,
 } from '@btc-vision/bitcoin';
 import { ECPairAPI, ECPairFactory, ECPairInterface } from 'ecpair';
 import { IWallet } from './interfaces/IWallet.js';
-import { CURVE, ProjectivePoint as Point } from '@noble/secp256k1';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { bytesToNumberBE, concatBytes, utf8ToBytes } from '@noble/curves/abstract/utils';
+import { mod } from '@noble/curves/abstract/modular';
+import { sha256 } from '@noble/hashes/sha2';
 
 initEccLib(ecc);
 
@@ -21,10 +26,16 @@ if (!BIP32factory) {
     throw new Error('Failed to load BIP32 library');
 }
 
-const mod = (a: bigint, b: bigint): bigint => {
-    const result = a % b;
-    return result >= 0n ? result : result + b;
-};
+secp256k1.utils.precompute(8);
+
+const { ProjectivePoint: Point, CURVE } = secp256k1;
+
+const TAP_TAG = utf8ToBytes('TapTweak');
+const TAP_TAG_HASH = sha256(TAP_TAG);
+
+function tapTweakHash(x: Uint8Array): Uint8Array {
+    return sha256(concatBytes(TAP_TAG_HASH, TAP_TAG_HASH, x));
+}
 
 /**
  * Class for handling EC key pairs
@@ -195,6 +206,32 @@ export class EcKeyPair {
         return address;
     }
 
+    /**
+     * Generate a P2OP address
+     * @param bytes - The bytes to use for the P2OP address
+     * @param network - The network to use
+     * @param deploymentVersion - The deployment version (default is 0)
+     * @returns {string} - The generated P2OP address
+     */
+    public static p2op(
+        bytes: Buffer | Uint8Array,
+        network: Network = networks.bitcoin,
+        deploymentVersion: number = 0,
+    ): string {
+        // custom opnet contract addresses
+        const witnessProgram = Buffer.concat([
+            Buffer.from([deploymentVersion]),
+            bitcoin.crypto.hash160(Buffer.from(bytes)),
+        ]);
+
+        if (witnessProgram.length < 2 || witnessProgram.length > 40) {
+            throw new Error('Witness program must be 2-40 bytes.');
+        }
+
+        const scriptData = script.compile([opcodes.OP_16, witnessProgram]);
+        return fromOutputScript(scriptData, network);
+    }
+
     /**
      * Get the address of a xOnly tweaked public key
      * @param {string} tweakedPubKeyHex - The xOnly tweaked public key hex string
@@ -225,42 +262,44 @@ export class EcKeyPair {
 
     /**
      * Tweak a public key
-     * @param {string | Buffer} compressedPubKeyHex - The compressed public key hex string
+     * @param {Buffer | Uint8Array | string} pub - The public key to tweak
      * @returns {Buffer} - The tweaked public key hex string
      * @throws {Error} - If the public key cannot be tweaked
      */
-    public static tweakPublicKey(compressedPubKeyHex: string | Buffer): Buffer {
-        if (typeof compressedPubKeyHex === 'string' && compressedPubKeyHex.startsWith('0x')) {
-            compressedPubKeyHex = compressedPubKeyHex.slice(2);
-        }
-
-        if (typeof compressedPubKeyHex !== 'string') {
-            compressedPubKeyHex = compressedPubKeyHex.toString('hex');
-        }
+    public static tweakPublicKey(pub: Uint8Array | Buffer | string): Buffer {
+        if (typeof pub === 'string' && pub.startsWith('0x')) pub = pub.slice(2);
 
-        // Convert the compressed public key hex string to a Point on the curve
-        let P = Point.fromHex(compressedPubKeyHex);
+        const P = Point.fromHex(pub);
+        const Peven = (P.y & 1n) === 0n ? P : P.negate();
 
-        // Ensure the point has an even y-coordinate
-        if ((P.y & 1n) !== 0n) {
-            // Negate the point to get an even y-coordinate
-            P = P.negate();
-        }
-
-        // Get the x-coordinate (32 bytes) of the point
-        const x = P.toRawBytes(true).slice(1); // Remove the prefix byte
-
-        // Compute the tweak t = H_tapTweak(x)
-        const tHash = taggedHash('TapTweak', Buffer.from(x));
-        const t = mod(BigInt('0x' + Buffer.from(tHash).toString('hex')), CURVE.n);
+        const xBytes = Peven.toRawBytes(true).subarray(1);
+        const tBytes = tapTweakHash(xBytes);
+        const t = mod(bytesToNumberBE(tBytes), CURVE.n);
 
-        // Compute Q = P + t*G (where G is the generator point)
-        const Q = P.add(Point.BASE.mul(t));
-
-        // Return the tweaked public key in compressed form (hex string)
+        const Q = Peven.add(Point.BASE.multiply(t));
         return Buffer.from(Q.toRawBytes(true));
     }
 
+    /**
+     * Tweak a batch of public keys
+     * @param {readonly Uint8Array[]} pubkeys - The public keys to tweak
+     * @param {bigint} tweakScalar - The scalar to use for tweaking
+     * @returns {Uint8Array[]} - The tweaked public keys
+     */
+    public static tweakBatchSharedT(
+        pubkeys: readonly Uint8Array[],
+        tweakScalar: bigint,
+    ): Uint8Array[] {
+        const T = Point.BASE.multiply(tweakScalar);
+
+        return pubkeys.map((bytes) => {
+            const P = Point.fromHex(bytes);
+            const P_even = P.hasEvenY() ? P : P.negate();
+            const Q = P_even.add(T);
+            return Q.toRawBytes(true);
+        });
+    }
+
     /**
      * Generate a random wallet
      * @param {Network} network - The network to use
@@ -337,6 +376,24 @@ export class EcKeyPair {
         return wallet.address;
     }
 
+    /**
+     * Get the legacy address from a keypair
+     * @param publicKey
+     * @param {Network} network - The network to use
+     * @returns {string} - The legacy address
+     */
+    public static getP2PKH(
+        publicKey: Buffer | Uint8Array,
+        network: Network = networks.bitcoin,
+    ): string {
+        const wallet = payments.p2pkh({ pubkey: Buffer.from(publicKey), network: network });
+        if (!wallet.address) {
+            throw new Error('Failed to generate wallet');
+        }
+
+        return wallet.address;
+    }
+
     /**
      * Get the legacy address from a keypair
      * @param {ECPairInterface} keyPair - The keypair to get the address for

package/src/transaction/TransactionFactory.ts

@@ -30,8 +30,6 @@ export interface DeploymentResult {
 
     readonly contractAddress: string;
     readonly contractPubKey: string;
-    readonly p2trAddress: string;
-
     readonly preimage: string;
 
     readonly utxos: UTXO[];
@@ -89,13 +87,22 @@ export class TransactionFactory {
             throw new Error('Field "from" not provided.');
         }
 
+        if (!interactionParameters.utxos[0]) {
+            throw new Error('Missing at least one UTXO.');
+        }
+
+        if (!('signer' in interactionParameters)) {
+            throw new Error('Field "signer" not provided, OP_WALLET not detected.');
+        }
+
+        const inputs = this.parseOptionalInputs(interactionParameters.optionalInputs);
         const preTransaction: CustomScriptTransaction = new CustomScriptTransaction({
             ...interactionParameters,
             utxos: [interactionParameters.utxos[0]], // we simulate one input here.
+            optionalInputs: inputs,
         });
 
         // we don't sign that transaction, we just need the parameters.
-
         await preTransaction.generateTransactionMinimalSignatures();
 
         const parameters: IFundingTransactionParameters =
@@ -119,7 +126,12 @@ export class TransactionFactory {
 
         parameters.estimatedFees = feeEstimationFundingTransaction.estimatedFees;
 
-        const signedTransaction = await this.createFundTransaction(parameters);
+        const signedTransaction = await this.createFundTransaction({
+            ...parameters,
+            optionalOutputs: [],
+            optionalInputs: [],
+        });
+
         if (!signedTransaction) {
             throw new Error('Could not sign funding transaction.');
         }
@@ -132,10 +144,13 @@ export class TransactionFactory {
 
         const newParams: ICustomTransactionParameters = {
             ...interactionParameters,
-            utxos: this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0), // always 0
+            utxos: [
+                ...this.getUTXOAsTransaction(signedTransaction.tx, interactionParameters.to, 0),
+            ], // always 0
             randomBytes: preTransaction.getRndBytes(),
             nonWitnessUtxo: signedTransaction.tx.toBuffer(),
             estimatedFees: preTransaction.estimatedFees,
+            optionalInputs: inputs,
         };
 
         const finalTransaction: CustomScriptTransaction = new CustomScriptTransaction(newParams);
@@ -352,9 +367,8 @@ export class TransactionFactory {
 
         return {
             transaction: [signedTransaction.toHex(), outTx.toHex()],
-            contractAddress: finalTransaction.contractAddress.p2tr(deploymentParameters.network),
+            contractAddress: finalTransaction.getContractAddress(), //finalTransaction.contractAddress.p2tr(deploymentParameters.network),
             contractPubKey: finalTransaction.contractPubKey,
-            p2trAddress: finalTransaction.p2trAddress,
             utxos: [refundUTXO],
             preimage: preTransaction.getPreimage().toString('hex'),
         };

package/src/transaction/browser/Web3Provider.ts

@@ -4,6 +4,7 @@ import {
 } from '../interfaces/ITransactionParameters.js';
 import { UTXO } from '../../utxo/interfaces/IUTXO.js';
 import { DeploymentResult, InteractionResponse } from '../TransactionFactory';
+import { ICustomTransactionParameters } from '../builders/CustomScriptTransaction.js';
 
 export type InteractionParametersWithoutSigner = Omit<
     IInteractionParameters,
@@ -15,6 +16,11 @@ export type IDeploymentParametersWithoutSigner = Omit<
     'signer' | 'network' | 'preimage'
 >;
 
+export type CustomTransactionWithoutSigner = Omit<
+    ICustomTransactionParameters,
+    'signer' | 'preimage'
+>;
+
 export interface BroadcastTransactionOptions {
     raw: string;
     psbt: boolean;

package/src/transaction/builders/CustomScriptTransaction.ts

@@ -19,10 +19,13 @@ import { AddressGenerator } from '../../generators/AddressGenerator.js';
 import { ECPairInterface } from 'ecpair';
 
 export interface ICustomTransactionParameters extends SharedInteractionParameters {
-    readonly script: (Buffer | Stack)[];
-    readonly witnesses: Buffer[];
+    script: (Buffer | Stack)[];
+    witnesses: Buffer[];
 
-    readonly to: string;
+    /** optional Taproot annex payload (without the 0x50 prefix) */
+    annex?: Buffer;
+
+    to: string;
 }
 
 /**
@@ -91,6 +94,7 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
      * @private
      */
     private readonly witnesses: Buffer[];
+    private readonly annexData?: Buffer;
 
     public constructor(parameters: ICustomTransactionParameters) {
         super(parameters);
@@ -202,7 +206,10 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
         for (let i = 0; i < transaction.data.inputs.length; i++) {
             if (i === 0) {
                 // multi sig input
-                transaction.signInput(0, this.contractSigner);
+                try {
+                    transaction.signInput(0, this.contractSigner);
+                } catch (e) {}
+
                 transaction.signInput(0, this.getSignerKey());
 
                 transaction.finalizeInput(0, this.customFinalizer);
@@ -250,6 +257,21 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
         };
     }
 
+    protected getScriptSolution(input: PsbtInput): Buffer[] {
+        if (!input.tapScriptSig) {
+            throw new Error('Tap script signature is required');
+        }
+
+        const witnesses: Buffer[] = [...this.witnesses];
+        if (input.tapScriptSig) {
+            for (const sig of input.tapScriptSig) {
+                witnesses.push(sig.signature);
+            }
+        }
+
+        return witnesses;
+    }
+
     /**
      * Generate the contract seed for the deployment
      * @private
@@ -261,18 +283,27 @@ export class CustomScriptTransaction extends TransactionBuilder<TransactionType.
     /**
      * Finalize the transaction
      * @param _inputIndex
-     * @param _input
+     * @param input
      */
-    private customFinalizer = (_inputIndex: number, _input: PsbtInput) => {
+    private customFinalizer = (_inputIndex: number, input: PsbtInput) => {
         if (!this.tapLeafScript) {
             throw new Error('Tap leaf script is required');
         }
 
-        const scriptSolution = this.witnesses;
+        const scriptSolution = this.getScriptSolution(input);
         const witness = scriptSolution
             .concat(this.tapLeafScript.script)
             .concat(this.tapLeafScript.controlBlock);
 
+        if (this.annexData && this.annexData.length > 0) {
+            const annex =
+                this.annexData[0] === 0x50
+                    ? this.annexData
+                    : Buffer.concat([Buffer.from([0x50]), this.annexData]);
+
+            witness.push(annex);
+        }
+
         return {
             finalScriptWitness: TransactionBuilder.witnessStackToScriptWitness(witness),
         };

package/src/transaction/builders/DeploymentTransaction.ts

@@ -30,10 +30,8 @@ const p = 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn;
 export class DeploymentTransaction extends TransactionBuilder<TransactionType.DEPLOYMENT> {
     public static readonly MAXIMUM_CONTRACT_SIZE = 128 * 1024;
     public type: TransactionType.DEPLOYMENT = TransactionType.DEPLOYMENT;
-
     protected readonly preimage: Buffer; // ALWAYS 128 bytes for the preimage
     protected readonly rewardChallenge: IMineableReward;
-
     /**
      * The contract address
      * @protected
@@ -44,6 +42,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * @private
      */
     protected tapLeafScript: TapLeafScript | null = null;
+    private readonly deploymentVersion: number = 0x00;
     /**
      * The target script redeem
      * @private
@@ -105,6 +104,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
      * @private
      */
     private readonly randomBytes: Buffer;
+    private _computedAddress: string | undefined;
 
     public constructor(parameters: IDeploymentParameters) {
         // TODO: Add legacy deployment, this is only p2tr.
@@ -190,6 +190,20 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         return this.preimage;
     }
 
+    public getContractAddress(): string {
+        if (this._computedAddress) {
+            return this._computedAddress;
+        }
+
+        this._computedAddress = EcKeyPair.p2op(
+            this.contractSeed,
+            this.network,
+            this.deploymentVersion,
+        );
+
+        return this._computedAddress;
+    }
+
     /**
      * Get the contract signer public key
      * @protected
@@ -243,7 +257,7 @@ export class DeploymentTransaction extends TransactionBuilder<TransactionType.DE
         // ALWAYS THE FIRST INPUT.
         this.addOutput({
             value: Number(amountToCA),
-            address: this.contractAddress.p2tr(this.network),
+            address: this.getContractAddress(),
         });
 
         // ALWAYS SECOND.

package/src/transaction/builders/TransactionBuilder.ts

@@ -27,7 +27,7 @@ import { UnisatSigner } from '../browser/extensions/UnisatSigner.js';
 initEccLib(ecc);
 
 export const MINIMUM_AMOUNT_REWARD: bigint = 540n;
-export const MINIMUM_AMOUNT_CA: bigint = 330n;
+export const MINIMUM_AMOUNT_CA: bigint = 297n;
 
 /**
  * Allows to build a transaction like you would on Ethereum.
@@ -36,9 +36,10 @@ export const MINIMUM_AMOUNT_CA: bigint = 330n;
  * @class TransactionBuilder
  */
 export abstract class TransactionBuilder<T extends TransactionType> extends TweakedTransaction {
+    // Cancel script
     public static readonly LOCK_LEAF_SCRIPT: Buffer = script.compile([
-        opcodes.OP_0,
-        //opcodes.OP_VERIFY, - verify that this is not needed.
+        opcodes.OP_FALSE,
+        opcodes.OP_VERIFY,
     ]);
 
     public static readonly MINIMUM_DUST: bigint = 50n;

package/src/transaction/shared/TweakedTransaction.ts

@@ -151,8 +151,8 @@ export abstract class TweakedTransaction extends Logger {
 
         function readVarInt(): number {
             const varint = varuint.decode(Buffer, offset);
-            offset += varuint.decode.bytes;
-            return varint;
+            offset += varint.bytes;
+            return varint.numberValue || 0;
         }
 
         function readVarSlice(): Buffer {