@bitgo-beta/sdk-coin-flrp 1.0.1-beta.36 → 1.0.1-beta.361

package/dist/src/lib/transactionBuilderFactory.js

@@ -1,91 +1,148 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionBuilderFactory = exports.DelegatorTxBuilder = exports.ValidatorTxBuilder = exports.ImportTxBuilder = exports.ExportTxBuilder = void 0;
+exports.TransactionBuilderFactory = void 0;
+const flarejs_1 = require("@flarenetwork/flarejs");
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
-const atomicTransactionBuilder_1 = require("./atomicTransactionBuilder");
-// Placeholder builders - basic implementations for testing
-class ExportTxBuilder extends atomicTransactionBuilder_1.AtomicTransactionBuilder {
-    get transactionType() {
-        return sdk_core_1.TransactionType.Export;
+const ExportInPTxBuilder_1 = require("./ExportInPTxBuilder");
+const ImportInPTxBuilder_1 = require("./ImportInPTxBuilder");
+const ExportInCTxBuilder_1 = require("./ExportInCTxBuilder");
+const ImportInCTxBuilder_1 = require("./ImportInCTxBuilder");
+const utils_1 = __importDefault(require("./utils"));
+class TransactionBuilderFactory extends sdk_core_1.BaseTransactionBuilderFactory {
+    constructor(_coinConfig) {
+        super(_coinConfig);
     }
-    constructor(coinConfig) {
-        super(coinConfig);
-        // Don't throw error, allow placeholder functionality
-    }
-}
-exports.ExportTxBuilder = ExportTxBuilder;
-class ImportTxBuilder extends atomicTransactionBuilder_1.AtomicTransactionBuilder {
-    get transactionType() {
-        return sdk_core_1.TransactionType.Import;
+    /**
+     * Extract credentials from remaining bytes after transaction using FlareJS codec.
+     * This is the proper way to parse credentials - using the codec's UnpackPrefix method.
+     * @param credentialBytes Remaining bytes after the transaction (starts with numCredentials)
+     * @param codec The FlareJS codec to use for unpacking
+     * @returns Array of parsed credentials
+     */
+    extractCredentialsWithCodec(credentialBytes, codec) {
+        const credentials = [];
+        if (credentialBytes.length < 4) {
+            return credentials;
+        }
+        // Skip the first 4 bytes (numCredentials as Int type)
+        // The codec doesn't know about this Int, so we skip it manually
+        let remainingBytes = credentialBytes.slice(4);
+        let moreCredentials = true;
+        do {
+            try {
+                const [credential, rest] = codec.UnpackPrefix(remainingBytes);
+                credentials.push(credential);
+                remainingBytes = rest;
+            }
+            catch {
+                moreCredentials = false;
+            }
+        } while (remainingBytes.length > 0 && moreCredentials);
+        return credentials;
     }
-    constructor(coinConfig) {
-        super(coinConfig);
-        // Don't throw error, allow placeholder functionality
+    /**
+     * Parse a raw transaction buffer using the specified VM manager.
+     * @param rawBuffer The raw transaction buffer
+     * @param vmType The VM type to use for parsing ('EVM' or 'PVM')
+     * @returns Parsed transaction and credentials, or null if parsing fails
+     */
+    parseWithVM(rawBuffer, vmType) {
+        try {
+            const manager = flarejs_1.utils.getManagerForVM(vmType);
+            const [codec, txBytes] = manager.getCodecFromBuffer(rawBuffer);
+            const [tx, credentialBytes] = codec.UnpackPrefix(txBytes);
+            const credentials = credentialBytes.length > 4 ? this.extractCredentialsWithCodec(credentialBytes, codec) : [];
+            return { tx, credentials };
+        }
+        catch {
+            return null;
+        }
     }
-}
-exports.ImportTxBuilder = ImportTxBuilder;
-class ValidatorTxBuilder extends atomicTransactionBuilder_1.AtomicTransactionBuilder {
-    get transactionType() {
-        return sdk_core_1.TransactionType.AddValidator;
+    /**
+     * Create the appropriate transaction builder based on transaction type.
+     * @param tx The parsed transaction
+     * @param rawBuffer The raw transaction buffer
+     * @param credentials The extracted credentials
+     * @param isEVM Whether this is an EVM transaction
+     * @returns The appropriate transaction builder
+     */
+    createBuilder(tx, rawBuffer, credentials, isEVM) {
+        if (isEVM) {
+            if (ExportInCTxBuilder_1.ExportInCTxBuilder.verifyTxType(tx._type)) {
+                const builder = this.getExportInCBuilder();
+                builder.initBuilder(tx, rawBuffer, credentials);
+                return builder;
+            }
+            if (ImportInCTxBuilder_1.ImportInCTxBuilder.verifyTxType(tx._type)) {
+                const builder = this.getImportInCBuilder();
+                builder.initBuilder(tx, rawBuffer, credentials);
+                return builder;
+            }
+        }
+        else {
+            if (ImportInPTxBuilder_1.ImportInPTxBuilder.verifyTxType(tx._type)) {
+                const builder = this.getImportInPBuilder();
+                builder.initBuilder(tx, rawBuffer, credentials);
+                return builder;
+            }
+            if (ExportInPTxBuilder_1.ExportInPTxBuilder.verifyTxType(tx._type)) {
+                const builder = this.getExportInPBuilder();
+                builder.initBuilder(tx, rawBuffer, credentials);
+                return builder;
+            }
+        }
+        throw new sdk_core_1.NotSupported('Transaction type not supported');
     }
-    constructor(coinConfig) {
-        super(coinConfig);
-        // Don't throw error, allow placeholder functionality
+    /** @inheritdoc */
+    from(raw) {
+        utils_1.default.validateRawTransaction(raw);
+        const rawBuffer = Buffer.from(utils_1.default.removeHexPrefix(raw), 'hex');
+        // Try EVM first, then fall back to PVM
+        const evmResult = this.parseWithVM(rawBuffer, 'EVM');
+        if (evmResult) {
+            return this.createBuilder(evmResult.tx, rawBuffer, evmResult.credentials, true);
+        }
+        const pvmResult = this.parseWithVM(rawBuffer, 'PVM');
+        if (pvmResult) {
+            return this.createBuilder(pvmResult.tx, rawBuffer, pvmResult.credentials, false);
+        }
+        throw new sdk_core_1.NotSupported('Transaction type not supported');
     }
-}
-exports.ValidatorTxBuilder = ValidatorTxBuilder;
-class DelegatorTxBuilder extends atomicTransactionBuilder_1.AtomicTransactionBuilder {
-    get transactionType() {
-        return sdk_core_1.TransactionType.AddDelegator;
+    /** @inheritdoc */
+    getTransferBuilder() {
+        throw new sdk_core_1.NotSupported('Transfer is not supported in P Chain');
     }
-    constructor(coinConfig) {
-        super(coinConfig);
-        // Don't throw error, allow placeholder functionality
+    /**
+     * Export Cross chain transfer
+     */
+    getExportInPBuilder() {
+        return new ExportInPTxBuilder_1.ExportInPTxBuilder(this._coinConfig);
     }
-}
-exports.DelegatorTxBuilder = DelegatorTxBuilder;
-/**
- * Factory for Flare P-chain transaction builders
- */
-class TransactionBuilderFactory {
-    constructor(coinConfig) {
-        this._coinConfig = coinConfig;
+    /**
+     * Import Cross chain transfer
+     */
+    getImportInPBuilder() {
+        return new ImportInPTxBuilder_1.ImportInPTxBuilder(this._coinConfig);
     }
     /**
-     * Create a transaction builder from a hex string
-     * @param txHex - Transaction hex string
+     * Import in C chain Cross chain transfer
      */
-    from(txHex) {
-        // TODO: Parse the hex and determine transaction type, then return appropriate builder
-        // For now, return a basic export builder as that's the most common use case
-        if (!txHex) {
-            throw new Error('Transaction hex is required');
-        }
-        // Create a mock export builder for now
-        // In the future, this will parse the transaction and determine the correct type
-        const builder = new ExportTxBuilder(this._coinConfig);
-        // Initialize with the hex data (placeholder)
-        builder.initBuilder({ txHex });
-        return builder;
+    getImportInCBuilder() {
+        return new ImportInCTxBuilder_1.ImportInCTxBuilder(this._coinConfig);
     }
     /**
-     * Create a transaction builder for a specific type
-     * @param type - Transaction type
+     * Export in C chain Cross chain transfer
      */
-    getBuilder(type) {
-        switch (type) {
-            case sdk_core_1.TransactionType.Export:
-                return new ExportTxBuilder(this._coinConfig);
-            case sdk_core_1.TransactionType.Import:
-                return new ImportTxBuilder(this._coinConfig);
-            case sdk_core_1.TransactionType.AddValidator:
-                return new ValidatorTxBuilder(this._coinConfig);
-            case sdk_core_1.TransactionType.AddDelegator:
-                return new DelegatorTxBuilder(this._coinConfig);
-            default:
-                throw new sdk_core_1.NotImplementedError(`Transaction type ${type} not supported`);
-        }
+    getExportInCBuilder() {
+        return new ExportInCTxBuilder_1.ExportInCTxBuilder(this._coinConfig);
+    }
+    /** @inheritdoc */
+    getWalletInitializationBuilder() {
+        throw new sdk_core_1.NotSupported('Wallet initialization is not needed');
     }
 }
 exports.TransactionBuilderFactory = TransactionBuilderFactory;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilderFactory.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { utils as FlareUtils, evmSerial, pvmSerial, Credential } from '@flarenetwork/flarejs';\nimport { BaseTransactionBuilderFactory, NotSupported } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { TransactionBuilder } from './transactionBuilder';\nimport { ExportInPTxBuilder } from './ExportInPTxBuilder';\nimport { ImportInPTxBuilder } from './ImportInPTxBuilder';\nimport { ExportInCTxBuilder } from './ExportInCTxBuilder';\nimport { ImportInCTxBuilder } from './ImportInCTxBuilder';\nimport { SerializedTx } from './iface';\nimport utils from './utils';\n\ninterface Codec {\n  UnpackPrefix<T>(bytes: Uint8Array): [T, Uint8Array];\n}\n\nexport class TransactionBuilderFactory extends BaseTransactionBuilderFactory {\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /**\n   * Extract credentials from remaining bytes after transaction using FlareJS codec.\n   * This is the proper way to parse credentials - using the codec's UnpackPrefix method.\n   * @param credentialBytes Remaining bytes after the transaction (starts with numCredentials)\n   * @param codec The FlareJS codec to use for unpacking\n   * @returns Array of parsed credentials\n   */\n  private extractCredentialsWithCodec(credentialBytes: Uint8Array, codec: Codec): Credential[] {\n    const credentials: Credential[] = [];\n    if (credentialBytes.length < 4) {\n      return credentials;\n    }\n\n    // Skip the first 4 bytes (numCredentials as Int type)\n    // The codec doesn't know about this Int, so we skip it manually\n    let remainingBytes: Uint8Array = credentialBytes.slice(4);\n    let moreCredentials = true;\n\n    do {\n      try {\n        const [credential, rest] = codec.UnpackPrefix<Credential>(remainingBytes);\n        credentials.push(credential);\n        remainingBytes = rest;\n      } catch {\n        moreCredentials = false;\n      }\n    } while (remainingBytes.length > 0 && moreCredentials);\n\n    return credentials;\n  }\n\n  /**\n   * Parse a raw transaction buffer using the specified VM manager.\n   * @param rawBuffer The raw transaction buffer\n   * @param vmType The VM type to use for parsing ('EVM' or 'PVM')\n   * @returns Parsed transaction and credentials, or null if parsing fails\n   */\n  private parseWithVM(\n    rawBuffer: Buffer,\n    vmType: 'EVM' | 'PVM'\n  ): { tx: SerializedTx; credentials: Credential[] } | null {\n    try {\n      const manager = FlareUtils.getManagerForVM(vmType);\n      const [codec, txBytes] = manager.getCodecFromBuffer(rawBuffer);\n      const [tx, credentialBytes] = (codec as Codec).UnpackPrefix<SerializedTx>(txBytes);\n\n      const credentials =\n        credentialBytes.length > 4 ? this.extractCredentialsWithCodec(credentialBytes, codec as Codec) : [];\n\n      return { tx, credentials };\n    } catch {\n      return null;\n    }\n  }\n\n  /**\n   * Create the appropriate transaction builder based on transaction type.\n   * @param tx The parsed transaction\n   * @param rawBuffer The raw transaction buffer\n   * @param credentials The extracted credentials\n   * @param isEVM Whether this is an EVM transaction\n   * @returns The appropriate transaction builder\n   */\n  private createBuilder(\n    tx: SerializedTx,\n    rawBuffer: Buffer,\n    credentials: Credential[],\n    isEVM: boolean\n  ): TransactionBuilder {\n    if (isEVM) {\n      if (ExportInCTxBuilder.verifyTxType(tx._type)) {\n        const builder = this.getExportInCBuilder();\n        builder.initBuilder(tx as evmSerial.ExportTx, rawBuffer, credentials);\n        return builder;\n      }\n      if (ImportInCTxBuilder.verifyTxType(tx._type)) {\n        const builder = this.getImportInCBuilder();\n        builder.initBuilder(tx as evmSerial.ImportTx, rawBuffer, credentials);\n        return builder;\n      }\n    } else {\n      if (ImportInPTxBuilder.verifyTxType(tx._type)) {\n        const builder = this.getImportInPBuilder();\n        builder.initBuilder(tx as pvmSerial.ImportTx, rawBuffer, credentials);\n        return builder;\n      }\n      if (ExportInPTxBuilder.verifyTxType(tx._type)) {\n        const builder = this.getExportInPBuilder();\n        builder.initBuilder(tx as pvmSerial.ExportTx, rawBuffer, credentials);\n        return builder;\n      }\n    }\n    throw new NotSupported('Transaction type not supported');\n  }\n\n  /** @inheritdoc */\n  from(raw: string): TransactionBuilder {\n    utils.validateRawTransaction(raw);\n    const rawBuffer = Buffer.from(utils.removeHexPrefix(raw), 'hex');\n\n    // Try EVM first, then fall back to PVM\n    const evmResult = this.parseWithVM(rawBuffer, 'EVM');\n    if (evmResult) {\n      return this.createBuilder(evmResult.tx, rawBuffer, evmResult.credentials, true);\n    }\n\n    const pvmResult = this.parseWithVM(rawBuffer, 'PVM');\n    if (pvmResult) {\n      return this.createBuilder(pvmResult.tx, rawBuffer, pvmResult.credentials, false);\n    }\n\n    throw new NotSupported('Transaction type not supported');\n  }\n\n  /** @inheritdoc */\n  getTransferBuilder(): TransactionBuilder {\n    throw new NotSupported('Transfer is not supported in P Chain');\n  }\n\n  /**\n   * Export Cross chain transfer\n   */\n  getExportInPBuilder(): ExportInPTxBuilder {\n    return new ExportInPTxBuilder(this._coinConfig);\n  }\n\n  /**\n   * Import Cross chain transfer\n   */\n  getImportInPBuilder(): ImportInPTxBuilder {\n    return new ImportInPTxBuilder(this._coinConfig);\n  }\n\n  /**\n   * Import in C chain Cross chain transfer\n   */\n  getImportInCBuilder(): ImportInCTxBuilder {\n    return new ImportInCTxBuilder(this._coinConfig);\n  }\n\n  /**\n   * Export in C chain Cross chain transfer\n   */\n  getExportInCBuilder(): ExportInCTxBuilder {\n    return new ExportInCTxBuilder(this._coinConfig);\n  }\n\n  /** @inheritdoc */\n  getWalletInitializationBuilder(): TransactionBuilder {\n    throw new NotSupported('Wallet initialization is not needed');\n  }\n}\n"]}

package/dist/src/lib/utils.d.ts

@@ -1,214 +1,145 @@
-import { TransferableOutput } from '@flarenetwork/flarejs';
+import { Signature, TransferableOutput, Id } from '@flarenetwork/flarejs';
 import { BaseUtils, Entry } from '@bitgo-beta/sdk-core';
 import { FlareNetwork } from '@bitgo-beta/statics';
-import { DeprecatedOutput, DeprecatedTx, Output } from './iface';
+import { Buffer } from 'buffer';
+import { Output, Tx } from './iface';
 export declare class Utils implements BaseUtils {
+    isValidTransactionId(txId: string): boolean;
+    isValidSignature(signature: string): boolean;
+    /**
+     * Check if addresses in wallet match UTXO output addresses
+     */
     includeIn(walletAddresses: string[], otxoOutputAddresses: string[]): boolean;
     /**
-     * Checks if it is a valid address no illegal characters
-     *
-     * @param {string} address - address to be validated
-     * @returns {boolean} - the validation result
+     * Validates a Flare address or array of addresses
+     * @param {string | string[]} address - address(es) to validate
+     * @returns {boolean} - validation result
      */
-    /** @inheritdoc */
     isValidAddress(address: string | string[]): boolean;
     private isValidAddressRegex;
     /**
-     * Checks if it is a valid blockId with length 66 including 0x
-     *
-     * @param {string} hash - blockId to be validated
-     * @returns {boolean} - the validation result
+     * Validates a block ID
+     * @param {string} hash - block ID to validate
+     * @returns {boolean} - validation result
      */
-    /** @inheritdoc */
     isValidBlockId(hash: string): boolean;
     /**
-     * Checks if the string is a valid protocol public key or
-     * extended public key.
-     *
-     * @param {string} pub - the  public key to be validated
-     * @returns {boolean} - the validation result
+     * Validates a public key
+     * @param {string} pub - public key to validate
+     * @returns {boolean} - validation result
      */
     isValidPublicKey(pub: string): boolean;
-    parseAddress: (pub: string) => Buffer;
     /**
-     * Returns whether or not the string is a valid protocol private key, or extended
-     * private key.
-     *
-     * The protocol key format is described in the @stacks/transactions npm package, in the
-     * createStacksPrivateKey function:
-     * https://github.com/blockstack/stacks.js/blob/master/packages/transactions/src/keys.ts#L125
-     *
-     * @param {string} prv - the private key (or extended private key) to be validated
-     * @returns {boolean} - the validation result
+     * Validates a private key
+     * @param {string} prv - private key to validate
+     * @returns {boolean} - validation result
      */
     isValidPrivateKey(prv: string): boolean;
     /**
-     * Returns whether or not the string is a composed of hex chars only
-     *
-     * @param {string} maybe - the  string to be validated
-     * @returns {boolean} - the validation result
+     * Checks if a string contains only hex characters
      */
-    allHexChars(maybe: string): boolean;
+    allHexChars(str: string): boolean;
     /**
-     * Lightweight Ethereum address validation
-     * Validates that an address is a 40-character hex string (optionally prefixed with 0x)
-     *
-     * @param {string} address - the Ethereum address to validate
-     * @returns {boolean} - true if valid Ethereum address format
+     * Creates a signature using the Flare network parameters
+     * Returns a 65-byte signature (64 bytes signature + 1 byte recovery parameter)
      */
-    isValidEthereumAddress(address: string): boolean;
+    createSignature(network: FlareNetwork, message: Buffer, prv: Buffer): Buffer;
     /**
-     * Pick specific properties from an object (replaces lodash.pick)
-     *
-     * @param {T} obj - the source object
-     * @param {K[]} keys - array of property keys to pick
-     * @returns {Pick<T, K>} - new object with only the specified properties
+     * Verifies a signature
+     * @param messageHash - The SHA256 hash of the message (e.g., signablePayload)
+     * @param signature - The 64-byte signature (without recovery parameter)
+     * @param publicKey - The public key to verify against
+     * @returns true if signature is valid
      */
-    pick<T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;
+    verifySignature(messageHash: Buffer, signature: Buffer, publicKey: Buffer): boolean;
     /**
-     * Deep equality comparison (replaces lodash.isEqual)
-     *
-     * @param {unknown} a - first value to compare
-     * @param {unknown} b - second value to compare
-     * @returns {boolean} - true if values are deeply equal
+     * Creates a new signature object
      */
-    isEqual(a: unknown, b: unknown): boolean;
-    /** @inheritdoc */
-    isValidSignature(signature: string): boolean;
-    /** @inheritdoc */
-    isValidTransactionId(txId: string): boolean;
+    createNewSig(sigHex: string): Signature;
     /**
-     * FlareJS wrapper to create signature and return it for credentials
-     * @param network
-     * @param message
-     * @param prv
-     * @return signature
+     * Creates an empty signature with embedded address for signature slot identification.
+     * The address is embedded at position 90 (after the first 45 zero bytes).
+     * This allows the signing logic to determine which slot belongs to which address.
+     * @param addressHex The 20-byte address in hex format (40 chars, without 0x prefix)
      */
-    createSignature(network: FlareNetwork, message: Buffer, prv: Buffer): Buffer;
+    createEmptySigWithAddress(addressHex: string): Signature;
     /**
-     * FlareJS wrapper to verify signature
-     * @param network
-     * @param message
-     * @param signature
-     * @param publicKey - public key instead of private key for verification
-     * @return true if it's verify successful
+     * Extracts the embedded address from an empty signature.
+     * Returns the address hex string (40 chars) or empty string if not found.
      */
-    verifySignature(network: FlareNetwork, message: Buffer, signature: Buffer, publicKey: Buffer): boolean;
+    getAddressFromEmptySig(sig: string): string;
     /**
-     * FlareJS wrapper to recover signature
-     * @param network
-     * @param message
-     * @param signature
-     * @return recovered public key
+     * Computes SHA256 hash
      */
-    recoverySignature(network: FlareNetwork, message: Buffer, signature: Buffer): Buffer;
     sha256(buf: Uint8Array): Buffer;
     /**
-     * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
-     * It's to reuse in TransactionBuilder and TransactionBuilderFactory
-     *
-     * @param rawTransaction Transaction as hex string
+     * Validates raw transaction format
      */
     validateRawTransaction(rawTransaction: string): void;
     /**
-     * Check if tx is for the blockchainId
-     *
-     * @param {DeprecatedTx} tx
-     * @param {string} blockchainId
-     * @returns true if tx is for blockchainId
-     */
-    isTransactionOf(tx: DeprecatedTx, blockchainId: string): boolean;
-    /**
-     * Check if Output is from PVM.
-     * Output could be EVM or PVM output.
-     * @param {DeprecatedOutput} output
-     * @returns {boolean} output has transferable output structure
-     */
-    deprecatedIsTransferableOutput(output: DeprecatedOutput): boolean;
-    /**
-     * Check if Output is from PVM.
-     * Output could be EVM or PVM output.
-     * @param {Output} output
-     * @returns {boolean} output is TransferableOutput
+     * Checks if output is TransferableOutput type
      */
     isTransferableOutput(output: Output): output is TransferableOutput;
     /**
-     * Return a mapper function to that network address representation.
-     * @param network required to stringify addresses
-     * @return mapper function
-     */
-    deprecatedMapOutputToEntry(network: FlareNetwork): (output: DeprecatedOutput) => Entry;
-    /**
-     * Return a mapper function to that network address representation.
-     * @param network required to stringify addresses
-     * @return mapper function
+     * Maps outputs to entry format
      */
     mapOutputToEntry(network: FlareNetwork): (Output: any) => Entry;
     /**
-     * remove hex prefix (0x)
-     * @param hex string
-     * @returns hex without 0x
+     * Removes 0x prefix from hex string
      */
     removeHexPrefix(hex: string): string;
     /**
-     * Outputidx convert from number (as string) to buffer.
-     * @param {string} outputidx number
-     * @return {Buffer} buffer of size 4 with that number value
+     * Converts output index to buffer
      */
     outputidxNumberToBuffer(outputidx: string): Buffer;
     /**
-     * Outputidx buffer to number (as string)
-     * @param {Buffer} outputidx
-     * @return {string} outputidx number
+     * Converts output index buffer to number string
      */
     outputidxBufferToNumber(outputidx: Buffer): string;
     /**
-     * CB58 decode function - simple Base58 decode implementation
-     * @param {string} data - CB58 encoded string
-     * @returns {Buffer} decoded buffer
+     * Helper method to convert address components to string
+     */
+    addressToString: (hrp: string, prefix: string, address: Buffer) => string;
+    /**
+     * Decodes a base58 string with checksum to a Buffer
      */
-    cb58Decode(data: string): Buffer;
+    cb58Decode(str: string): Buffer;
     /**
-     * Convert address buffer to bech32 string
-     * @param {string} hrp - Human readable part
-     * @param {string} chainid - Chain identifier
-     * @param {Buffer} addressBuffer - Address buffer
-     * @returns {string} Address string
+     * Validates a checksum on a Buffer and returns true if valid, false if not
      */
-    addressToString(hrp: string, chainid: string, addressBuffer: Buffer): string;
+    private validateChecksum;
     /**
-     * Convert string to bytes for FlareJS memo
-     * Follows FlareJS utils.stringToBytes pattern
-     * @param {string} text - Text to convert
-     * @returns {Uint8Array} Byte array
+     * Encodes a Buffer as a base58 string with checksum
      */
-    stringToBytes(text: string): Uint8Array;
+    cb58Encode(bytes: Buffer): string;
     /**
-     * Convert bytes to string from FlareJS memo
-     * @param {Uint8Array} bytes - Bytes to convert
-     * @returns {string} Decoded string
+     * Adds a checksum to a Buffer and returns the concatenated result
+     * Uses last 4 bytes of SHA256 hash as checksum (matching avaxp behavior)
      */
-    bytesToString(bytes: Uint8Array): string;
+    addChecksum(buff: Buffer | Uint8Array): Uint8Array;
     /**
-     * Create memo bytes from various input formats
-     * Supports string, JSON object, or raw bytes
-     * @param {string | Record<string, unknown> | Uint8Array} memo - Memo data
-     * @returns {Uint8Array} Memo bytes for FlareJS
+     * Parse an address string into a Buffer
+     * @param address - The address to parse
+     * @returns Buffer containing the parsed address
      */
-    createMemoBytes(memo: string | Record<string, unknown> | Uint8Array): Uint8Array;
+    parseAddress: (address: string) => Buffer;
+    stringToAddress: (address: string, hrp?: string) => Buffer;
+    flareIdString(value: string): Id;
     /**
-     * Parse memo bytes to string
-     * @param {Uint8Array} memoBytes - Memo bytes from FlareJS transaction
-     * @returns {string} Decoded memo string
+     * Recover public key from signature
+     * @param messageHash - The SHA256 hash of the message (e.g., signablePayload)
+     * @param signature - 65-byte signature (64 bytes signature + 1 byte recovery parameter)
+     * @return recovered public key
      */
-    parseMemoBytes(memoBytes: Uint8Array): string;
+    recoverySignature(messageHash: Buffer, signature: Buffer): Buffer;
     /**
-     * Validate memo size (FlareJS has transaction size limits)
-     * @param {Uint8Array} memoBytes - Memo bytes
-     * @param {number} maxSize - Maximum size in bytes (default 4KB)
-     * @returns {boolean} Whether memo is within size limits
+     * Check if tx is for the blockchainId
+     *
+     * @param {Tx} tx
+     * @param {string} blockchainId - blockchain ID in hex format
+     * @returns true if tx is for blockchainId
      */
-    validateMemoSize(memoBytes: Uint8Array, maxSize?: number): boolean;
+    isTransactionOf(tx: Tx, blockchainId: string): boolean;
 }
 declare const utils: Utils;
 export default utils;

package/dist/src/lib/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAC3D,OAAO,EACL,SAAS,EACT,KAAK,EAMN,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGnD,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAcjE,qBAAa,KAAM,YAAW,SAAS;IAC9B,SAAS,CAAC,eAAe,EAAE,MAAM,EAAE,EAAE,mBAAmB,EAAE,MAAM,EAAE,GAAG,OAAO;IAInF;;;;;OAKG;IACH,kBAAkB;IAClB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,OAAO;IAYnD,OAAO,CAAC,mBAAmB;IAI3B;;;;;OAKG;IACH,kBAAkB;IAClB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAUrC;;;;;;OAMG;IACH,gBAAgB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAwC/B,YAAY,QAAS,MAAM,KAAG,MAAM,CAGzC;IAEF;;;;;;;;;;OAUG;IACH,iBAAiB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAiBvC;;;;;OAKG;IACH,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO;IAInC;;;;;;OAMG;IACH,sBAAsB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAYhD;;;;;;OAMG;IACH,IAAI,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,GAAG,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;IAUzD;;;;;;OAMG;IACH,OAAO,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,GAAG,OAAO;IAmCxC,kBAAkB;IAClB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI5C,kBAAkB;IAClB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI3C;;;;;;OAMG;IACH,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAU5E;;;;;;;OAOG;IACH,eAAe,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO;IAQtG;;;;;;OAMG;IACH,iBAAiB,CAAC,OAAO,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM;IAUpF,MAAM,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM;IAI/B;;;;;OAKG;IACH,sBAAsB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI;IASpD;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,GAAG,OAAO;IAahE;;;;;OAKG;IACH,8BAA8B,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO;IAIjE;;;;;OAKG;IACH,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,IAAI,kBAAkB;IAIlE;;;;OAIG;IACH,0BAA0B,CAAC,OAAO,EAAE,YAAY,GAAG,CAAC,MAAM,EAAE,gBAAgB,KAAK,KAAK;IA4BtF;;;;OAIG;IACH,gBAAgB,CAAC,OAAO,EAAE,YAAY,GAAG,CAAC,MAAM,KAAA,KAAK,KAAK;IAmB1D;;;;OAIG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAOpC;;;;OAIG;IACH,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIlD;;;;OAIG;IACH,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAIlD;;;;OAIG;IACH,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAWhC;;;;;;OAMG;IACH,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM;IAK5E;;;;;OAKG;IACH,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,UAAU;IAIvC;;;;OAIG;IACH,aAAa,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM;IAIxC;;;;;OAKG;IACH,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,UAAU,GAAG,UAAU;IAgBhF;;;;OAIG;IACH,cAAc,CAAC,SAAS,EAAE,UAAU,GAAG,MAAM;IAO7C;;;;;OAKG;IACH,gBAAgB,CAAC,SAAS,EAAE,UAAU,EAAE,OAAO,SAAO,GAAG,OAAO;CAGjE;AAED,QAAA,MAAM,KAAK,OAAc,CAAC;AAE1B,eAAe,KAAK,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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"}