@btc-vision/cli 1.0.0

package/build/commands/VerifyCommand.js

@@ -0,0 +1,167 @@
+import * as fs from 'fs';
+import * as crypto from 'crypto';
+import { BaseCommand } from './BaseCommand.js';
+import { parseOpnetBinary, verifyChecksum, formatFileSize } from '../lib/binary.js';
+import { CLIWallet } from '../lib/wallet.js';
+export class VerifyCommand extends BaseCommand {
+    constructor() {
+        super('verify', 'Verify a .opnet binary signature and integrity');
+    }
+    configure() {
+        this.command
+            .argument('<file>', 'Path to .opnet file')
+            .option('-v, --verbose', 'Show detailed information')
+            .option('--json', 'Output as JSON')
+            .action((file, options) => this.execute(file, options));
+    }
+    execute(file, options) {
+        try {
+            if (!fs.existsSync(file)) {
+                if (options.json) {
+                    this.logger.log(JSON.stringify({ valid: false, error: `File not found: ${file}` }));
+                    process.exit(1);
+                }
+                this.exitWithError(`File not found: ${file}`);
+            }
+            const data = fs.readFileSync(file);
+            const fileSize = data.length;
+            let parsed;
+            try {
+                parsed = parseOpnetBinary(data);
+            }
+            catch (error) {
+                if (options.json) {
+                    this.logger.log(JSON.stringify({
+                        valid: false,
+                        error: `Parse error: ${error instanceof Error ? error.message : String(error)}`,
+                    }));
+                    process.exit(1);
+                }
+                this.exitWithError(`Parse error: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            const mldsaLevel = [44, 65, 87][parsed.mldsaLevel];
+            const checksumValid = verifyChecksum(parsed);
+            let signatureValid = false;
+            let signatureError;
+            const isUnsigned = parsed.publicKey.every((b) => b === 0);
+            if (isUnsigned) {
+                signatureError = 'Binary is unsigned (public key is empty)';
+            }
+            else {
+                try {
+                    signatureValid = CLIWallet.verifyMLDSA(parsed.checksum, parsed.signature, parsed.publicKey, mldsaLevel);
+                }
+                catch (error) {
+                    signatureError = error instanceof Error ? error.message : String(error);
+                }
+            }
+            const isValid = checksumValid && signatureValid;
+            if (options.json) {
+                const output = {
+                    valid: isValid,
+                    file,
+                    fileSize,
+                    formatVersion: parsed.formatVersion,
+                    mldsaLevel,
+                    checksumValid,
+                    signatureValid,
+                    signatureError,
+                    isUnsigned,
+                    metadata: parsed.metadata,
+                    publicKeyHash: crypto.createHash('sha256').update(parsed.publicKey).digest('hex'),
+                    bytecodeSize: parsed.bytecode.length,
+                    protoSize: parsed.proto?.length ?? 0,
+                };
+                this.logger.log(JSON.stringify(output, null, 2));
+                process.exit(isValid ? 0 : 1);
+            }
+            this.logger.info('\nOPNet Binary Verification\n');
+            this.logger.log('─'.repeat(60));
+            this.logger.log(`File:            ${file}`);
+            this.logger.log(`Size:            ${formatFileSize(fileSize)}`);
+            this.logger.log(`Format Version:  ${parsed.formatVersion}`);
+            this.logger.log('');
+            this.logger.log('Plugin:');
+            this.logger.log(`  Name:           ${parsed.metadata.name}`);
+            this.logger.log(`  Version:        ${parsed.metadata.version}`);
+            this.logger.log(`  Type:           ${parsed.metadata.pluginType}`);
+            this.logger.log(`  OPNet Version:  ${parsed.metadata.opnetVersion}`);
+            this.logger.log('');
+            this.logger.log('Cryptography:');
+            this.logger.log(`  MLDSA Level:    MLDSA-${mldsaLevel}`);
+            this.logger.log(`  Public Key:     ${formatFileSize(parsed.publicKey.length)}`);
+            this.logger.log(`  Signature:      ${formatFileSize(parsed.signature.length)}`);
+            if (!isUnsigned) {
+                const pkHash = crypto.createHash('sha256').update(parsed.publicKey).digest('hex');
+                this.logger.log(`  PubKey Hash:    ${pkHash.substring(0, 16)}...`);
+            }
+            this.logger.log('');
+            this.logger.log('Verification:');
+            this.logger.log(`  Checksum:       ${checksumValid ? 'VALID' : 'INVALID'}`);
+            if (isUnsigned) {
+                this.logger.log(`  Signature:      UNSIGNED`);
+            }
+            else if (signatureError) {
+                this.logger.log(`  Signature:      ERROR - ${signatureError}`);
+            }
+            else {
+                this.logger.log(`  Signature:      ${signatureValid ? 'VALID' : 'INVALID'}`);
+            }
+            this.logger.log('');
+            this.logger.log('─'.repeat(60));
+            if (isUnsigned) {
+                this.logger.warn('WARNING: This binary is unsigned and cannot be published.');
+                this.logger.warn('Use `opnet sign` to sign it.');
+            }
+            else if (isValid) {
+                this.logger.success('VERIFIED: Binary is valid and properly signed.');
+            }
+            else {
+                this.logger.fail('FAILED: Binary verification failed.');
+                if (!checksumValid) {
+                    this.logger.error('  - Checksum mismatch (binary may be corrupted)');
+                }
+                if (!signatureValid && !signatureError) {
+                    this.logger.error('  - Signature invalid (binary may be tampered)');
+                }
+            }
+            this.logger.log('');
+            if (options.verbose) {
+                this.logger.log('Sizes:');
+                this.logger.log(`  Metadata:       ${formatFileSize(parsed.rawMetadata.length)}`);
+                this.logger.log(`  Bytecode:       ${formatFileSize(parsed.bytecode.length)}`);
+                this.logger.log(`  Proto:          ${formatFileSize(parsed.proto?.length ?? 0)}`);
+                this.logger.log('');
+                this.logger.log('Checksums:');
+                this.logger.log(`  Stored:         ${parsed.checksum.toString('hex')}`);
+                this.logger.log('');
+                this.logger.log('Author:');
+                this.logger.log(`  Name:           ${parsed.metadata.author.name}`);
+                if (parsed.metadata.author.email) {
+                    this.logger.log(`  Email:          ${parsed.metadata.author.email}`);
+                }
+                this.logger.log('');
+                this.logger.log('Permissions:');
+                const perms = parsed.metadata.permissions;
+                if (perms) {
+                    this.logger.log(`  Database:       ${perms.database?.enabled ? 'Yes' : 'No'}`);
+                    this.logger.log(`  Block Hooks:    ${perms.blocks?.preProcess || perms.blocks?.postProcess || perms.blocks?.onChange ? 'Yes' : 'No'}`);
+                    this.logger.log(`  Epoch Hooks:    ${perms.epochs?.onChange || perms.epochs?.onFinalized ? 'Yes' : 'No'}`);
+                    this.logger.log(`  Mempool Feed:   ${perms.mempool?.txFeed ? 'Yes' : 'No'}`);
+                    this.logger.log(`  API Endpoints:  ${perms.api?.addEndpoints ? 'Yes' : 'No'}`);
+                    this.logger.log(`  Websocket:      ${perms.api?.addWebsocket ? 'Yes' : 'No'}`);
+                    this.logger.log(`  Filesystem:     ${perms.filesystem?.configDir || perms.filesystem?.tempDir ? 'Yes' : 'No'}`);
+                }
+                else {
+                    this.logger.log('  (none configured)');
+                }
+                this.logger.log('');
+            }
+            process.exit(isValid ? 0 : 1);
+        }
+        catch (error) {
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+export const verifyCommand = new VerifyCommand().getCommand();

package/build/commands/WhoamiCommand.d.ts

@@ -0,0 +1,7 @@
+import { BaseCommand } from './BaseCommand.js';
+export declare class WhoamiCommand extends BaseCommand {
+    constructor();
+    protected configure(): void;
+    private execute;
+}
+export declare const whoamiCommand: import("commander").Command;

package/build/commands/WhoamiCommand.js

@@ -0,0 +1,84 @@
+import { BaseCommand } from './BaseCommand.js';
+import { loadCredentials, hasCredentials, getCredentialSource, maskSensitive, } from '../lib/credentials.js';
+import { CLIWallet } from '../lib/wallet.js';
+export class WhoamiCommand extends BaseCommand {
+    constructor() {
+        super('whoami', 'Display current wallet identity and configuration');
+    }
+    configure() {
+        this.command
+            .option('-v, --verbose', 'Show detailed information')
+            .option('--public-key', 'Show full MLDSA public key')
+            .action((options) => this.execute(options));
+    }
+    execute(options) {
+        try {
+            if (!hasCredentials()) {
+                this.logger.warn('Not logged in.');
+                this.logger.info('Run `opnet login` to configure your wallet.');
+                return;
+            }
+            const credentials = loadCredentials();
+            if (!credentials) {
+                this.logger.warn('No credentials found.');
+                return;
+            }
+            const source = getCredentialSource();
+            this.logger.info('\nOPNet Identity\n');
+            this.logger.log('─'.repeat(50));
+            this.logger.log(`Network:        ${credentials.network}`);
+            this.logger.log(`MLDSA Level:    ${credentials.mldsaLevel}`);
+            this.logger.log(`Auth Source:    ${source}`);
+            try {
+                const wallet = CLIWallet.fromCredentials(credentials);
+                this.logger.log('');
+                this.logger.log(`P2TR Address:   ${wallet.p2trAddress}`);
+                this.logger.log(`MLDSA PubKey Hash: ${wallet.mldsaPublicKeyHash}`);
+                if (options.publicKey) {
+                    this.logger.log('');
+                    this.logger.log('MLDSA Public Key:');
+                    this.logger.log(wallet.mldsaPublicKey.toString('hex'));
+                }
+                if (options.verbose) {
+                    this.logger.log('');
+                    this.logger.log('─'.repeat(50));
+                    this.logger.log('Details:');
+                    this.logger.log(`  Security Level: MLDSA-${credentials.mldsaLevel}`);
+                    this.logger.log(`  Public Key Size: ${wallet.mldsaPublicKey.length} bytes`);
+                    if (credentials.mnemonic) {
+                        this.logger.log('  Auth Method: BIP-39 Mnemonic');
+                        this.logger.log(`  Mnemonic: ${maskSensitive(credentials.mnemonic, 8)}`);
+                    }
+                    else {
+                        this.logger.log('  Auth Method: WIF + MLDSA Keys');
+                        if (credentials.wif) {
+                            this.logger.log(`  WIF: ${maskSensitive(credentials.wif, 4)}`);
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                this.logger.log('');
+                this.logger.warn('Could not load wallet details.');
+                if (options.verbose) {
+                    this.logger.debug(`  Error: ${this.formatError(error)}`);
+                }
+                this.logger.log('');
+                if (credentials.mnemonic) {
+                    this.logger.log(`Auth Method:    BIP-39 Mnemonic`);
+                    if (options.verbose) {
+                        this.logger.log(`Mnemonic:       ${maskSensitive(credentials.mnemonic, 8)}`);
+                    }
+                }
+                else {
+                    this.logger.log(`Auth Method:    WIF + MLDSA Keys`);
+                }
+            }
+            this.logger.log('');
+        }
+        catch (error) {
+            this.exitWithError(this.formatError(error));
+        }
+    }
+}
+export const whoamiCommand = new WhoamiCommand().getCommand();

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/index.js

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { Logger } from '@btc-vision/logger';
+import { configCommand } from './commands/ConfigCommand.js';
+import { loginCommand } from './commands/LoginCommand.js';
+import { logoutCommand } from './commands/LogoutCommand.js';
+import { whoamiCommand } from './commands/WhoamiCommand.js';
+import { keygenCommand } from './commands/KeygenCommand.js';
+import { initCommand } from './commands/InitCommand.js';
+import { compileCommand } from './commands/CompileCommand.js';
+import { verifyCommand } from './commands/VerifyCommand.js';
+import { infoCommand } from './commands/InfoCommand.js';
+import { signCommand } from './commands/SignCommand.js';
+import { publishCommand } from './commands/PublishCommand.js';
+import { deprecateCommand } from './commands/DeprecateCommand.js';
+import { undeprecateCommand } from './commands/UndeprecateCommand.js';
+import { transferCommand } from './commands/TransferCommand.js';
+import { acceptCommand } from './commands/AcceptCommand.js';
+import { installCommand } from './commands/InstallCommand.js';
+import { updateCommand } from './commands/UpdateCommand.js';
+import { listCommand } from './commands/ListCommand.js';
+import { searchCommand } from './commands/SearchCommand.js';
+const logger = new Logger();
+const program = new Command();
+program
+    .name('opnet')
+    .description('OPNet CLI - Build, sign, and publish plugins for the OPNet ecosystem')
+    .version('1.0.0');
+program.addCommand(configCommand);
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(keygenCommand);
+program.addCommand(initCommand);
+program.addCommand(compileCommand);
+program.addCommand(verifyCommand);
+program.addCommand(infoCommand);
+program.addCommand(signCommand);
+program.addCommand(publishCommand);
+program.addCommand(deprecateCommand);
+program.addCommand(undeprecateCommand);
+program.addCommand(transferCommand);
+program.addCommand(acceptCommand);
+program.addCommand(installCommand);
+program.addCommand(updateCommand);
+program.addCommand(listCommand);
+program.addCommand(searchCommand);
+program.showHelpAfterError();
+program.showSuggestionAfterError();
+program.exitOverride((err) => {
+    if (err.code === 'commander.help') {
+        process.exit(0);
+    }
+    if (err.code === 'commander.version') {
+        process.exit(0);
+    }
+    logger.error(`Error: ${err.message}`);
+    process.exit(1);
+});
+program.parseAsync(process.argv).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.error(`Error: ${message}`);
+    process.exit(1);
+});

package/build/lib/PackageRegistry.abi.d.ts

@@ -0,0 +1,2 @@
+import { BitcoinInterfaceAbi } from 'opnet';
+export declare const PACKAGE_REGISTRY_ABI: BitcoinInterfaceAbi;

package/build/lib/PackageRegistry.abi.js

@@ -0,0 +1,356 @@
+import { ABIDataTypes } from '@btc-vision/transaction';
+import { BitcoinAbiTypes } from 'opnet';
+export const PACKAGE_REGISTRY_ABI = [
+    {
+        name: 'setTreasuryAddress',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'treasuryAddress', type: ABIDataTypes.STRING }],
+        outputs: [],
+    },
+    {
+        name: 'setScopePrice',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'priceSats', type: ABIDataTypes.UINT64 }],
+        outputs: [],
+    },
+    {
+        name: 'setPackagePrice',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'priceSats', type: ABIDataTypes.UINT64 }],
+        outputs: [],
+    },
+    {
+        name: 'registerScope',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'scopeName', type: ABIDataTypes.STRING }],
+        outputs: [],
+    },
+    {
+        name: 'initiateScopeTransfer',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'scopeName', type: ABIDataTypes.STRING },
+            { name: 'newOwner', type: ABIDataTypes.ADDRESS },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'acceptScopeTransfer',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'scopeName', type: ABIDataTypes.STRING }],
+        outputs: [],
+    },
+    {
+        name: 'cancelScopeTransfer',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'scopeName', type: ABIDataTypes.STRING }],
+        outputs: [],
+    },
+    {
+        name: 'registerPackage',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'packageName', type: ABIDataTypes.STRING }],
+        outputs: [],
+    },
+    {
+        name: 'publishVersion',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'packageName', type: ABIDataTypes.STRING },
+            { name: 'version', type: ABIDataTypes.STRING },
+            { name: 'ipfsCid', type: ABIDataTypes.STRING },
+            { name: 'checksum', type: ABIDataTypes.BYTES32 },
+            { name: 'signature', type: ABIDataTypes.BYTES },
+            { name: 'mldsaLevel', type: ABIDataTypes.UINT8 },
+            { name: 'opnetVersionRange', type: ABIDataTypes.STRING },
+            { name: 'pluginType', type: ABIDataTypes.UINT8 },
+            { name: 'permissionsHash', type: ABIDataTypes.BYTES32 },
+            { name: 'dependencies', type: ABIDataTypes.BYTES },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'deprecateVersion',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'packageName', type: ABIDataTypes.STRING },
+            { name: 'version', type: ABIDataTypes.STRING },
+            { name: 'reason', type: ABIDataTypes.STRING },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'undeprecateVersion',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'packageName', type: ABIDataTypes.STRING },
+            { name: 'version', type: ABIDataTypes.STRING },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'initiateTransfer',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'packageName', type: ABIDataTypes.STRING },
+            { name: 'newOwner', type: ABIDataTypes.ADDRESS },
+        ],
+        outputs: [],
+    },
+    {
+        name: 'acceptTransfer',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'packageName', type: ABIDataTypes.STRING }],
+        outputs: [],
+    },
+    {
+        name: 'cancelTransfer',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'packageName', type: ABIDataTypes.STRING }],
+        outputs: [],
+    },
+    {
+        name: 'getScope',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'scopeName', type: ABIDataTypes.STRING }],
+        outputs: [
+            { name: 'exists', type: ABIDataTypes.BOOL },
+            { name: 'owner', type: ABIDataTypes.ADDRESS },
+            { name: 'createdAt', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'getScopeOwner',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'scopeName', type: ABIDataTypes.STRING }],
+        outputs: [{ name: 'owner', type: ABIDataTypes.ADDRESS }],
+    },
+    {
+        name: 'getPackage',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'packageName', type: ABIDataTypes.STRING }],
+        outputs: [
+            { name: 'exists', type: ABIDataTypes.BOOL },
+            { name: 'owner', type: ABIDataTypes.ADDRESS },
+            { name: 'createdAt', type: ABIDataTypes.UINT64 },
+            { name: 'versionCount', type: ABIDataTypes.UINT256 },
+            { name: 'latestVersion', type: ABIDataTypes.STRING },
+        ],
+    },
+    {
+        name: 'getOwner',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'packageName', type: ABIDataTypes.STRING }],
+        outputs: [{ name: 'owner', type: ABIDataTypes.ADDRESS }],
+    },
+    {
+        name: 'getVersion',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'packageName', type: ABIDataTypes.STRING },
+            { name: 'version', type: ABIDataTypes.STRING },
+        ],
+        outputs: [
+            { name: 'exists', type: ABIDataTypes.BOOL },
+            { name: 'ipfsCid', type: ABIDataTypes.STRING },
+            { name: 'checksum', type: ABIDataTypes.BYTES32 },
+            { name: 'sigHash', type: ABIDataTypes.BYTES32 },
+            { name: 'mldsaLevel', type: ABIDataTypes.UINT8 },
+            { name: 'opnetVersionRange', type: ABIDataTypes.STRING },
+            { name: 'pluginType', type: ABIDataTypes.UINT8 },
+            { name: 'permissionsHash', type: ABIDataTypes.BYTES32 },
+            { name: 'depsHash', type: ABIDataTypes.BYTES32 },
+            { name: 'publisher', type: ABIDataTypes.ADDRESS },
+            { name: 'publishedAt', type: ABIDataTypes.UINT64 },
+            { name: 'deprecated', type: ABIDataTypes.BOOL },
+        ],
+    },
+    {
+        name: 'isDeprecated',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'packageName', type: ABIDataTypes.STRING },
+            { name: 'version', type: ABIDataTypes.STRING },
+        ],
+        outputs: [{ name: 'deprecated', type: ABIDataTypes.BOOL }],
+    },
+    {
+        name: 'isImmutable',
+        type: BitcoinAbiTypes.Function,
+        inputs: [
+            { name: 'packageName', type: ABIDataTypes.STRING },
+            { name: 'version', type: ABIDataTypes.STRING },
+        ],
+        outputs: [{ name: 'immutable', type: ABIDataTypes.BOOL }],
+    },
+    {
+        name: 'getPendingTransfer',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'packageName', type: ABIDataTypes.STRING }],
+        outputs: [
+            { name: 'pendingOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'initiatedAt', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'getPendingScopeTransfer',
+        type: BitcoinAbiTypes.Function,
+        inputs: [{ name: 'scopeName', type: ABIDataTypes.STRING }],
+        outputs: [
+            { name: 'pendingOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'initiatedAt', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'getTreasuryAddress',
+        type: BitcoinAbiTypes.Function,
+        inputs: [],
+        outputs: [{ name: 'treasuryAddress', type: ABIDataTypes.STRING }],
+    },
+    {
+        name: 'getScopePrice',
+        type: BitcoinAbiTypes.Function,
+        inputs: [],
+        outputs: [{ name: 'priceSats', type: ABIDataTypes.UINT64 }],
+    },
+    {
+        name: 'getPackagePrice',
+        type: BitcoinAbiTypes.Function,
+        inputs: [],
+        outputs: [{ name: 'priceSats', type: ABIDataTypes.UINT64 }],
+    },
+    {
+        name: 'TreasuryAddressChanged',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'previousAddressHash', type: ABIDataTypes.UINT256 },
+            { name: 'newAddressHash', type: ABIDataTypes.UINT256 },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'ScopePriceChanged',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'oldPrice', type: ABIDataTypes.UINT64 },
+            { name: 'newPrice', type: ABIDataTypes.UINT64 },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'PackagePriceChanged',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'oldPrice', type: ABIDataTypes.UINT64 },
+            { name: 'newPrice', type: ABIDataTypes.UINT64 },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'ScopeRegistered',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'scopeHash', type: ABIDataTypes.UINT256 },
+            { name: 'owner', type: ABIDataTypes.ADDRESS },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'ScopeTransferInitiated',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'scopeHash', type: ABIDataTypes.UINT256 },
+            { name: 'currentOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'newOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'ScopeTransferCompleted',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'scopeHash', type: ABIDataTypes.UINT256 },
+            { name: 'previousOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'newOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'ScopeTransferCancelled',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'scopeHash', type: ABIDataTypes.UINT256 },
+            { name: 'owner', type: ABIDataTypes.ADDRESS },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'PackageRegistered',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'packageHash', type: ABIDataTypes.UINT256 },
+            { name: 'owner', type: ABIDataTypes.ADDRESS },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'VersionPublished',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'packageHash', type: ABIDataTypes.UINT256 },
+            { name: 'versionHash', type: ABIDataTypes.UINT256 },
+            { name: 'publisher', type: ABIDataTypes.ADDRESS },
+            { name: 'checksum', type: ABIDataTypes.UINT256 },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+            { name: 'mldsaLevel', type: ABIDataTypes.UINT8 },
+            { name: 'pluginType', type: ABIDataTypes.UINT8 },
+        ],
+    },
+    {
+        name: 'VersionDeprecated',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'packageHash', type: ABIDataTypes.UINT256 },
+            { name: 'versionHash', type: ABIDataTypes.UINT256 },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'VersionUndeprecated',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'packageHash', type: ABIDataTypes.UINT256 },
+            { name: 'versionHash', type: ABIDataTypes.UINT256 },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'PackageTransferInitiated',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'packageHash', type: ABIDataTypes.UINT256 },
+            { name: 'currentOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'newOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'PackageTransferCompleted',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'packageHash', type: ABIDataTypes.UINT256 },
+            { name: 'previousOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'newOwner', type: ABIDataTypes.ADDRESS },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+    {
+        name: 'PackageTransferCancelled',
+        type: BitcoinAbiTypes.Event,
+        values: [
+            { name: 'packageHash', type: ABIDataTypes.UINT256 },
+            { name: 'owner', type: ABIDataTypes.ADDRESS },
+            { name: 'timestamp', type: ABIDataTypes.UINT64 },
+        ],
+    },
+];