@dorafactory/maci-sdk 0.1.3-pre.21 → 0.1.3-pre.23

package/dist/libs/account/crypto.d.ts

@@ -0,0 +1 @@
+export declare const generateMnemonic: (numberOfWords?: 12 | 24) => string;

package/dist/libs/account/index.d.ts

@@ -0,0 +1,35 @@
+import { EdDSAPoseidonKeypair, EdDSAPoseidonPublicKey } from '../keypairs/eddsa-poseidon';
+import type { AccountMangerParams, DerivePathParams } from 'src/types';
+export { generateMnemonic } from './crypto';
+export { getKeyPair } from './keypair';
+export declare class MaciAccount {
+    private mnemonic;
+    private secretKey;
+    currentKeypair: EdDSAPoseidonKeypair;
+    currentPubkey: EdDSAPoseidonPublicKey;
+    /**
+     * Support the following ways to init the SuiToolkit:
+     * 1. mnemonics
+     * 2. secretKey (base64 or hex)
+     * If none of them is provided, will generate a random mnemonics with 24 words.
+     *
+     * @param mnemonics, 12 or 24 mnemonics words, separated by space
+     * @param secretKey, base64 or hex string or Bech32 string, when mnemonics is provided, secretKey will be ignored
+     */
+    constructor({ mnemonic, secretKey }?: AccountMangerParams);
+    /**
+     * Check if the secretKey starts with bench32 format
+     */
+    parseSecretKey(secretKey: string | bigint): EdDSAPoseidonKeypair;
+    /**
+     * if derivePathParams is not provided or mnemonics is empty, it will return the currentKeyPair.
+     * else:
+     * it will generate keyPair from the mnemonic with the given derivePathParams.
+     */
+    getKeyPair(derivePathParams?: DerivePathParams): EdDSAPoseidonKeypair;
+    /**
+     * Switch the current account with the given derivePathParams.
+     * This is only useful when the mnemonic is provided. For secretKey mode, it will always use the same account.
+     */
+    switchAccount(derivePathParams: DerivePathParams): void;
+}

package/dist/libs/account/keypair.d.ts

@@ -0,0 +1,21 @@
+import type { DerivePathParams } from '../../types';
+import { EdDSAPoseidonKeypair } from '../keypairs/eddsa-poseidon';
+/**
+ * @description Get eddsaposeidon derive path for MACI
+ * @param derivePathParams
+ */
+export declare const getDerivePathForMACI: (derivePathParams?: DerivePathParams) => string;
+/**
+ * the format is m/44'/118'/accountIndex'/${isExternal ? 1 : 0}/addressIndex
+ *
+ * accountIndex is the index of the account, default is 0.
+ *
+ * isExternal is the type of the address, default is false. Usually, the external address is used to receive coins. The internal address is used to change coins.
+ *
+ * addressIndex is the index of the address, default is 0. It's used to generate multiple addresses for one account.
+ *
+ * @description Get keypair from mnemonics and derive path
+ * @param mnemonics
+ * @param derivePathParams
+ */
+export declare const getKeyPair: (mnemonics: string, derivePathParams?: DerivePathParams) => EdDSAPoseidonKeypair;

package/dist/libs/account/util.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @description This regular expression matches any string that contains only hexadecimal digits (0-9, A-F, a-f).
+ * @param str
+ */
+export declare const isHex: (str: string) => boolean;
+/**
+ * @description This regular expression matches any string that contains only base64 digits (0-9, A-Z, a-z, +, /, =).
+ * Note that the "=" signs at the end are optional padding characters that may be present in some base64 encoded strings.
+ * @param str
+ */
+export declare const isBase64: (str: string) => boolean;
+/**
+ * Convert a hex string to Uint8Array
+ * @param hexStr
+ */
+export declare const fromHEX: (hexStr: string) => Uint8Array;
+/**
+ * normalize a private key
+ * A private key is a 32-byte array.
+ * But there are two different formats for private keys:
+ * 1. A 32-byte array
+ * 2. A 64-byte array with the first 32 bytes being the private key and the last 32 bytes being the public key
+ * 3. A 33-byte array with the first byte being 0x00 (sui.keystore key is a Base64 string with scheme flag 0x00 at the beginning)
+ */
+export declare const normalizePrivateKey: (key: Uint8Array) => Uint8Array;

package/dist/libs/api/client.d.ts

@@ -0,0 +1,173 @@
+import type { paths, operations } from './types';
+/**
+ * MACI API Client configuration
+ */
+export interface MaciApiClientConfig {
+    /** API base URL */
+    baseUrl: string;
+    /** API key for authentication */
+    apiKey?: string;
+    /** Custom fetch function (optional) */
+    customFetch?: typeof fetch;
+    /** Default request timeout in milliseconds */
+    timeout?: number;
+    /**
+     * API key header type
+     * - 'x-api-key': Use x-api-key header (default)
+     * - 'bearer': Use Authorization: Bearer header
+     */
+    apiKeyHeader?: 'x-api-key' | 'bearer';
+}
+/**
+ * Extract request body type from operation
+ */
+type RequestBody<T> = T extends {
+    requestBody: {
+        content: {
+            'application/json': infer U;
+        };
+    };
+} ? U : T extends {
+    requestBody?: {
+        content: {
+            'application/json': infer U;
+        };
+    };
+} ? U : never;
+/**
+ * Extract response type from operation
+ */
+type ResponseBody<T, Status extends number = 200> = T extends {
+    responses: {
+        [K in Status]: {
+            content: {
+                'application/json': infer U;
+            };
+        };
+    };
+} ? U : never;
+/**
+ * Extract query parameters from operation
+ */
+type QueryParams<T> = T extends {
+    parameters: {
+        query?: infer U;
+    };
+} ? U : never;
+/**
+ * Extract path parameters from operation
+ */
+type PathParams<T> = T extends {
+    parameters: {
+        path: infer U;
+    };
+} ? U : never;
+/**
+ * MACI API Client
+ * Provides type-safe MACI API call wrapper
+ */
+export declare class MaciApiClient {
+    private baseUrl;
+    private apiKey?;
+    private customFetch;
+    private timeout;
+    private apiKeyHeader;
+    constructor(config: MaciApiClientConfig);
+    /**
+     * Update API key
+     */
+    setApiKey(apiKey: string): void;
+    /**
+     * Update base URL
+     */
+    setBaseUrl(baseUrl: string): void;
+    /**
+     * Internal fetch method with timeout and error handling
+     */
+    private fetch;
+    /**
+     * Health check
+     */
+    health(): Promise<ResponseBody<paths['/health']['get'], 200>>;
+    /**
+     * Create API key (Admin)
+     */
+    createApiKey(data: RequestBody<paths['/admin/keys']['post']>): Promise<ResponseBody<paths['/admin/keys']['post'], 200>>;
+    /**
+     * Create tenant (Admin)
+     */
+    createTenant(data: RequestBody<paths['/admin/tenants']['post']>): Promise<ResponseBody<paths['/admin/tenants']['post'], 201>>;
+    /**
+     * Get usage for current API key
+     */
+    getUsage(params?: QueryParams<paths['/v1/usage']['get']>): Promise<ResponseBody<paths['/v1/usage']['get'], 200>>;
+    /**
+     * Signup
+     */
+    signup(data: RequestBody<operations['signup']>): Promise<ResponseBody<operations['signup'], 202>>;
+    /**
+     * Vote
+     */
+    vote(data: RequestBody<operations['vote']>): Promise<ResponseBody<operations['vote'], 202>>;
+    /**
+     * Create Round
+     */
+    createRound(data: RequestBody<operations['createRound']>): Promise<ResponseBody<operations['createRound'], 202>>;
+    /**
+     * Create AMaci Round
+     */
+    createAmaciRound(data: RequestBody<operations['createAmaciRound']>): Promise<ResponseBody<operations['createAmaciRound'], 202>>;
+    /**
+     * Set Round Info
+     */
+    setRoundInfo(data: RequestBody<operations['setRoundInfo']>): Promise<ResponseBody<operations['setRoundInfo'], 202>>;
+    /**
+     * Set Vote Options
+     */
+    setVoteOptions(data: RequestBody<operations['setVoteOptions']>): Promise<ResponseBody<operations['setVoteOptions'], 202>>;
+    /**
+     * Deactivate
+     */
+    deactivate(data: RequestBody<operations['deactivate']>): Promise<ResponseBody<operations['deactivate'], 202>>;
+    /**
+     * Add New Key
+     */
+    addNewKey(data: RequestBody<operations['addNewKey']>): Promise<ResponseBody<operations['addNewKey'], 202>>;
+    /**
+     * Pre Add New Key
+     */
+    preAddNewKey(data: RequestBody<operations['preAddNewKey']>): Promise<ResponseBody<operations['preAddNewKey'], 202>>;
+    /**
+     * Get allowlist list
+     */
+    getAllowlists(params?: QueryParams<operations['getAllowlists']>): Promise<ResponseBody<operations['getAllowlists'], 200>>;
+    /**
+     * Create allowlist
+     */
+    createAllowlist(data: RequestBody<operations['createAllowlist']>): Promise<ResponseBody<operations['createAllowlist'], 201>>;
+    /**
+     * Get allowlist details
+     */
+    getAllowlistDetail(params: PathParams<operations['getAllowlistDetail']>): Promise<ResponseBody<operations['getAllowlistDetail'], 200>>;
+    /**
+     * Update allowlist
+     */
+    updateAllowlist(params: PathParams<operations['updateAllowlist']>, data: RequestBody<operations['updateAllowlist']>): Promise<ResponseBody<operations['updateAllowlist'], 200>>;
+    /**
+     * Delete allowlist
+     */
+    deleteAllowlist(params: PathParams<operations['deleteAllowlist']>): Promise<ResponseBody<operations['deleteAllowlist'], 204>>;
+    /**
+     * Get round allowlist snapshot
+     */
+    getRoundAllowlistSnapshot(params: PathParams<operations['getRoundAllowlistSnapshot']>): Promise<ResponseBody<operations['getRoundAllowlistSnapshot'], 200>>;
+    /**
+     * Request certificate
+     */
+    requestCertificate(data: RequestBody<paths['/v1/certificates/request']['post']>): Promise<ResponseBody<paths['/v1/certificates/request']['post'], 200>>;
+    /**
+     * Get pre-deactivate data by contract address
+     */
+    getPreDeactivate(params: PathParams<paths['/v1/pre-deactivate/{contractAddress}']['get']>): Promise<ResponseBody<paths['/v1/pre-deactivate/{contractAddress}']['get'], 200>>;
+}
+export {};

package/dist/libs/api/index.d.ts

@@ -0,0 +1,3 @@
+export { MaciApiClient } from './client';
+export type { MaciApiClientConfig } from './client';
+export type { paths, operations, components } from './types';

package/dist/libs/const.d.ts

@@ -107,6 +107,7 @@ export interface NetworkConfig {
     rpcEndpoint: string;
     restEndpoint: string;
     apiEndpoint: string;
+    saasApiEndpoint: string;
     certificateApiEndpoint: string;
     registryAddress: string;
     saasAddress: string;

package/dist/libs/crypto/adapter.d.ts

@@ -0,0 +1,6 @@
+import { Groth16Proof } from 'snarkjs';
+export declare const adaptToUncompressed: (proof: Groth16Proof) => Promise<{
+    a: string;
+    b: string;
+    c: string;
+}>;

package/dist/libs/crypto/curve.d.ts

@@ -0,0 +1,3 @@
+export declare function getCurveFromR(r: bigint): Promise<any>;
+export declare function getCurveFromQ(q: bigint): Promise<any>;
+export declare function getCurveFromName(name: string): Promise<any>;

package/dist/libs/crypto/index.d.ts

@@ -6,4 +6,7 @@ export * from './sign';
 export * from './types';
 export * from './tree';
 export * from './babyjub';
+export * from './curve';
+export * from './adapter';
+export * from './rerandomize';
 export type { Keypair, PubKey, PrivKey } from './types';

package/dist/libs/crypto/keys.d.ts

@@ -53,7 +53,14 @@ export declare const batchGenMessage: (stateIdx: number, keypair: Keypair, coord
     encPubkeys: PubKey<bigint>;
 }[];
 export declare const privateKeyFromTxt: (txt: string) => Keypair | undefined;
-export declare const genAddKeyInput: (depth: number, { coordPubKey, oldKey, deactivates, }: {
+export declare const rerandomize: (pubKey: bigint[], ciphertext: {
+    c1: bigint[];
+    c2: bigint[];
+}, randomVal?: bigint) => {
+    d1: bigint[];
+    d2: bigint[];
+};
+export declare const genAddKeyInput: (depth: number, { coordPubKey, oldKey, deactivates }: {
     coordPubKey: PubKey;
     oldKey: Keypair;
     deactivates: bigint[][];

package/dist/libs/crypto/rerandomize.d.ts

@@ -0,0 +1,12 @@
+import { PubKey } from './types';
+export declare const encryptOdevity: (isOdd: boolean, pubKey: PubKey, randomVal?: bigint) => {
+    c1: {
+        x: bigint;
+        y: bigint;
+    };
+    c2: {
+        x: bigint;
+        y: bigint;
+    };
+    xIncrement: any;
+};

package/dist/libs/crypto/sign.d.ts

@@ -2,7 +2,7 @@ import { OfflineSigner } from '@cosmjs/proto-signing';
 import { SignResult } from './types';
 export declare function signMessage(signer: OfflineSigner, address: string, message: string, network: 'mainnet' | 'testnet'): Promise<SignResult>;
 export declare function genKeypairFromSignature(signature: string): Promise<import("./types").Keypair>;
-export declare function genKeypairFromSign({ signer, address, network, }: {
+export declare function genKeypairFromSign({ signer, address, network }: {
     signer: OfflineSigner;
     address?: string;
     network: 'mainnet' | 'testnet';

package/dist/libs/cryptography/keypair.d.ts

@@ -0,0 +1,30 @@
+import { Signature } from '@zk-kit/eddsa-poseidon';
+import type { PublicKey } from './publickey';
+import type { SignatureScheme } from './signature-scheme';
+import { BigNumberish } from '@zk-kit/utils';
+export interface SignatureWithBytes {
+    message: BigNumberish;
+    signature: Signature<bigint>;
+}
+export declare abstract class Signer {
+    abstract sign(message: BigNumberish): Signature<bigint>;
+    /**
+     * Sign messages with a specific payload. By combining the message bytes with the payload before hashing and signing,
+     * it ensures that a signed message is tied to a specific purpose and domain separator is provided
+     */
+    signWithPayload(message: BigNumberish): Promise<SignatureWithBytes>;
+    /**
+     * Get the key scheme of the keypair: Secp256k1 or ED25519
+     */
+    abstract getKeyScheme(): SignatureScheme;
+    /**
+     * The public key for this keypair
+     */
+    abstract getPublicKey(): PublicKey;
+}
+export declare abstract class Keypair extends Signer {
+    /**
+     * This returns the Bech32 secret key string for this keypair.
+     */
+    abstract getSecretKey(): string;
+}

package/dist/libs/cryptography/mnemonics.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Parse and validate a path that is compliant to SLIP-0010 in form m/44'/118'/{account_index}'/{change_index}'/{address_index}'.
+ *
+ * @param path path string (e.g. `m/44'/118'/0'/0'/0'`).
+ */
+export declare function isValidHardenedPath(path: string): boolean;
+/**
+ * Parse and validate a path that is compliant to BIP-32 in form m/54'/784'/{account_index}'/{change_index}/{address_index}
+ * for Secp256k1 and m/74'/784'/{account_index}'/{change_index}/{address_index} for Secp256r1.
+ *
+ * Note that the purpose for Secp256k1 is registered as 54, to differentiate from Ed25519 with purpose 44.
+ *
+ * @param path path string (e.g. `m/54'/118'/0'/0/0`).
+ */
+export declare function isValidBIP32Path(path: string): boolean;
+/**
+ * Uses KDF to derive 64 bytes of key data from mnemonic with empty password.
+ *
+ * @param mnemonics 12 words string split by spaces.
+ */
+export declare function mnemonicToSeed(mnemonics: string): Uint8Array;
+/**
+ * Derive the seed in hex format from a 12-word mnemonic string.
+ *
+ * @param mnemonics 12 words string split by spaces.
+ */
+export declare function mnemonicToSeedHex(mnemonics: string): string;

package/dist/libs/cryptography/publickey.d.ts

@@ -0,0 +1,23 @@
+import { Signature } from '@zk-kit/eddsa-poseidon';
+/**
+ * Value to be converted into public key.
+ */
+export type PublicKeyInitData = string | Uint8Array | Iterable<number>;
+export declare function bytesEqual(a: Uint8Array, b: Uint8Array): boolean;
+/**
+ * A public key
+ */
+export declare abstract class PublicKey {
+    /**
+     * Checks if two public keys are equal
+     */
+    equals(publicKey: PublicKey): boolean;
+    /**
+     * Converts the public key to a packed data format
+     */
+    abstract toPackedData(): bigint;
+    /**
+     * Verifies that the signature is valid for for the provided message
+     */
+    abstract verify(data: Uint8Array, signature: Signature): boolean;
+}

package/dist/libs/cryptography/signature-scheme.d.ts

@@ -0,0 +1 @@
+export type SignatureScheme = 'EDDSA_POSEIDON';

package/dist/libs/index.d.ts

@@ -5,3 +5,4 @@ export * from './contract';
 export * from './oracle-certificate';
 export * from './maci';
 export * from './crypto';
+export * from './api';

package/dist/libs/keypairs/eddsa-poseidon/index.d.ts

@@ -0,0 +1,2 @@
+export { DEFAULT_EDDSA_POSEIDON_DERIVATION_PATH, EdDSAPoseidonKeypair, type EdDSAPoseidonKeypairData, } from './keypair';
+export { EdDSAPoseidonPublicKey } from './publickey';

package/dist/libs/keypairs/eddsa-poseidon/keypair.d.ts

@@ -0,0 +1,187 @@
+/**
+ * @file EdDSA-Poseidon Keypair Implementation
+ * @description This module provides a complete implementation of EdDSA-Poseidon keypairs
+ * for use in zero-knowledge proof systems and MACI (Minimal Anti-Collusion Infrastructure).
+ *
+ * The EdDSA-Poseidon signature scheme combines:
+ * - Edwards-curve Digital Signature Algorithm (EdDSA) for efficient elliptic curve cryptography
+ * - Poseidon hash function for ZK-SNARK friendly hashing
+ * - BIP-32 hierarchical deterministic key derivation
+ * - Support for both JSON payload signing and ZK-optimized credential signing
+ *
+ * Key features:
+ * - Random keypair generation
+ * - Keypair derivation from mnemonic phrases
+ * - Keypair reconstruction from secret keys
+ * - Multiple signing methods for different use cases
+ * - Comprehensive input validation and error handling
+ *
+ * @author MACI Team
+ * @version 1.0.0
+ */
+import { Keypair } from '../../cryptography/keypair';
+import type { SignatureScheme } from '../../cryptography/signature-scheme';
+import { EdDSAPoseidonPublicKey } from './publickey';
+import { EcdhSharedKey, PubKey, Tree } from '../../crypto';
+import { BigNumberish } from '@zk-kit/utils';
+export declare const DEFAULT_EDDSA_POSEIDON_DERIVATION_PATH = "m/44'/118'/0'/0/0";
+/**
+ * Interface defining the structure of EdDSA-Poseidon keypair data
+ * Contains both the public and secret key components as bigint values
+ */
+export interface EdDSAPoseidonKeypairData {
+    /** The public key component as a bigint */
+    publicKey: bigint;
+    /** The secret key component as a bigint */
+    secretKey: bigint;
+    formatedPrivKey: bigint;
+}
+/**
+ * EdDSA-Poseidon Keypair implementation for zero-knowledge proof systems
+ *
+ * This class implements the Edwards-curve Digital Signature Algorithm (EdDSA)
+ * using the Poseidon hash function, which is optimized for zero-knowledge circuits.
+ * It extends the base Keypair class and provides methods for key generation,
+ * signing, and cryptographic operations suitable for MACI (Minimal Anti-Collusion Infrastructure).
+ */
+export declare class EdDSAPoseidonKeypair extends Keypair {
+    /** Private storage for the keypair data */
+    private keypair;
+    /**
+     * Create a new EdDSA-Poseidon keypair instance.
+     *
+     * If no keypair data is provided, a new random keypair will be generated
+     * using cryptographically secure random number generation.
+     *
+     * @param keypair Optional existing EdDSA-Poseidon keypair data to initialize with
+     */
+    constructor(keypair?: EdDSAPoseidonKeypairData);
+    /**
+     * Get the signature scheme identifier for this keypair.
+     *
+     * @returns The signature scheme type 'EDDSA_POSEIDON'
+     */
+    getKeyScheme(): SignatureScheme;
+    /**
+     * Generate a new random EdDSA-Poseidon keypair.
+     *
+     * This is a convenience static method that creates a new instance
+     * with randomly generated cryptographic keys.
+     *
+     * @returns A new EdDSAPoseidonKeypair instance with random keys
+     */
+    static generate(): EdDSAPoseidonKeypair;
+    /**
+     * Create a keypair from an existing secret key.
+     *
+     * This method reconstructs a keypair from a previously generated secret key.
+     * The secret key can be provided as either a hex string (with or without '0x' prefix)
+     * or as a bigint value. For generating keypairs from mnemonic seeds, use the
+     * {@link EdDSAPoseidonKeypair.deriveKeypair} method instead.
+     *
+     * @param secretKey The secret key as a hex string or bigint
+     * @param options Configuration options for key reconstruction
+     * @param options.skipValidation If true, skips cryptographic validation of the secret key
+     *
+     * @returns A new EdDSAPoseidonKeypair instance created from the secret key
+     * @throws Error if the provided secret key is invalid and validation is not skipped
+     */
+    static fromSecretKey(secretKey: string | bigint, options?: {
+        skipValidation?: boolean;
+    }): EdDSAPoseidonKeypair;
+    /**
+     * Get the public key associated with this keypair.
+     *
+     * @returns An EdDSAPoseidonPublicKey instance containing the public key data
+     */
+    getPublicKey(): EdDSAPoseidonPublicKey;
+    /**
+     * Get the secret key as a hexadecimal string.
+     *
+     * Returns the secret key component of this keypair encoded as a hex string.
+     * This can be used to serialize the secret key for storage or transmission.
+     *
+     * @returns The secret key encoded as a hexadecimal string
+     */
+    getSecretKey(): string;
+    getFormatedPrivKey(): bigint;
+    /**
+     * Sign a message using this keypair's secret key.
+     *
+     * Creates a cryptographic signature for the provided message using the
+     * EdDSA-Poseidon signature algorithm. The signature can later be verified
+     * using the corresponding public key.
+     *
+     * @param message The message to sign (as BigNumberish - can be bigint, string, or number)
+     * @returns The cryptographic signature of the message
+     */
+    sign(message: BigNumberish): import("@zk-kit/eddsa-poseidon").Signature<bigint>;
+    /**
+     * Derive an EdDSA-Poseidon keypair from a mnemonic phrase and derivation path.
+     *
+     * This method implements hierarchical deterministic (HD) key derivation following
+     * the BIP-32 standard. The mnemonic phrase must be normalized and validated against
+     * the English wordlist before use.
+     *
+     * @param mnemonics The mnemonic phrase (12, 15, 18, 21, or 24 words)
+     * @param path Optional BIP-32 derivation path. If not provided, uses the default path.
+     *             Must be in the form m/44'/118'/{account_index}'/{change_index}/{address_index}
+     *
+     * @returns A new EdDSAPoseidonKeypair derived from the mnemonic and path
+     * @throws Error if the derivation path is invalid or key derivation fails
+     */
+    static deriveKeypair(mnemonics: string, path?: string): EdDSAPoseidonKeypair;
+    /**
+     * Sign a payload containing contract address and amount information.
+     *
+     * This method creates a structured payload with the contract address, amount,
+     * and public key coordinates, then generates a cryptographic signature over
+     * the JSON-serialized payload using SHA-256 hashing.
+     *
+     * The resulting signature can be used as a certificate or proof of authorization
+     * for the specified contract address and amount.
+     *
+     * @param params The payload parameters
+     * @param params.amount The amount value as a string
+     * @param params.contractAddress The contract address to include in the payload
+     *
+     * @returns Base64-encoded signature of the payload
+     */
+    signPayload({ amount, contractAddress, }: {
+        amount: string;
+        contractAddress: string;
+    }): string;
+    /**
+     * Sign a credential containing contract address and amount using Poseidon hashing.
+     *
+     * This method creates a cryptographic credential by signing a structured message
+     * using the Poseidon hash function (hash5). The message includes the amount,
+     * contract address (converted to uint256), public key coordinates, and a zero nonce.
+     *
+     * This type of credential is optimized for zero-knowledge proof systems where
+     * Poseidon hashing is more efficient than traditional hash functions.
+     *
+     * @param params The credential parameters
+     * @param params.amount The amount value as a string (will be converted to BigInt)
+     * @param params.contractAddress The contract address (will be converted to uint256)
+     *
+     * @returns Base64-encoded signature of the credential
+     */
+    signCredential({ amount, contractAddress, }: {
+        amount: string;
+        contractAddress: string;
+    }): string;
+    /**
+     * Generates an Elliptic-Curve Diffie–Hellman (ECDH) shared key given a private
+     * key and a public key.
+     * @param pubKey A public key generated using genPubKey()
+     * @returns The ECDH shared key.
+     */
+    genEcdhSharedKey(pubKey: PubKey): EcdhSharedKey;
+    genDeactivateRoot(accounts: PubKey[] | bigint[], stateTreeDepth: number): {
+        deactivates: bigint[][];
+        root: bigint;
+        leaves: bigint[];
+        tree: Tree;
+    };
+}

package/dist/libs/keypairs/eddsa-poseidon/publickey.d.ts

@@ -0,0 +1,48 @@
+import { PublicKey } from '../../cryptography/publickey';
+import type { PublicKeyInitData } from '../../cryptography/publickey';
+import { Signature } from '@zk-kit/eddsa-poseidon';
+import { PubKey } from '../../crypto';
+/**
+ * An EdDSAPoseidon public key
+ */
+export declare class EdDSAPoseidonPublicKey extends PublicKey {
+    private packedData;
+    private rawPoint;
+    /**
+     * Create a new EdDSAPoseidonPublicKey object
+     * @param value public key as packed bigint, Point array, Uint8Array or string
+     */
+    constructor(value: PublicKeyInitData | bigint | PubKey);
+    /**
+     * Checks if two EdDSAPoseidon public keys are equal
+     */
+    equals(publicKey: EdDSAPoseidonPublicKey): boolean;
+    /**
+     * Return the Point representation of the EdDSAPoseidon public key
+     */
+    toPoints(): PubKey;
+    /**
+     * Return the packed bigint representation of the EdDSAPoseidon public key
+     */
+    toPackedData(): bigint;
+    /**
+     * Verifies that the signature is valid for for the provided message
+     */
+    verify(message: Uint8Array | string, signature: Signature): boolean;
+    /**
+     * Verifies that the signature is valid for the provided address and amount
+     */
+    verifyPayload({ amount, contractAddress, signature }: {
+        amount: string;
+        contractAddress: string;
+        signature: string;
+    }): boolean;
+    /**
+     * Verifies that the signature is valid for the provided address and amount
+     */
+    verifyCredential({ amount, contractAddress, signature }: {
+        amount: string;
+        contractAddress: string;
+        signature: string;
+    }): boolean;
+}