@zhoujun_aptos/octopus-ts-sdk-min 0.22.4 → 0.22.6

package/dist/common/index.d.ts

@@ -0,0 +1,966 @@
+import * as AptosSDK from '@aptos-labs/ts-sdk';
+import { Deserializer, Serializer, Aptos, AccountAddress, Ed25519PublicKey, Ed25519Signature, AccountPublicKey, Signature as Signature$1, PublicKey as PublicKey$1, AptosConfig } from '@aptos-labs/ts-sdk';
+import * as SolanaSDK from '@solana/web3.js';
+import { PublicKey, Transaction, VersionedTransaction } from '@solana/web3.js';
+
+declare class Element {
+    bytes: Uint8Array;
+    constructor(bytes: Uint8Array);
+    static dummy(): Element;
+    static fromInner(inner: any): Element;
+    static groupIdentity(): Element;
+    static rand(): Element;
+    static deserialize(deserializer: Deserializer): Element;
+    static fromBytes(bytes: Uint8Array): Element;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    asInner(): any;
+    add(other: Element): Element;
+    sub(other: Element): Element;
+    scale(scalar: Scalar): Element;
+}
+declare class Scalar {
+    bytes: Uint8Array;
+    constructor(bytes: Uint8Array);
+    static dummy(): Scalar;
+    static fromU64(x: bigint): Scalar;
+    static fromLittleEndianBytesModQ(bytes: Uint8Array): Scalar;
+    static rand(): Scalar;
+    static deserialize(deserializer: Deserializer): Scalar;
+    static fromBytes(bytes: Uint8Array): Scalar;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    isZero(): boolean;
+    add(other: Scalar): Scalar;
+    sub(other: Scalar): Scalar;
+    mul(other: Scalar): Scalar;
+    neg(): Scalar;
+}
+declare function msm(bases: Element[], scalars: Scalar[]): Element;
+declare function scalarFrom512BitHash(hash: Uint8Array): Scalar;
+
+type group_Element = Element;
+declare const group_Element: typeof Element;
+type group_Scalar = Scalar;
+declare const group_Scalar: typeof Scalar;
+declare const group_msm: typeof msm;
+declare const group_scalarFrom512BitHash: typeof scalarFrom512BitHash;
+declare namespace group {
+  export { group_Element as Element, group_Scalar as Scalar, group_msm as msm, group_scalarFrom512BitHash as scalarFrom512BitHash };
+}
+
+declare class Ciphertext$6 {
+    c0: Element;
+    c1: Element;
+    constructor(c0: Element, c1: Element);
+    static deserialize(deserializer: Deserializer): Ciphertext$6;
+    encode(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    add(other: Ciphertext$6): Ciphertext$6;
+    scale(scalar: Scalar): Ciphertext$6;
+}
+declare class DecKey {
+    encBase: Element;
+    privateScalar: Scalar;
+    constructor(encBase: Element, privateScalar: Scalar);
+    static deserialize(deserializer: Deserializer): DecKey;
+    encode(serializer: Serializer): void;
+}
+declare class EncKey {
+    encBase: Element;
+    publicPoint: Element;
+    constructor(encBase: Element, publicPoint: Element);
+    static decode(deserializer: Deserializer): EncKey;
+    encode(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+}
+declare function enc(ek: EncKey, randomizer: Scalar, ptxt: Element): Ciphertext$6;
+declare function dec(dk: DecKey, ciph: Ciphertext$6): Element;
+declare function multiExp(ciphs: Ciphertext$6[], scalars: Scalar[]): Ciphertext$6;
+
+type elgamal_DecKey = DecKey;
+declare const elgamal_DecKey: typeof DecKey;
+type elgamal_EncKey = EncKey;
+declare const elgamal_EncKey: typeof EncKey;
+declare const elgamal_dec: typeof dec;
+declare const elgamal_enc: typeof enc;
+declare const elgamal_multiExp: typeof multiExp;
+declare namespace elgamal {
+  export { Ciphertext$6 as Ciphertext, elgamal_DecKey as DecKey, elgamal_EncKey as EncKey, elgamal_dec as dec, elgamal_enc as enc, elgamal_multiExp as multiExp };
+}
+
+declare class SimpleElGamalRistretto255EncKey {
+    elgamalEk: EncKey;
+    constructor(elgamalEk: EncKey);
+    static deserialize(deserializer: Deserializer): SimpleElGamalRistretto255EncKey;
+    serialize(serializer: Serializer): void;
+}
+declare class SimpleElGamalRistretto255DecKey {
+    elgamalDk: DecKey;
+    constructor(elgamalDk: DecKey);
+    static deserialize(deserializer: Deserializer): SimpleElGamalRistretto255DecKey;
+    serialize(serializer: Serializer): void;
+}
+declare class SimpleElGamalRistretto255Ciphertext {
+    elgamalCiph: Ciphertext$6;
+    symmetricCiph: Uint8Array;
+    mac: Uint8Array;
+    constructor(elgamalCiph: Ciphertext$6, symmetricCiph: Uint8Array, mac: Uint8Array);
+    static deserialize(deserializer: Deserializer): SimpleElGamalRistretto255Ciphertext;
+    serialize(serializer: Serializer): void;
+}
+
+declare const SCHEME_SIMPLE_ELGAMAL_RISTRETTO255 = 0;
+declare class EncryptionKey$1 {
+    scheme: number;
+    inner: SimpleElGamalRistretto255EncKey;
+    constructor(scheme: number, inner: SimpleElGamalRistretto255EncKey);
+    static deserialize(deserializer: Deserializer): EncryptionKey$1;
+    static fromBytes(bytes: Uint8Array): EncryptionKey$1;
+    static fromHex(hex: string): EncryptionKey$1;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare class DecryptionKey$1 {
+    scheme: number;
+    inner: SimpleElGamalRistretto255DecKey;
+    constructor(scheme: number, inner: SimpleElGamalRistretto255DecKey);
+    static deserialize(deserializer: Deserializer): DecryptionKey$1;
+    static fromBytes(bytes: Uint8Array): DecryptionKey$1;
+    static fromHex(hex: string): DecryptionKey$1;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare class Ciphertext$5 {
+    scheme: number;
+    inner: SimpleElGamalRistretto255Ciphertext;
+    constructor(scheme: number, inner: SimpleElGamalRistretto255Ciphertext);
+    static deserialize(deserializer: Deserializer): Ciphertext$5;
+    static fromBytes(bytes: Uint8Array): Ciphertext$5;
+    static fromHex(hex: string): Ciphertext$5;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare function keygen$3(schemeId?: number): DecryptionKey$1;
+declare function deriveEncryptionKey(dk: DecryptionKey$1): EncryptionKey$1;
+declare function encrypt$3(ek: EncryptionKey$1, msg: Uint8Array): Ciphertext$5;
+declare function encryptWithRandomness$2(ek: EncryptionKey$1, msg: Uint8Array, randomness: Uint8Array): Ciphertext$5;
+declare function decrypt$3(dk: DecryptionKey$1, ciphertext: Ciphertext$5): Uint8Array | undefined;
+
+declare const index$5_SCHEME_SIMPLE_ELGAMAL_RISTRETTO255: typeof SCHEME_SIMPLE_ELGAMAL_RISTRETTO255;
+declare const index$5_deriveEncryptionKey: typeof deriveEncryptionKey;
+declare namespace index$5 {
+  export { Ciphertext$5 as Ciphertext, DecryptionKey$1 as DecryptionKey, EncryptionKey$1 as EncryptionKey, index$5_SCHEME_SIMPLE_ELGAMAL_RISTRETTO255 as SCHEME_SIMPLE_ELGAMAL_RISTRETTO255, decrypt$3 as decrypt, index$5_deriveEncryptionKey as deriveEncryptionKey, encrypt$3 as encrypt, encryptWithRandomness$2 as encryptWithRandomness, keygen$3 as keygen };
+}
+
+declare const SCHEME_OTP_HAMC_BONEH_FRANKLIN_BLS12381_SHORT_PK = 0;
+declare class MasterPublicKey {
+    scheme: number;
+    inner: any;
+    constructor(scheme: number, inner: any);
+    static deserialize(deserializer: Deserializer): MasterPublicKey;
+    static fromBytes(bytes: Uint8Array): MasterPublicKey;
+    static fromHex(hex: string): MasterPublicKey;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare class MasterPrivateKey {
+    scheme: number;
+    inner: any;
+    constructor(scheme: number, inner: any);
+    static deserialize(deserializer: Deserializer): MasterPrivateKey;
+    static fromBytes(bytes: Uint8Array): MasterPrivateKey;
+    static fromHex(hex: string): MasterPrivateKey;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare class IdentityPrivateKey {
+    scheme: number;
+    inner: any;
+    constructor(scheme: number, inner: any);
+    static deserialize(deserializer: Deserializer): IdentityPrivateKey;
+    static fromBytes(bytes: Uint8Array): IdentityPrivateKey;
+    static fromHex(hex: string): IdentityPrivateKey;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare class Ciphertext$4 {
+    scheme: number;
+    inner: any;
+    constructor(scheme: number, inner: any);
+    static deserialize(deserializer: Deserializer): Ciphertext$4;
+    static fromBytes(bytes: Uint8Array): Ciphertext$4;
+    static fromHex(hex: string): Ciphertext$4;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare function keygen$2(scheme?: number): MasterPrivateKey;
+declare function derivePublicKey(privateKey: MasterPrivateKey): MasterPublicKey;
+declare function encrypt$2(publicKey: MasterPublicKey, id: Uint8Array, plaintext: Uint8Array): Ciphertext$4;
+/** Do NOT use this, unless you are a maintainer. Use `encrypt` instead. */
+declare function encryptWithRandomness$1(publicKey: MasterPublicKey, id: Uint8Array, plaintext: Uint8Array, randomness: Uint8Array): Ciphertext$4;
+declare function extract(privateKey: MasterPrivateKey, id: Uint8Array): IdentityPrivateKey;
+declare function decrypt$2(identityKey: IdentityPrivateKey, ciphertext: Ciphertext$4): Uint8Array | undefined;
+
+type index$4_IdentityPrivateKey = IdentityPrivateKey;
+declare const index$4_IdentityPrivateKey: typeof IdentityPrivateKey;
+type index$4_MasterPrivateKey = MasterPrivateKey;
+declare const index$4_MasterPrivateKey: typeof MasterPrivateKey;
+type index$4_MasterPublicKey = MasterPublicKey;
+declare const index$4_MasterPublicKey: typeof MasterPublicKey;
+declare const index$4_SCHEME_OTP_HAMC_BONEH_FRANKLIN_BLS12381_SHORT_PK: typeof SCHEME_OTP_HAMC_BONEH_FRANKLIN_BLS12381_SHORT_PK;
+declare const index$4_derivePublicKey: typeof derivePublicKey;
+declare const index$4_extract: typeof extract;
+declare namespace index$4 {
+  export { Ciphertext$4 as Ciphertext, index$4_IdentityPrivateKey as IdentityPrivateKey, index$4_MasterPrivateKey as MasterPrivateKey, index$4_MasterPublicKey as MasterPublicKey, index$4_SCHEME_OTP_HAMC_BONEH_FRANKLIN_BLS12381_SHORT_PK as SCHEME_OTP_HAMC_BONEH_FRANKLIN_BLS12381_SHORT_PK, decrypt$2 as decrypt, index$4_derivePublicKey as derivePublicKey, encrypt$2 as encrypt, encryptWithRandomness$1 as encryptWithRandomness, index$4_extract as extract, keygen$2 as keygen };
+}
+
+declare class SchnorrRistretto255SigningKey {
+    base: Element;
+    privateScalar: Scalar;
+    constructor(base: Element, privateScalar: Scalar);
+    static deserialize(deserializer: Deserializer): SchnorrRistretto255SigningKey;
+    serialize(serializer: Serializer): void;
+}
+declare class SchnorrRistretto255VerifyingKey {
+    base: Element;
+    publicPoint: Element;
+    constructor(base: Element, publicPoint: Element);
+    static deserialize(deserializer: Deserializer): SchnorrRistretto255VerifyingKey;
+    serialize(serializer: Serializer): void;
+}
+declare class SchnorrRistretto255Signature {
+    challenge: Scalar;
+    z: Scalar;
+    constructor(challenge: Scalar, z: Scalar);
+    static deserialize(deserializer: Deserializer): SchnorrRistretto255Signature;
+    serialize(serializer: Serializer): void;
+}
+
+declare const SCHEME_SCHNORR_RISTRETTO255 = 0;
+declare class SigningKey {
+    scheme: number;
+    inner: SchnorrRistretto255SigningKey;
+    constructor(scheme: number, inner: SchnorrRistretto255SigningKey);
+    static deserialize(deserializer: Deserializer): SigningKey;
+    static fromBytes(bytes: Uint8Array): SigningKey;
+    static fromHex(hex: string): SigningKey;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare class VerifyingKey {
+    scheme: number;
+    inner: SchnorrRistretto255VerifyingKey;
+    constructor(scheme: number, inner: SchnorrRistretto255VerifyingKey);
+    static deserialize(deserializer: Deserializer): VerifyingKey;
+    static fromBytes(bytes: Uint8Array): VerifyingKey;
+    static fromHex(hex: string): VerifyingKey;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare class Signature {
+    scheme: number;
+    inner: SchnorrRistretto255Signature;
+    constructor(scheme: number, inner: SchnorrRistretto255Signature);
+    static deserialize(deserializer: Deserializer): Signature;
+    static fromBytes(bytes: Uint8Array): Signature;
+    static fromHex(hex: string): Signature;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare function keygen$1(schemeId?: number): SigningKey;
+declare function deriveVerifyingKey(sk: SigningKey): VerifyingKey;
+declare function sign(sk: SigningKey, msg: Uint8Array): Signature;
+declare function signWithRandomness(sk: SigningKey, msg: Uint8Array, randomness: Uint8Array): Signature;
+declare function verify(vk: VerifyingKey, msg: Uint8Array, sig: Signature): boolean;
+
+declare const index$3_SCHEME_SCHNORR_RISTRETTO255: typeof SCHEME_SCHNORR_RISTRETTO255;
+type index$3_Signature = Signature;
+declare const index$3_Signature: typeof Signature;
+type index$3_SigningKey = SigningKey;
+declare const index$3_SigningKey: typeof SigningKey;
+type index$3_VerifyingKey = VerifyingKey;
+declare const index$3_VerifyingKey: typeof VerifyingKey;
+declare const index$3_deriveVerifyingKey: typeof deriveVerifyingKey;
+declare const index$3_sign: typeof sign;
+declare const index$3_signWithRandomness: typeof signWithRandomness;
+declare const index$3_verify: typeof verify;
+declare namespace index$3 {
+  export { index$3_SCHEME_SCHNORR_RISTRETTO255 as SCHEME_SCHNORR_RISTRETTO255, index$3_Signature as Signature, index$3_SigningKey as SigningKey, index$3_VerifyingKey as VerifyingKey, index$3_deriveVerifyingKey as deriveVerifyingKey, keygen$1 as keygen, index$3_sign as sign, index$3_signWithRandomness as signWithRandomness, index$3_verify as verify };
+}
+
+declare class Key {
+    scheme: number;
+    inner: any;
+    constructor(scheme: number, inner: any);
+    static deserialize(deserializer: Deserializer): Key;
+    static fromBytes(bytes: Uint8Array): Key;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare class Ciphertext$3 {
+    scheme: number;
+    inner: any;
+    constructor(scheme: number, inner: any);
+    static dummy(): Ciphertext$3;
+    static deserialize(deserializer: Deserializer): Ciphertext$3;
+    static fromBytes(bytes: Uint8Array): Ciphertext$3;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare function keygen(scheme?: number): Key;
+declare function encrypt$1(key: Key, plaintext: Uint8Array): Ciphertext$3;
+declare function encryptWithRandomness(key: Key, plaintext: Uint8Array, randomness: Uint8Array): Ciphertext$3;
+declare function decrypt$1(key: Key, ciphertext: Ciphertext$3): Uint8Array | undefined;
+
+type index$2_Key = Key;
+declare const index$2_Key: typeof Key;
+declare const index$2_encryptWithRandomness: typeof encryptWithRandomness;
+declare const index$2_keygen: typeof keygen;
+declare namespace index$2 {
+  export { Ciphertext$3 as Ciphertext, index$2_Key as Key, decrypt$1 as decrypt, encrypt$1 as encrypt, index$2_encryptWithRandomness as encryptWithRandomness, index$2_keygen as keygen };
+}
+
+declare class WorkerConfig {
+    expiryTimeMicrosecs: number;
+    endpoint: string;
+    encEk: EncryptionKey$1;
+    sigVk: VerifyingKey;
+    ibeMpk: MasterPublicKey;
+    constructor(expiryTimeMicrosecs: number, endpoint: string, encEk: EncryptionKey$1, sigVk: VerifyingKey, ibeMpk: MasterPublicKey);
+    static dummy(): WorkerConfig;
+    static deserialize(deserializer: Deserializer): WorkerConfig;
+    static fromBytes(bytes: Uint8Array): WorkerConfig;
+    static fromHex(hex: string): WorkerConfig;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    toPrettyJson(): string;
+}
+declare function view(aptos: Aptos, worker: AccountAddress): Promise<WorkerConfig>;
+declare function get(workerEndpoint: string): Promise<WorkerConfig>;
+declare function randWorker(): {
+    addr: AccountAddress;
+    config: WorkerConfig;
+    encDk: DecryptionKey$1;
+    sigSk: SigningKey;
+    ibeMsk: MasterPrivateKey;
+};
+
+type worker_config_WorkerConfig = WorkerConfig;
+declare const worker_config_WorkerConfig: typeof WorkerConfig;
+declare const worker_config_get: typeof get;
+declare const worker_config_randWorker: typeof randWorker;
+declare const worker_config_view: typeof view;
+declare namespace worker_config {
+  export { worker_config_WorkerConfig as WorkerConfig, worker_config_get as get, worker_config_randWorker as randWorker, worker_config_view as view };
+}
+
+/**
+ * This file contains Aptos-specific implementations for silent setup encryption.
+ * For cross-chain support, use `silent_setup_encryption_xchain.ts` instead.
+ */
+
+declare class EncryptionContext$1 {
+    workers: AccountAddress[];
+    threshold: number;
+    moduleAddr: AccountAddress;
+    moduleName: string;
+    constructor({ workers, threshold, moduleAddr, moduleName }: {
+        workers: AccountAddress[];
+        threshold: number;
+        moduleAddr: AccountAddress;
+        moduleName: string;
+    });
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    loadEncryptor(aptos: Aptos): Promise<Encryptor$1>;
+}
+declare class DecryptionContext$1 {
+    workers: AccountAddress[];
+    threshold: number;
+    moduleAddr: AccountAddress;
+    moduleName: string;
+    domain: Uint8Array;
+    constructor({ workers, threshold, moduleAddr, moduleName, domain }: {
+        workers: AccountAddress[];
+        threshold: number;
+        moduleAddr: AccountAddress;
+        moduleName: string;
+        domain: Uint8Array;
+    });
+    static dummy(): DecryptionContext$1;
+    static deserialize(deserializer: Deserializer): DecryptionContext$1;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    toWalletSignMessage(): string;
+    loadDecryptor({ aptos, userAddr, publicKey, signature }: {
+        aptos: Aptos;
+        userAddr: AccountAddress;
+        publicKey: Ed25519PublicKey;
+        signature: Ed25519Signature;
+    }): Promise<Decryptor$1>;
+}
+declare class Ciphertext$2 {
+    decryptionContext: DecryptionContext$1;
+    aesCiph: Ciphertext$3;
+    ibeCiphs: Ciphertext$4[];
+    constructor(decryptionContext: DecryptionContext$1, aesCiph: Ciphertext$3, ibeCiphs: Ciphertext$4[]);
+    static dummy(): Ciphertext$2;
+    static deserialize(deserializer: Deserializer): Ciphertext$2;
+    static fromBytes(bytes: Uint8Array): Ciphertext$2;
+    static fromHex(hex: string): Ciphertext$2;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+}
+declare class Encryptor$1 {
+    domain: EncryptionContext$1;
+    workerConfigs: WorkerConfig[];
+    constructor(domain: EncryptionContext$1, workerConfigs: WorkerConfig[]);
+    encrypt({ domain, plaintext }: {
+        domain: Uint8Array;
+        plaintext: Uint8Array;
+    }): Ciphertext$2;
+}
+declare class Decryptor$1 {
+    ibeDecryptionKeys: (IdentityPrivateKey | null)[];
+    decryptionContext: DecryptionContext$1;
+    constructor(decryptionContext: DecryptionContext$1, ibeDecryptionKeys: (IdentityPrivateKey | null)[]);
+    decrypt(ciphertext: Ciphertext$2): Uint8Array | undefined;
+}
+/**
+ * A message from a user to a MPC worker to request a decryption key.
+ */
+declare class RequestForDecryptionKey$1 {
+    decryptionContext: DecryptionContext$1;
+    userAddr: AccountAddress;
+    publicKey: Ed25519PublicKey;
+    signature: Ed25519Signature;
+    constructor(decryptionContext: DecryptionContext$1, userAddr: AccountAddress, publicKey: Ed25519PublicKey, signature: Ed25519Signature);
+    static deserialize(deserializer: Deserializer): RequestForDecryptionKey$1;
+    static fromBytes(bytes: Uint8Array): RequestForDecryptionKey$1;
+    static fromHex(hex: string): RequestForDecryptionKey$1;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+
+declare namespace silent_setup_encryption {
+  export { Ciphertext$2 as Ciphertext, DecryptionContext$1 as DecryptionContext, Decryptor$1 as Decryptor, EncryptionContext$1 as EncryptionContext, Encryptor$1 as Encryptor, RequestForDecryptionKey$1 as RequestForDecryptionKey };
+}
+
+declare class ContractID$5 {
+    chainId: number;
+    moduleAddr: AccountAddress;
+    moduleName: string;
+    constructor(chainId: number, moduleAddr: AccountAddress, moduleName: string);
+    static dummy(): ContractID$5;
+    static deserialize(deserializer: Deserializer): ContractID$5;
+    static fromBytes(bytes: Uint8Array): ContractID$5;
+    static fromHex(hex: string): ContractID$5;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare const POP_SCHEME__V0 = 0;
+declare class ProofOfPermission$5 {
+    scheme: number;
+    inner: any;
+    private constructor();
+    static newV0(v0: ProofOfPermissionV0): ProofOfPermission$5;
+    static deserialize(deserializer: Deserializer): ProofOfPermission$5;
+    static fromBytes(bytes: Uint8Array): ProofOfPermission$5;
+    static fromHex(hex: string): ProofOfPermission$5;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare class ProofOfPermissionV0 {
+    userAddr: AccountAddress;
+    publicKey: Ed25519PublicKey;
+    signature: Ed25519Signature;
+    constructor(userAddr: AccountAddress, publicKey: Ed25519PublicKey, signature: Ed25519Signature);
+    static deserialize(deserializer: Deserializer): ProofOfPermissionV0;
+    static fromBytes(bytes: Uint8Array): ProofOfPermissionV0;
+    static fromHex(hex: string): ProofOfPermissionV0;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+
+declare const aptos_POP_SCHEME__V0: typeof POP_SCHEME__V0;
+type aptos_ProofOfPermissionV0 = ProofOfPermissionV0;
+declare const aptos_ProofOfPermissionV0: typeof ProofOfPermissionV0;
+declare namespace aptos {
+  export { ContractID$5 as ContractID, aptos_POP_SCHEME__V0 as POP_SCHEME__V0, ProofOfPermission$5 as ProofOfPermission, aptos_ProofOfPermissionV0 as ProofOfPermissionV0 };
+}
+
+declare const SCHEME_V0 = 0;
+declare class ContractID$4 {
+    scheme: number;
+    inner: any;
+    private constructor();
+    static newV0(v0: ContractIDV0): ContractID$4;
+    static deserialize(deserializer: Deserializer): ContractID$4;
+    static fromBytes(bytes: Uint8Array): ContractID$4;
+    static fromHex(hex: string): ContractID$4;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare class ContractIDV0 {
+    knownChainName: string;
+    programId: PublicKey;
+    constructor(knownChainName: string, programId: PublicKey);
+    static deserialize(deserializer: Deserializer): ContractIDV0;
+    static fromBytes(bytes: Uint8Array): ContractIDV0;
+    static fromHex(hex: string): ContractIDV0;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare const POP_SCHEME__UNVERSIONED_TXN = 0;
+declare const POP_SCHEME__VERSIONED_TXN = 1;
+declare class ProofOfPermission$4 {
+    scheme: number;
+    inner: Transaction | VersionedTransaction;
+    private constructor();
+    static newVersioned(txn: VersionedTransaction): ProofOfPermission$4;
+    static newUnversioned(txn: Transaction): ProofOfPermission$4;
+    static deserialize(deserializer: Deserializer): ProofOfPermission$4;
+    static fromBytes(bytes: Uint8Array): ProofOfPermission$4;
+    static fromHex(hex: string): ProofOfPermission$4;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+
+type solana_ContractIDV0 = ContractIDV0;
+declare const solana_ContractIDV0: typeof ContractIDV0;
+declare const solana_POP_SCHEME__UNVERSIONED_TXN: typeof POP_SCHEME__UNVERSIONED_TXN;
+declare const solana_POP_SCHEME__VERSIONED_TXN: typeof POP_SCHEME__VERSIONED_TXN;
+declare const solana_SCHEME_V0: typeof SCHEME_V0;
+declare namespace solana {
+  export { ContractID$4 as ContractID, solana_ContractIDV0 as ContractIDV0, solana_POP_SCHEME__UNVERSIONED_TXN as POP_SCHEME__UNVERSIONED_TXN, solana_POP_SCHEME__VERSIONED_TXN as POP_SCHEME__VERSIONED_TXN, ProofOfPermission$4 as ProofOfPermission, solana_SCHEME_V0 as SCHEME_V0 };
+}
+
+declare const SCHEME_APTOS = 0;
+declare const SCHEME_SOLANA = 1;
+declare class ContractID$3 {
+    scheme: number;
+    inner: any;
+    private constructor();
+    static newAptos(id: ContractID$5): ContractID$3;
+    static newSolana(id: ContractID$4): ContractID$3;
+    static dummy(): ContractID$3;
+    static deserialize(deserializer: Deserializer): ContractID$3;
+    static fromBytes(bytes: Uint8Array): ContractID$3;
+    static fromHex(hex: string): ContractID$3;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare class ProofOfPermission$3 {
+    scheme: number;
+    inner: any;
+    private constructor();
+    static newAptos(id: ProofOfPermission$5): ProofOfPermission$3;
+    static newSolana(id: ProofOfPermission$4): ProofOfPermission$3;
+    static deserialize(deserializer: Deserializer): ProofOfPermission$3;
+    static fromBytes(bytes: Uint8Array): ProofOfPermission$3;
+    static fromHex(hex: string): ProofOfPermission$3;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare class EncryptionContext {
+    workers: string[];
+    threshold: number;
+    contractId: ContractID$3;
+    constructor({ workers, threshold, contractId }: {
+        workers: string[];
+        threshold: number;
+        contractId: ContractID$3;
+    });
+    static deserialize(deserializer: Deserializer): EncryptionContext;
+    static fromBytes(bytes: Uint8Array): EncryptionContext;
+    static fromHex(hex: string): EncryptionContext;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    loadEncryptor(): Promise<Encryptor>;
+}
+declare class DecryptionContext {
+    workers: string[];
+    threshold: number;
+    contractId: ContractID$3;
+    domain: Uint8Array;
+    constructor({ workers, threshold, contractId, domain }: {
+        workers: string[];
+        threshold: number;
+        contractId: ContractID$3;
+        domain: Uint8Array;
+    });
+    static dummy(): DecryptionContext;
+    static deserialize(deserializer: Deserializer): DecryptionContext;
+    static fromBytes(bytes: Uint8Array): DecryptionContext;
+    static fromHex(hex: string): DecryptionContext;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    loadDecryptor(proof: ProofOfPermission$3): Promise<Decryptor>;
+}
+declare class Ciphertext$1 {
+    decryptionContext: DecryptionContext;
+    aesCiph: Ciphertext$3;
+    ibeCiphs: Ciphertext$4[];
+    constructor(decryptionContext: DecryptionContext, aesCiph: Ciphertext$3, ibeCiphs: Ciphertext$4[]);
+    static dummy(): Ciphertext$1;
+    static deserialize(deserializer: Deserializer): Ciphertext$1;
+    static fromBytes(bytes: Uint8Array): Ciphertext$1;
+    static fromHex(hex: string): Ciphertext$1;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+}
+declare class Encryptor {
+    domain: EncryptionContext;
+    workerConfigs: WorkerConfig[];
+    constructor(domain: EncryptionContext, workerConfigs: WorkerConfig[]);
+    encrypt({ domain, plaintext }: {
+        domain: Uint8Array;
+        plaintext: Uint8Array;
+    }): Ciphertext$1;
+}
+declare class Decryptor {
+    ibeDecryptionKeys: (IdentityPrivateKey | null)[];
+    decryptionContext: DecryptionContext;
+    constructor(decryptionContext: DecryptionContext, ibeDecryptionKeys: (IdentityPrivateKey | null)[]);
+    decrypt(ciphertext: Ciphertext$1): Uint8Array | undefined;
+}
+/**
+ * A message from a user to a MPC worker to request a decryption key.
+ */
+declare class RequestForDecryptionKey {
+    decryptionContext: DecryptionContext;
+    proofOfPermission: ProofOfPermission$3;
+    constructor(decryptionContext: DecryptionContext, proofOfPermission: ProofOfPermission$3);
+    static deserialize(deserializer: Deserializer): RequestForDecryptionKey;
+    static fromBytes(bytes: Uint8Array): RequestForDecryptionKey;
+    static fromHex(hex: string): RequestForDecryptionKey;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+
+type index$1_DecryptionContext = DecryptionContext;
+declare const index$1_DecryptionContext: typeof DecryptionContext;
+type index$1_Decryptor = Decryptor;
+declare const index$1_Decryptor: typeof Decryptor;
+type index$1_EncryptionContext = EncryptionContext;
+declare const index$1_EncryptionContext: typeof EncryptionContext;
+type index$1_Encryptor = Encryptor;
+declare const index$1_Encryptor: typeof Encryptor;
+type index$1_RequestForDecryptionKey = RequestForDecryptionKey;
+declare const index$1_RequestForDecryptionKey: typeof RequestForDecryptionKey;
+declare const index$1_SCHEME_APTOS: typeof SCHEME_APTOS;
+declare const index$1_SCHEME_SOLANA: typeof SCHEME_SOLANA;
+declare namespace index$1 {
+  export { aptos as Aptos, Ciphertext$1 as Ciphertext, ContractID$3 as ContractID, index$1_DecryptionContext as DecryptionContext, index$1_Decryptor as Decryptor, index$1_EncryptionContext as EncryptionContext, index$1_Encryptor as Encryptor, ProofOfPermission$3 as ProofOfPermission, index$1_RequestForDecryptionKey as RequestForDecryptionKey, index$1_SCHEME_APTOS as SCHEME_APTOS, index$1_SCHEME_SOLANA as SCHEME_SOLANA, solana as Solana };
+}
+
+declare class ContractID$2 {
+    chainId: number;
+    moduleAddr: AccountAddress;
+    moduleName: string;
+    functionName: string;
+    constructor(chainId: number, moduleAddr: AccountAddress, moduleName: string, functionName: string);
+    static dummy(): ContractID$2;
+    static deserialize(deserializer: Deserializer): ContractID$2;
+    static fromBytes(bytes: Uint8Array): ContractID$2;
+    static fromHex(hex: string): ContractID$2;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    toPrettyMessage(indent?: number): string;
+}
+declare class ProofOfPermission$2 {
+    userAddr: AccountAddress;
+    publicKeyScheme: number;
+    publicKey: AccountPublicKey;
+    signatureScheme: number;
+    signature: Signature$1;
+    fullMessage: string;
+    constructor({ userAddr, publicKey, signature, fullMessage }: {
+        userAddr: AccountAddress;
+        publicKey: PublicKey$1;
+        signature: Signature$1;
+        fullMessage: string;
+    });
+    static deserialize(deserializer: Deserializer): ProofOfPermission$2;
+    static fromBytes(bytes: Uint8Array): ProofOfPermission$2;
+    static fromHex(hex: string): ProofOfPermission$2;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+
+declare class ContractID$1 {
+    knownChainName: string;
+    programId: PublicKey;
+    constructor({ knownChainName, programId }: {
+        knownChainName: string;
+        programId: PublicKey;
+    });
+    static deserialize(deserializer: Deserializer): ContractID$1;
+    static fromBytes(bytes: Uint8Array): ContractID$1;
+    static fromHex(hex: string): ContractID$1;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    toPrettyMessage(indent?: number): string;
+}
+declare class ProofOfPermission$1 {
+    static readonly SCHEME_UNVERSIONED = 0;
+    static readonly SCHEME_VERSIONED = 1;
+    scheme: number;
+    inner: Transaction | VersionedTransaction;
+    private constructor();
+    static newVersioned(txn: VersionedTransaction): ProofOfPermission$1;
+    static newUnversioned(txn: Transaction): ProofOfPermission$1;
+    static deserialize(deserializer: Deserializer): ProofOfPermission$1;
+    static fromBytes(bytes: Uint8Array): ProofOfPermission$1;
+    static fromHex(hex: string): ProofOfPermission$1;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+
+/**
+ * @module threshold-ibe
+ *
+ *
+ */
+
+declare class Committee {
+    workerEndpoints: string[];
+    threshold: number;
+    constructor({ workerEndpoints, threshold }: {
+        workerEndpoints: string[];
+        threshold: number;
+    });
+    static dummy(): Committee;
+    static deserialize(deserializer: Deserializer): Committee;
+    serialize(serializer: Serializer): void;
+    toPrettyMessage(indent?: number): string;
+}
+declare class ContractID {
+    static readonly SCHEME_APTOS = 0;
+    static readonly SCHEME_SOLANA = 1;
+    scheme: number;
+    inner: any;
+    private constructor();
+    static newAptos({ chainId, moduleAddr, moduleName, functionName }: {
+        chainId: number;
+        moduleAddr: AptosSDK.AccountAddress;
+        moduleName: string;
+        functionName: string;
+    }): ContractID;
+    static newSolana({ knownChainName, programId }: {
+        knownChainName: string;
+        programId: SolanaSDK.PublicKey;
+    }): ContractID;
+    static dummy(): ContractID;
+    static deserialize(deserializer: Deserializer): ContractID;
+    static fromBytes(bytes: Uint8Array): ContractID;
+    static fromHex(hex: string): ContractID;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    toPrettyMessage(indent?: number): string;
+}
+declare class EncryptionKey {
+    ibeMpks: MasterPublicKey[];
+    constructor({ ibeMpks }: {
+        ibeMpks: MasterPublicKey[];
+    });
+    static fetch({ committee }: {
+        committee: Committee;
+    }): Promise<EncryptionKey>;
+}
+declare class DecryptionKey {
+    ibeDecryptionKeys: (IdentityPrivateKey | null)[];
+    private constructor();
+    static fetch({ committee, contractId, domain, proof }: {
+        committee: Committee;
+        contractId: ContractID;
+        domain: Uint8Array;
+        proof: ProofOfPermission;
+    }): Promise<DecryptionKey>;
+}
+declare class Ciphertext {
+    aesCiph: Ciphertext$3;
+    ibeCiphs: Ciphertext$4[];
+    constructor(aesCiph: Ciphertext$3, ibeCiphs: Ciphertext$4[]);
+    static dummy(): Ciphertext;
+    static deserialize(deserializer: Deserializer): Ciphertext;
+    static fromBytes(bytes: Uint8Array): Ciphertext;
+    static fromHex(hex: string): Ciphertext;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+}
+declare class FullDecryptionDomain {
+    committee: Committee;
+    contractId: ContractID;
+    domain: Uint8Array;
+    constructor({ committee, contractId, domain }: {
+        committee: Committee;
+        contractId: ContractID;
+        domain: Uint8Array;
+    });
+    static dummy(): FullDecryptionDomain;
+    static deserialize(deserializer: Deserializer): FullDecryptionDomain;
+    static fromBytes(bytes: Uint8Array): FullDecryptionDomain;
+    static fromHex(hex: string): FullDecryptionDomain;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    toPrettyMessage(indent?: number): string;
+    getSolanaContractID(): ContractID$1;
+    getAptosContractID(): ContractID$2;
+}
+declare class ProofOfPermission {
+    static readonly SCHEME_APTOS = 0;
+    static readonly SCHEME_SOLANA = 1;
+    scheme: number;
+    inner: any;
+    private constructor();
+    /** @deprecated Use `ProofOfPermission.createAptos()` instead */
+    static newAptos(id: ProofOfPermission$2): ProofOfPermission;
+    /** @deprecated Use `ProofOfPermission.createSolana()` instead */
+    static newSolana(id: ProofOfPermission$1): ProofOfPermission;
+    static createAptos({ userAddr, publicKey, signature, fullMessage }: {
+        userAddr: AptosSDK.AccountAddress;
+        publicKey: AptosSDK.PublicKey;
+        signature: AptosSDK.Signature;
+        fullMessage: string;
+    }): ProofOfPermission;
+    static createSolana({ txn }: {
+        txn: SolanaSDK.Transaction | SolanaSDK.VersionedTransaction;
+    }): ProofOfPermission;
+    static deserialize(deserializer: Deserializer): ProofOfPermission;
+    static fromBytes(bytes: Uint8Array): ProofOfPermission;
+    static fromHex(hex: string): ProofOfPermission;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+}
+declare function encrypt({ committee, encryptionKey, contractId, domain, plaintext }: {
+    committee: Committee;
+    encryptionKey: EncryptionKey;
+    contractId: ContractID;
+    domain: Uint8Array;
+    plaintext: Uint8Array;
+}): {
+    fullDecryptionDomain: FullDecryptionDomain;
+    ciphertext: Ciphertext;
+};
+declare function decrypt({ decryptionKey, ciphertext }: {
+    decryptionKey: DecryptionKey;
+    ciphertext: Ciphertext;
+}): Uint8Array | undefined;
+declare function verifyAndExtract({ ibeMsk, committee, contractId, domain, proof }: {
+    ibeMsk: MasterPrivateKey;
+    committee: Committee;
+    contractId: ContractID;
+    domain: Uint8Array;
+    proof: ProofOfPermission;
+}): Promise<IdentityPrivateKey>;
+
+type index_Ciphertext = Ciphertext;
+declare const index_Ciphertext: typeof Ciphertext;
+type index_Committee = Committee;
+declare const index_Committee: typeof Committee;
+type index_ContractID = ContractID;
+declare const index_ContractID: typeof ContractID;
+type index_DecryptionKey = DecryptionKey;
+declare const index_DecryptionKey: typeof DecryptionKey;
+type index_EncryptionKey = EncryptionKey;
+declare const index_EncryptionKey: typeof EncryptionKey;
+type index_FullDecryptionDomain = FullDecryptionDomain;
+declare const index_FullDecryptionDomain: typeof FullDecryptionDomain;
+type index_ProofOfPermission = ProofOfPermission;
+declare const index_ProofOfPermission: typeof ProofOfPermission;
+declare const index_decrypt: typeof decrypt;
+declare const index_encrypt: typeof encrypt;
+declare const index_verifyAndExtract: typeof verifyAndExtract;
+declare namespace index {
+  export { index_Ciphertext as Ciphertext, index_Committee as Committee, index_ContractID as ContractID, index_DecryptionKey as DecryptionKey, index_EncryptionKey as EncryptionKey, index_FullDecryptionDomain as FullDecryptionDomain, index_ProofOfPermission as ProofOfPermission, index_decrypt as decrypt, index_encrypt as encrypt, index_verifyAndExtract as verifyAndExtract };
+}
+
+declare const CONTRACT_ADDRESS_HEX: string;
+declare const SHELBYNET_CONTRACT_ADDRESS_HEX: string;
+declare function randBytes(length: number): Uint8Array;
+declare function xorBytes(blinder: Uint8Array<ArrayBufferLike>, plaintext: Uint8Array<ArrayBufferLike>): Uint8Array;
+declare function concatBytes(a: Uint8Array, b: Uint8Array): Uint8Array;
+declare function kdf(seed: Uint8Array, dst: Uint8Array, targetLength: number): Uint8Array;
+declare function hmac_sha3_256(key: Uint8Array, message: Uint8Array): Uint8Array;
+declare function sha3_256(message: Uint8Array): Uint8Array;
+declare function sha3_512(message: Uint8Array): Uint8Array;
+declare function getAptosConfig(networkName: string): AptosConfig;
+
+declare const utils_CONTRACT_ADDRESS_HEX: typeof CONTRACT_ADDRESS_HEX;
+declare const utils_SHELBYNET_CONTRACT_ADDRESS_HEX: typeof SHELBYNET_CONTRACT_ADDRESS_HEX;
+declare const utils_concatBytes: typeof concatBytes;
+declare const utils_getAptosConfig: typeof getAptosConfig;
+declare const utils_hmac_sha3_256: typeof hmac_sha3_256;
+declare const utils_kdf: typeof kdf;
+declare const utils_randBytes: typeof randBytes;
+declare const utils_sha3_256: typeof sha3_256;
+declare const utils_sha3_512: typeof sha3_512;
+declare const utils_xorBytes: typeof xorBytes;
+declare namespace utils {
+  export { utils_CONTRACT_ADDRESS_HEX as CONTRACT_ADDRESS_HEX, utils_SHELBYNET_CONTRACT_ADDRESS_HEX as SHELBYNET_CONTRACT_ADDRESS_HEX, utils_concatBytes as concatBytes, utils_getAptosConfig as getAptosConfig, utils_hmac_sha3_256 as hmac_sha3_256, utils_kdf as kdf, utils_randBytes as randBytes, utils_sha3_256 as sha3_256, utils_sha3_512 as sha3_512, utils_xorBytes as xorBytes };
+}
+
+declare class WorkerTask {
+    taskType: number;
+    inner: any;
+    constructor(taskType: number, inner: any);
+    static newSilentSetupDecryptionKey(decryptionContext: DecryptionContext$1, userAddr: AccountAddress, publicKey: Ed25519PublicKey, signature: Ed25519Signature): WorkerTask;
+    static newXChainSilentSetupDecryptionKey(decryptionContext: DecryptionContext, proofOfPermission: ProofOfPermission$3): WorkerTask;
+    static newThresholdIbeDecryptionKey(args: {
+        committee: Committee;
+        contractId: ContractID;
+        domain: Uint8Array;
+        proof: ProofOfPermission;
+    }): WorkerTask;
+    static deserialize(deserializer: Deserializer): WorkerTask;
+    static fromBytes(bytes: Uint8Array): WorkerTask;
+    static fromHex(hex: string): WorkerTask;
+    serialize(serializer: Serializer): void;
+    toBytes(): Uint8Array;
+    toHex(): string;
+    unpackThresholdIbeDecryptionKey(): {
+        committee: Committee;
+        contractId: ContractID;
+        domain: Uint8Array;
+        proof: ProofOfPermission;
+    };
+}
+
+export { elgamal as ElGamal, index$5 as Enc, group as Group, index$4 as IBE, index$3 as Sig, silent_setup_encryption as SilentSetupEncryption, index$1 as SilentSetupEncryptionXChain, index$2 as Sym, index as ThresholdIbe, utils as Utils, worker_config as WorkerConfig, WorkerTask };