@buildonspark/spark-sdk 0.0.8 → 0.0.9

package/dist/signer-DDkpXvNZ.d.cts

@@ -0,0 +1,154 @@
+import { N as Network$1, b as TreeNode } from './spark-BUTdOtMz.cjs';
+import { NetworkType } from '@buildonspark/lrc20-sdk';
+import * as btc from '@scure/btc-signer';
+import { networks } from 'bitcoinjs-lib';
+
+declare enum Network {
+    MAINNET = 0,
+    TESTNET = 1,
+    SIGNET = 2,
+    REGTEST = 3,
+    LOCAL = 4
+}
+declare const NetworkToProto: Record<Network, Network$1>;
+declare const getNetwork: (network: Network) => typeof btc.NETWORK;
+declare const LRC_WALLET_NETWORK: Readonly<{
+    0: networks.Network;
+    1: networks.Network;
+    2: networks.Network;
+    3: networks.Network;
+    4: networks.Network;
+}>;
+declare const LRC_WALLET_NETWORK_TYPE: Readonly<{
+    0: NetworkType.MAINNET;
+    1: NetworkType.TESTNET;
+    2: NetworkType.TESTNET;
+    3: NetworkType.REGTEST;
+    4: NetworkType.REGTEST;
+}>;
+
+type Polynomial = {
+    fieldModulus: bigint;
+    coefficients: bigint[];
+    proofs: Uint8Array[];
+};
+type SecretShare = {
+    fieldModulus: bigint;
+    threshold: number;
+    index: bigint;
+    share: bigint;
+};
+type VerifiableSecretShare = SecretShare & {
+    proofs: Uint8Array[];
+};
+declare function getRandomBigInt(max: bigint): bigint;
+declare function modInverse(a: bigint, m: bigint): bigint;
+declare function evaluatePolynomial(polynomial: Polynomial, x: bigint): bigint;
+declare function fieldDiv(numerator: bigint, denominator: bigint, fieldModulus: bigint): bigint;
+declare function computerLagrangeCoefficients(index: bigint, points: SecretShare[]): bigint;
+declare function generatePolynomialForSecretSharing(fieldModulus: bigint, secret: bigint, degree: number): Polynomial;
+declare function splitSecret(fieldModulus: bigint, secret: bigint, threshold: number, numberOfShares: number): SecretShare[];
+declare function splitSecretWithProofs(secret: bigint, fieldModulus: bigint, threshold: number, numberOfShares: number): VerifiableSecretShare[];
+declare function recoverSecret(shares: VerifiableSecretShare[]): bigint;
+declare function validateShare(share: VerifiableSecretShare): void;
+declare function bigIntToPrivateKey(value: bigint): Uint8Array;
+
+type SigningNonce = {
+    binding: Uint8Array;
+    hiding: Uint8Array;
+};
+type SigningCommitment = {
+    binding: Uint8Array;
+    hiding: Uint8Array;
+};
+type SignFrostParams = {
+    message: Uint8Array;
+    privateAsPubKey: Uint8Array;
+    publicKey: Uint8Array;
+    verifyingKey: Uint8Array;
+    selfCommitment: SigningCommitment;
+    statechainCommitments?: {
+        [key: string]: SigningCommitment;
+    } | undefined;
+    adaptorPubKey?: Uint8Array | undefined;
+};
+type AggregateFrostParams = Omit<SignFrostParams, "privateAsPubKey"> & {
+    selfSignature: Uint8Array;
+    statechainSignatures?: {
+        [key: string]: Uint8Array;
+    } | undefined;
+    statechainPublicKeys?: {
+        [key: string]: Uint8Array;
+    } | undefined;
+};
+type SplitSecretWithProofsParams = {
+    secret: Uint8Array;
+    curveOrder: bigint;
+    threshold: number;
+    numShares: number;
+    isSecretPubkey?: boolean;
+};
+interface SparkSigner {
+    getIdentityPublicKey(): Promise<Uint8Array>;
+    generateMnemonic(): Promise<string>;
+    createSparkWalletFromMnemonic(mnemonic: string, network: Network): Promise<string>;
+    createSparkWalletFromSeed(seed: Uint8Array | string, network: Network): Promise<string>;
+    restoreSigningKeysFromLeafs(leafs: TreeNode[]): Promise<void>;
+    getTrackedPublicKeys(): Promise<Uint8Array[]>;
+    generatePublicKey(hash?: Uint8Array): Promise<Uint8Array>;
+    removePublicKey(publicKey: Uint8Array): Promise<void>;
+    getSchnorrPublicKey(publicKey: Uint8Array): Promise<Uint8Array>;
+    signSchnorr(message: Uint8Array, publicKey: Uint8Array): Promise<Uint8Array>;
+    signSchnorrWithIdentityKey(message: Uint8Array): Promise<Uint8Array>;
+    subtractPrivateKeysGivenPublicKeys(first: Uint8Array, second: Uint8Array): Promise<Uint8Array>;
+    splitSecretWithProofs(params: SplitSecretWithProofsParams): Promise<VerifiableSecretShare[]>;
+    signFrost(params: SignFrostParams): Promise<Uint8Array>;
+    aggregateFrost(params: AggregateFrostParams): Promise<Uint8Array>;
+    signMessageWithPublicKey(message: Uint8Array, publicKey: Uint8Array, compact?: boolean): Promise<Uint8Array>;
+    signMessageWithIdentityKey(message: Uint8Array, compact?: boolean): Promise<Uint8Array>;
+    encryptLeafPrivateKeyEcies(receiverPublicKey: Uint8Array, publicKey: Uint8Array): Promise<Uint8Array>;
+    decryptEcies(ciphertext: Uint8Array): Promise<Uint8Array>;
+    getRandomSigningCommitment(): Promise<SigningCommitment>;
+    getSspIdentityPublicKey(network: Network): Promise<Uint8Array>;
+    hashRandomPrivateKey(): Promise<Uint8Array>;
+    generateAdaptorFromSignature(signature: Uint8Array): Promise<{
+        adaptorSignature: Uint8Array;
+        adaptorPublicKey: Uint8Array;
+    }>;
+    getDepositSigningKey(): Promise<Uint8Array>;
+}
+declare class DefaultSparkSigner implements SparkSigner {
+    private identityPrivateKey;
+    private publicKeyToPrivateKeyMap;
+    private commitmentToNonceMap;
+    private deriveSigningKey;
+    restoreSigningKeysFromLeafs(leafs: TreeNode[]): Promise<void>;
+    getSchnorrPublicKey(publicKey: Uint8Array): Promise<Uint8Array>;
+    signSchnorr(message: Uint8Array, publicKey: Uint8Array): Promise<Uint8Array>;
+    signSchnorrWithIdentityKey(message: Uint8Array): Promise<Uint8Array>;
+    getIdentityPublicKey(): Promise<Uint8Array>;
+    generateMnemonic(): Promise<string>;
+    createSparkWalletFromMnemonic(mnemonic: string, network: Network): Promise<string>;
+    getTrackedPublicKeys(): Promise<Uint8Array[]>;
+    generatePublicKey(hash?: Uint8Array): Promise<Uint8Array>;
+    removePublicKey(publicKey: Uint8Array): Promise<void>;
+    subtractPrivateKeysGivenPublicKeys(first: Uint8Array, second: Uint8Array): Promise<Uint8Array>;
+    splitSecretWithProofs({ secret, curveOrder, threshold, numShares, isSecretPubkey, }: SplitSecretWithProofsParams): Promise<VerifiableSecretShare[]>;
+    signFrost({ message, privateAsPubKey, publicKey, verifyingKey, selfCommitment, statechainCommitments, adaptorPubKey, }: SignFrostParams): Promise<Uint8Array>;
+    aggregateFrost({ message, publicKey, verifyingKey, selfCommitment, statechainCommitments, adaptorPubKey, selfSignature, statechainSignatures, statechainPublicKeys, }: AggregateFrostParams): Promise<Uint8Array>;
+    createSparkWalletFromSeed(seed: Uint8Array | string, network: Network): Promise<string>;
+    signMessageWithPublicKey(message: Uint8Array, publicKey: Uint8Array, compact?: boolean): Promise<Uint8Array>;
+    signMessageWithIdentityKey(message: Uint8Array, compact?: boolean): Promise<Uint8Array>;
+    encryptLeafPrivateKeyEcies(receiverPublicKey: Uint8Array, publicKey: Uint8Array): Promise<Uint8Array>;
+    decryptEcies(ciphertext: Uint8Array): Promise<Uint8Array>;
+    getRandomSigningCommitment(): Promise<SigningCommitment>;
+    getSspIdentityPublicKey(network: Network): Promise<Uint8Array>;
+    hashRandomPrivateKey(): Promise<Uint8Array>;
+    generateAdaptorFromSignature(signature: Uint8Array): Promise<{
+        adaptorSignature: Uint8Array;
+        adaptorPublicKey: Uint8Array;
+    }>;
+    getDepositSigningKey(): Promise<Uint8Array>;
+}
+
+export { type AggregateFrostParams as A, DefaultSparkSigner as D, LRC_WALLET_NETWORK as L, Network as N, type SparkSigner as S, type VerifiableSecretShare as V, type SigningNonce as a, type SigningCommitment as b, NetworkToProto as c, LRC_WALLET_NETWORK_TYPE as d, getRandomBigInt as e, evaluatePolynomial as f, getNetwork as g, fieldDiv as h, computerLagrangeCoefficients as i, generatePolynomialForSecretSharing as j, splitSecretWithProofs as k, bigIntToPrivateKey as l, modInverse as m, type SignFrostParams as n, type SplitSecretWithProofsParams as o, recoverSecret as r, splitSecret as s, validateShare as v };