@xpla/xpla/dist/signers/signature-processor.js

<p align="center"> <img src="https://user-images.githubusercontent.com/545047/188804067-28e67e5e-0214-4449-ab04-2e0c564a6885.svg" width="80"> </p>

import { resolveSignatureFormat } from "@interchainjs/auth";
import { BaseCryptoBytes } from "@interchainjs/utils";

//#region src/signers/signature-processor.ts
/**
* Utility functions that implement the BytesUtils functionality mentioned in requirements
* Defined first to avoid forward reference issues
*/
const BytesUtils = {
	splitSignature: (signature) => {
		if (signature.length === 64) return {
			r: signature.slice(0, 32),
			s: signature.slice(32, 64)
		};
		else if (signature.length === 65) return {
			r: signature.slice(0, 32),
			s: signature.slice(32, 64),
			recovery: signature[64]
		};
		else throw new Error(`Invalid signature length: ${signature.length}. Expected 64 or 65 bytes.`);
	},
	combineSignature: (r, s, recovery) => {
		if (r.length !== 32 || s.length !== 32) throw new Error("R and S components must be 32 bytes each");
		if (recovery !== void 0) {
			const signature = new Uint8Array(65);
			signature.set(r, 0);
			signature.set(s, 32);
			signature[64] = recovery;
			return signature;
		} else {
			const signature = new Uint8Array(64);
			signature.set(r, 0);
			signature.set(s, 32);
			return signature;
		}
	},
	arrayify: (data) => data,
	concat: (arrays) => {
		const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
		const result = new Uint8Array(totalLength);
		let offset = 0;
		for (const arr of arrays) {
			result.set(arr, offset);
			offset += arr.length;
		}
		return result;
	}
};
/**
* CosmosEvm signature format implementations using BytesUtils
* These implement the main branch EthSecp256k1Signature.toCompact() behavior
*/
const compactFormat = (signature) => {
	const splitSig = BytesUtils.splitSignature(signature);
	const result = BytesUtils.concat([splitSig.r, splitSig.s]);
	return BytesUtils.arrayify(result);
};
const fullFormat = (signature) => {
	if (signature.length === 64) throw new Error("Cannot create full signature format from compact signature without recovery information");
	return BytesUtils.arrayify(signature);
};
const rawFormat = (signature) => {
	return BytesUtils.arrayify(signature);
};
/**
* Preset CosmosEvm signature format functions mapping
* These implement the CosmosEvmSignatureFormat enum (COMPACT, FULL, RAW) mentioned in requirements
*/
const PRESET_COSMOS_EVM_SIGNATURE_FORMATS = {
	"compact": compactFormat,
	"full": fullFormat,
	"raw": rawFormat
};
/**
* Resolve CosmosEvm signature format function
* @param formatFn - Format function or string identifier
* @param defaultFn - Default format to use if formatFn is not provided
* @returns Resolved signature format function
*/
function resolveCosmosEvmSignatureFormat(formatFn, defaultFn) {
	if (!formatFn) {
		if (!defaultFn) return void 0;
		return resolveCosmosEvmSignatureFormat(defaultFn);
	}
	if (typeof formatFn === "string") {
		if (!PRESET_COSMOS_EVM_SIGNATURE_FORMATS[formatFn]) if (defaultFn) return resolveCosmosEvmSignatureFormat(defaultFn);
		else throw new Error(`Unknown CosmosEvm signature format: ${formatFn}`);
		return PRESET_COSMOS_EVM_SIGNATURE_FORMATS[formatFn];
	}
	return formatFn;
}
/**
* Utility class for processing CosmosEvm signatures
* Implements the configurable signature post-processing logic
* that was previously hardcoded in EthSecp256k1Signature.toCompact()
*/
var CosmosEvmSignatureProcessor = class {
	/**
	* Process a signature according to the specified format
	* @param signature - Raw signature bytes (typically 65 bytes with recovery)
	* @param format - Desired signature format (string or function)
	* @returns Processed signature bytes
	*/
	static processSignature(signature, format) {
		if (typeof format === "string" && PRESET_COSMOS_EVM_SIGNATURE_FORMATS[format]) {
			const cosmosEvmFormatFn = resolveCosmosEvmSignatureFormat(format, "compact");
			return cosmosEvmFormatFn ? cosmosEvmFormatFn(signature) : signature;
		}
		const formatFn = resolveSignatureFormat(format, "compact");
		return formatFn ? formatFn(signature) : signature;
	}
	/**
	* Convert signature to BaseCryptoBytes for use in workflows
	* @param signature - Signature bytes
	* @param format - Desired signature format
	* @returns BaseCryptoBytes instance
	*/
	static toBaseCryptoBytes(signature, format) {
		return new BaseCryptoBytes(this.processSignature(signature, format));
	}
};
/**
* Legacy compatibility class that implements the EthSecp256k1Signature interface
* This provides backward compatibility for code that expects the old toCompact() method
*/
var EthSecp256k1Signature = class {
	constructor(signature) {
		this.signature = signature;
	}
	/**
	* Convert signature to compact format
	* This method maintains backward compatibility with the original implementation
	* @returns Compact signature as BaseCryptoBytes (Key-like object)
	*/
	toCompact() {
		return CosmosEvmSignatureProcessor.toBaseCryptoBytes(this.signature, "compact");
	}
	/**
	* Convert signature to full format
	* @returns Full signature as BaseCryptoBytes
	*/
	toFull() {
		return CosmosEvmSignatureProcessor.toBaseCryptoBytes(this.signature, "full");
	}
	/**
	* Get raw signature
	* @returns Raw signature as BaseCryptoBytes
	*/
	toRaw() {
		return CosmosEvmSignatureProcessor.toBaseCryptoBytes(this.signature, "raw");
	}
	/**
	* Process signature with configurable format
	* @param format - Desired signature format
	* @returns Processed signature as BaseCryptoBytes
	*/
	process(format) {
		return CosmosEvmSignatureProcessor.toBaseCryptoBytes(this.signature, format);
	}
};

//#endregion
export { BytesUtils, CosmosEvmSignatureProcessor, EthSecp256k1Signature, PRESET_COSMOS_EVM_SIGNATURE_FORMATS, resolveCosmosEvmSignatureFormat };