@attestprotocol/stellar-contracts/dist/protocol.d.ts

Stellar Attestation Service

import { Buffer } from "buffer";
import { AssembledTransaction, Client as ContractClient, ClientOptions as ContractClientOptions, MethodOptions, Result } from '@stellar/stellar-sdk/contract';
import type { u64, i128, Option } from '@stellar/stellar-sdk/contract';
export * from '@stellar/stellar-sdk';
export * as contract from '@stellar/stellar-sdk/contract';
export * as rpc from '@stellar/stellar-sdk/rpc';
export declare const networks: {
    readonly testnet: {
        readonly networkPassphrase: "Test SDF Network ; September 2015";
        readonly contractId: "CBLG2QQ4BLFB7SSOPGYYJJHO5SLQROPRCLKBDMFQWRDXRA4ZXRIRWZW3";
    };
    readonly mainnet: {
        readonly networkPassphrase: "Public Global Stellar Network ; September 2015";
        readonly contractId: "CBLG2QQ4BLFB7SSOPGYYJJHO5SLQROPRCLKBDMFQWRDXRA4ZXRIRWZW3";
    };
};
export declare const Errors: {
    1: {
        message: string;
    };
    2: {
        message: string;
    };
    3: {
        message: string;
    };
    4: {
        message: string;
    };
    5: {
        message: string;
    };
    6: {
        message: string;
    };
    7: {
        message: string;
    };
    9: {
        message: string;
    };
    10: {
        message: string;
    };
    11: {
        message: string;
    };
    12: {
        message: string;
    };
    13: {
        message: string;
    };
    14: {
        message: string;
    };
    15: {
        message: string;
    };
    16: {
        message: string;
    };
    17: {
        message: string;
    };
    18: {
        message: string;
    };
    19: {
        message: string;
    };
    20: {
        message: string;
    };
    21: {
        message: string;
    };
    22: {
        message: string;
    };
    23: {
        message: string;
    };
    24: {
        message: string;
    };
    25: {
        message: string;
    };
    26: {
        message: string;
    };
};
export interface ResolverAttestation {
    attester: string;
    data: Buffer;
    expiration_time: u64;
    recipient: string;
    ref_uid: Buffer;
    revocable: boolean;
    revocation_time: u64;
    schema_uid: Buffer;
    time: u64;
    uid: Buffer;
    value: i128;
}
export type DataKey = {
    tag: "Admin";
    values: void;
} | {
    tag: "Authority";
    values: readonly [string];
} | {
    tag: "Schema";
    values: readonly [Buffer];
} | {
    tag: "AttestationUID";
    values: readonly [Buffer];
} | {
    tag: "AttesterNonce";
    values: readonly [string];
} | {
    tag: "AttesterPublicKey";
    values: readonly [string];
};
export interface Authority {
    address: string;
    metadata: string;
}
export interface Schema {
    authority: string;
    definition: string;
    resolver: Option<string>;
    revocable: boolean;
}
export interface DelegatedAttestationRequest {
    attester: string;
    deadline: u64;
    expiration_time: Option<u64>;
    nonce: u64;
    schema_uid: Buffer;
    signature: Buffer;
    subject: string;
    value: string;
}
export interface DelegatedRevocationRequest {
    attestation_uid: Buffer;
    deadline: u64;
    nonce: u64;
    revoker: string;
    schema_uid: Buffer;
    signature: Buffer;
    subject: string;
}
export interface Attestation {
    attester: string;
    expiration_time: Option<u64>;
    nonce: u64;
    revocation_time: Option<u64>;
    revoked: boolean;
    schema_uid: Buffer;
    subject: string;
    timestamp: u64;
    uid: Buffer;
    value: string;
}
export interface BlsPublicKey {
    key: Buffer;
    registered_at: u64;
}
export interface Client {
    initialize: ({ admin }: {
        admin: string;
    }, options?: {
        fee?: number;
        timeoutInSeconds?: number;
        simulate?: boolean;
    }) => Promise<AssembledTransaction<Result<void>>>;
    register: ({ caller, schema_definition, resolver, revocable }: {
        caller: string;
        schema_definition: string;
        resolver: Option<string>;
        revocable: boolean;
    }, options?: {
        fee?: number;
        timeoutInSeconds?: number;
        simulate?: boolean;
    }) => Promise<AssembledTransaction<Result<Buffer>>>;
    get_schema: ({ schema_uid }: {
        schema_uid: Buffer;
    }, options?: {
        fee?: number;
        timeoutInSeconds?: number;
        simulate?: boolean;
    }) => Promise<AssembledTransaction<Result<Schema>>>;
    attest: ({ attester, schema_uid, value, expiration_time }: {
        attester: string;
        schema_uid: Buffer;
        value: string;
        expiration_time: Option<u64>;
    }, options?: {
        fee?: number;
        timeoutInSeconds?: number;
        simulate?: boolean;
    }) => Promise<AssembledTransaction<Result<Buffer>>>;
    revoke: ({ revoker, attestation_uid }: {
        revoker: string;
        attestation_uid: Buffer;
    }, options?: {
        fee?: number;
        timeoutInSeconds?: number;
        simulate?: boolean;
    }) => Promise<AssembledTransaction<Result<void>>>;
    get_attestation: ({ attestation_uid }: {
        attestation_uid: Buffer;
    }, options?: {
        fee?: number;
        timeoutInSeconds?: number;
        simulate?: boolean;
    }) => Promise<AssembledTransaction<Result<Attestation>>>;
    attest_by_delegation: ({ submitter, request }: {
        submitter: string;
        request: DelegatedAttestationRequest;
    }, options?: {
        fee?: number;
        timeoutInSeconds?: number;
        simulate?: boolean;
    }) => Promise<AssembledTransaction<Result<void>>>;
    revoke_by_delegation: ({ submitter, request }: {
        submitter: string;
        request: DelegatedRevocationRequest;
    }, options?: {
        fee?: number;
        timeoutInSeconds?: number;
        simulate?: boolean;
    }) => Promise<AssembledTransaction<Result<void>>>;
    get_attester_nonce: ({ attester }: {
        attester: string;
    }, options?: {
        fee?: number;
        timeoutInSeconds?: number;
        simulate?: boolean;
    }) => Promise<AssembledTransaction<u64>>;
    register_bls_key: ({ attester, public_key }: {
        attester: string;
        public_key: Buffer;
    }, options?: {
        fee?: number;
        timeoutInSeconds?: number;
        simulate?: boolean;
    }) => Promise<AssembledTransaction<Result<void>>>;
    get_bls_key: ({ attester }: {
        attester: string;
    }, options?: {
        fee?: number;
        timeoutInSeconds?: number;
        simulate?: boolean;
    }) => Promise<AssembledTransaction<Result<BlsPublicKey>>>;
    get_dst_for_attestation: (options?: {
        fee?: number;
        timeoutInSeconds?: number;
        simulate?: boolean;
    }) => Promise<AssembledTransaction<Buffer>>;
    get_dst_for_revocation: (options?: {
        fee?: number;
        timeoutInSeconds?: number;
        simulate?: boolean;
    }) => Promise<AssembledTransaction<Buffer>>;
}
export declare class Client extends ContractClient {
    readonly options: ContractClientOptions;
    static deploy<T = Client>(options: MethodOptions & Omit<ContractClientOptions, "contractId"> & {
        wasmHash: Buffer | string;
        salt?: Buffer | Uint8Array;
        format?: "hex" | "base64";
    }): Promise<AssembledTransaction<T>>;
    constructor(options: ContractClientOptions);
    readonly fromJSON: {
        initialize: (json: string) => AssembledTransaction<Result<void, import("@stellar/stellar-sdk/contract").ErrorMessage>>;
        register: (json: string) => AssembledTransaction<Result<Buffer<ArrayBufferLike>, import("@stellar/stellar-sdk/contract").ErrorMessage>>;
        get_schema: (json: string) => AssembledTransaction<Result<Schema, import("@stellar/stellar-sdk/contract").ErrorMessage>>;
        attest: (json: string) => AssembledTransaction<Result<Buffer<ArrayBufferLike>, import("@stellar/stellar-sdk/contract").ErrorMessage>>;
        revoke: (json: string) => AssembledTransaction<Result<void, import("@stellar/stellar-sdk/contract").ErrorMessage>>;
        get_attestation: (json: string) => AssembledTransaction<Result<Attestation, import("@stellar/stellar-sdk/contract").ErrorMessage>>;
        attest_by_delegation: (json: string) => AssembledTransaction<Result<void, import("@stellar/stellar-sdk/contract").ErrorMessage>>;
        revoke_by_delegation: (json: string) => AssembledTransaction<Result<void, import("@stellar/stellar-sdk/contract").ErrorMessage>>;
        get_attester_nonce: (json: string) => AssembledTransaction<bigint>;
        register_bls_key: (json: string) => AssembledTransaction<Result<void, import("@stellar/stellar-sdk/contract").ErrorMessage>>;
        get_bls_key: (json: string) => AssembledTransaction<Result<BlsPublicKey, import("@stellar/stellar-sdk/contract").ErrorMessage>>;
        get_dst_for_attestation: (json: string) => AssembledTransaction<Buffer<ArrayBufferLike>>;
        get_dst_for_revocation: (json: string) => AssembledTransaction<Buffer<ArrayBufferLike>>;
    };
}
//# sourceMappingURL=protocol.d.ts.map