@pact-toolbox/signers/dist/index.d.cts

import { Address, ReadonlyUint8Array, SignatureBytes } from "@pact-toolbox/crypto";
import { PactCommand, PartiallySignedTransaction, SignedTransaction, TransactionFullSig, TransactionSig } from "@pact-toolbox/types";

//#region src/types.d.ts
type SignatureDictionary = Readonly<Record<Address, SignatureBytes>>;
type BaseSignerConfig = Readonly<{
  abortSignal?: AbortSignal;
}>;
interface BaseTransactionSignerConfig extends BaseSignerConfig {}
//#endregion
//#region src/command-signer.d.ts
type PactCommandSignerConfig = BaseTransactionSignerConfig;
/** Defines a signer capable of signing transactions. */
type PactCommandSigner<TAddress extends string = string> = Readonly<{
  address: Address<TAddress>;
  signPactCommands(commands: PactCommand[]): Promise<PartiallySignedTransaction[]>;
}>;
/** Checks whether the provided value implements the {@link PactCommandSigner} interface. */
declare function isPactCommandSigner<TAddress extends string>(value: {
  [key: string]: unknown;
  address: Address<TAddress>;
}): value is PactCommandSigner<TAddress>;
/** Asserts that the provided value implements the {@link PactCommandSigner} interface. */
declare function assertIsPactCommandSigner<TAddress extends string>(value: {
  [key: string]: unknown;
  address: Address<TAddress>;
}): asserts value is PactCommandSigner<TAddress>;
// Function to sign a PactCommand
declare function partiallySignPactCommand(keyPairs: CryptoKeyPair[], command: PactCommand): Promise<PartiallySignedTransaction>;
declare function isTransactionFullSig(sig: TransactionSig): sig is TransactionFullSig;
declare function isFullySignedTransaction(transaction: unknown): transaction is SignedTransaction;
declare function finalizeTransaction(transaction: PartiallySignedTransaction): SignedTransaction;
//#endregion
//#region src/signable-message.d.ts
/** Defines a message that needs signing and its current set of signatures if any. */
type SignableMessage = Readonly<{
  content: Uint8Array;
  signatures: SignatureDictionary;
}>;
/**
* Creates a signable message from a provided content.
* If a string is provided, it will be UTF-8 encoded.
*/
declare function createSignableMessage(content: Uint8Array | string, signatures?: SignatureDictionary): SignableMessage;
//#endregion
//#region src/message-signer.d.ts
type MessageSignerConfig = BaseSignerConfig;
/** Defines a signer capable of signing messages. */
type MessageSigner<TAddress extends string = string> = Readonly<{
  address: Address<TAddress>;
  signMessages(messages: readonly SignableMessage[], config?: MessageSignerConfig): Promise<readonly SignatureDictionary[]>;
}>;
/** Checks whether the provided value implements the {@link MessageSigner} interface. */
declare function isMessageSigner<TAddress extends string>(value: {
  [key: string]: unknown;
  address: Address<TAddress>;
}): value is MessageSigner<TAddress>;
/** Asserts that the provided value implements the {@link MessageSigner} interface. */
declare function assertIsMessageSigner<TAddress extends string>(value: {
  [key: string]: unknown;
  address: Address<TAddress>;
}): asserts value is MessageSigner<TAddress>;
//#endregion
//#region src/keypair-signer.d.ts
/** Defines a signer capable of signing messages and transactions using a CryptoKeyPair. */
type KeyPairSigner<TAddress extends string = string> = MessageSigner<TAddress> & PactCommandSigner<TAddress> & {
  keyPair: CryptoKeyPair;
};
/** Checks whether the provided value implements the {@link KeyPairSigner} interface. */
declare function isKeyPairSigner<TAddress extends string>(value: {
  [key: string]: unknown;
  address: Address<TAddress>;
}): value is KeyPairSigner<TAddress>;
/** Asserts that the provided value implements the {@link KeyPairSigner} interface. */
declare function assertIsKeyPairSigner<TAddress extends string>(value: {
  [key: string]: unknown;
  address: Address<TAddress>;
}): asserts value is KeyPairSigner<TAddress>;
/** Creates a KeyPairSigner from the provided Crypto KeyPair. */
declare function createSignerFromKeyPair(keyPair: CryptoKeyPair): Promise<KeyPairSigner>;
/** Securely generates a signer capable of signing messages and transactions using a Crypto KeyPair. */
declare function generateKeyPairSigner(): Promise<KeyPairSigner>;
/** Creates a signer capable of signing messages and transactions using the 64 bytes of a KeyPair. */
declare function createKeyPairSignerFromBytes(bytes: ReadonlyUint8Array, extractable?: boolean): Promise<KeyPairSigner>;
/** Creates a signer capable of signing messages and transactions using the 32 bytes of a private key. */
declare function createKeyPairSignerFromPrivateKeyBytes(bytes: ReadonlyUint8Array, extractable?: boolean): Promise<KeyPairSigner>;
declare function createKeyPairSignerFromBase16PrivateKey(privateKey: string, extractable?: boolean): Promise<KeyPairSigner>;
//#endregion
//#region src/noop.d.ts
/** Defines a no-operation signer that pretends to partially sign messages and transactions. */
type NoopSigner<TAddress extends string = string> = MessageSigner<TAddress> & PactCommandSigner<TAddress>;
/** Creates a NoopSigner from the provided Address. */
declare function createNoopSigner(address: Address): NoopSigner;
//#endregion
export { BaseSignerConfig, BaseTransactionSignerConfig, KeyPairSigner, MessageSigner, MessageSignerConfig, NoopSigner, PactCommandSigner, PactCommandSignerConfig, SignableMessage, SignatureDictionary, assertIsKeyPairSigner, assertIsMessageSigner, assertIsPactCommandSigner, createKeyPairSignerFromBase16PrivateKey, createKeyPairSignerFromBytes, createKeyPairSignerFromPrivateKeyBytes, createNoopSigner, createSignableMessage, createSignerFromKeyPair, finalizeTransaction, generateKeyPairSigner, isFullySignedTransaction, isKeyPairSigner, isMessageSigner, isPactCommandSigner, isTransactionFullSig, partiallySignPactCommand };
//# sourceMappingURL=index.d.cts.map