@dfns/sdk 0.0.0-prealpha.9

package/codegen/datamodel/Wallets/responses.d.ts

@@ -0,0 +1,77 @@
+import { BadRequestError, EntityNotFoundError, ForbiddenError, UnauthorizedError } from '../Foundations';
+import { PaginatedEventHistory, PaginatedSignatureList, PaginatedTransactionList, PaginatedTransferList, PaginatedWalletList, SignatureRequest, TransactionRequest, TransferRequest, Wallet, WalletAssets, WalletNfts } from './types';
+export type CreateWalletSuccess = Wallet;
+export type CreateWalletError = {
+    error: BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type CreateWalletResponse = CreateWalletSuccess | CreateWalletError;
+export type GetWalletSuccess = Wallet;
+export type GetWalletError = {
+    error: EntityNotFoundError | BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetWalletResponse = GetWalletSuccess | GetWalletError;
+export type GetWalletAssetsSuccess = WalletAssets;
+export type GetWalletAssetsError = {
+    error: EntityNotFoundError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetWalletAssetsResponse = GetWalletAssetsSuccess | GetWalletAssetsError;
+export type GetWalletNftsSuccess = WalletNfts;
+export type GetWalletNftsError = {
+    error: EntityNotFoundError | BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetWalletNftsResponse = GetWalletNftsSuccess | GetWalletNftsError;
+export type ListWalletsSuccess = PaginatedWalletList;
+export type ListWalletsError = {
+    error: ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListWalletsResponse = ListWalletsSuccess | ListWalletsError;
+export type GetWalletHistorySuccess = PaginatedEventHistory;
+export type GetWalletHistoryError = {
+    error: EntityNotFoundError | BadRequestError | ForbiddenError | UnauthorizedError;
+};
+export type GetWalletHistoryResponse = GetWalletHistorySuccess | GetWalletHistoryError;
+export type TransferAssetSuccess = TransferRequest;
+export type TransferAssetError = {
+    error: BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type TransferAssetResponse = TransferAssetSuccess | TransferAssetError;
+export type GetTransferSuccess = TransferRequest;
+export type GetTransferError = {
+    error: EntityNotFoundError | BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetTransferResponse = GetTransferSuccess | GetTransferError;
+export type ListTransfersSuccess = PaginatedTransferList;
+export type ListTransfersError = {
+    error: ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListTransfersResponse = ListTransfersSuccess | ListTransfersError;
+export type BroadcastTransactionSuccess = TransactionRequest;
+export type BroadcastTransactionError = {
+    error: BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type BroadcastTransactionResponse = BroadcastTransactionSuccess | BroadcastTransactionError;
+export type GetTransactionSuccess = TransactionRequest;
+export type GetTransactionError = {
+    error: EntityNotFoundError | BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetTransactionResponse = GetTransactionSuccess | GetTransactionError;
+export type ListTransactionsSuccess = PaginatedTransactionList;
+export type ListTransactionsError = {
+    error: ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListTransactionsResponse = ListTransactionsSuccess | ListTransactionsError;
+export type GenerateSignatureSuccess = SignatureRequest;
+export type GenerateSignatureError = {
+    error: BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GenerateSignatureResponse = GenerateSignatureSuccess | GenerateSignatureError;
+export type GetSignatureSuccess = SignatureRequest;
+export type GetSignatureError = {
+    error: EntityNotFoundError | BadRequestError | ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type GetSignatureResponse = GetSignatureSuccess | GetSignatureError;
+export type ListSignaturesSuccess = PaginatedSignatureList;
+export type ListSignaturesError = {
+    error: ForbiddenError | UnauthorizedError | ForbiddenError | BadRequestError | EntityNotFoundError;
+};
+export type ListSignaturesResponse = ListSignaturesSuccess | ListSignaturesError;

package/codegen/datamodel/Wallets/responses.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/codegen/datamodel/Wallets/types.d.ts

@@ -0,0 +1,277 @@
+import { Amount, BlockchainAddress, EntityId, IsoDatetime, Tag } from '../Foundations';
+export type TransferNativeAsset = {
+    kind: TransferKind.Native;
+    to: BlockchainAddress;
+    amount: Amount;
+};
+export type TransferErc20Asset = {
+    kind: TransferKind.Erc20;
+    contract: BlockchainAddress;
+    to: BlockchainAddress;
+    amount: Amount;
+};
+export type TransferErc721Asset = {
+    kind: TransferKind.Erc721;
+    contract: BlockchainAddress;
+    to: BlockchainAddress;
+    tokenId: string;
+};
+export type BroadcastEvmTransaction = {
+    kind: TransactionKind.Evm;
+    to?: BlockchainAddress;
+    value?: Amount;
+    data?: string;
+    nonce?: number;
+    gasLimit?: Amount;
+    gasPrice?: Amount;
+    maxPriorityFeePerGas?: Amount;
+    maxFeePerGas?: Amount;
+};
+export type SignHash = {
+    kind: SignatureKind.Hash;
+    hash: string;
+};
+export type Eip712Domain = {
+    name?: string;
+    version?: string;
+    chainId?: number;
+    verifyingContract?: BlockchainAddress;
+    salt?: string;
+};
+export type SignEip712TypedData = {
+    kind: SignatureKind.Eip712;
+    types: Record<string, unknown>;
+    domain: Eip712Domain;
+    message: Record<string, unknown>;
+};
+export type Wallet = {
+    id: EntityId;
+    network: BlockchainNetwork;
+    status: WalletStatus;
+    address?: string;
+    name?: string;
+    externalId?: string;
+    tags: Tag[];
+    dateCreated: IsoDatetime;
+};
+export type WalletAssets = {
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    assets: WalletAsset[];
+};
+export type WalletAsset = {
+    contract?: string;
+    symbol?: string;
+    decimals: number;
+    verified?: boolean;
+    balance: Amount;
+};
+export type WalletNfts = {
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    nfts: WalletNft[];
+};
+export type WalletNft = {
+    contract: string;
+    symbol?: string;
+    verified?: boolean;
+    tokenIds: string[];
+    count: number;
+};
+export type PaginatedWalletList = {
+    items: Wallet[];
+    nextPageToken?: string;
+};
+export type NativeTransferEvent = {
+    kind: EventKind.NativeTransfer;
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    blockNumber: number;
+    txHash: string;
+    index?: string;
+    timestamp: IsoDatetime;
+    fee?: Amount;
+    direction: TransferDirection;
+    symbol: string;
+    decimals: number;
+    verified?: boolean;
+    from: BlockchainAddress;
+    to: BlockchainAddress;
+    value: Amount;
+};
+export type Erc20TransferEvent = {
+    kind: EventKind.Erc20Transfer;
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    blockNumber: number;
+    txHash: string;
+    index?: string;
+    timestamp: IsoDatetime;
+    fee?: Amount;
+    direction: TransferDirection;
+    contract: BlockchainAddress;
+    symbol?: string;
+    decimals: number;
+    verified?: boolean;
+    from: BlockchainAddress;
+    to: BlockchainAddress;
+    value: Amount;
+};
+export type Erc721TransferEvent = {
+    kind: EventKind.Erc721Transfer;
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    blockNumber: number;
+    txHash: string;
+    index?: string;
+    timestamp: IsoDatetime;
+    fee?: Amount;
+    direction: TransferDirection;
+    contract: BlockchainAddress;
+    symbol?: string;
+    verified?: boolean;
+    from: BlockchainAddress;
+    to: BlockchainAddress;
+    tokenId: string;
+};
+export type PaginatedEventHistory = {
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    items: BlockchainEvent[];
+    nextPageToken?: string;
+};
+export type TransferRequest = {
+    id: EntityId;
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    txHash?: string;
+    requester: RequesterIdentity;
+    requestBody: TransferAssetBody;
+    status: TransferStatus;
+    fee?: Amount;
+    error?: string;
+    dateRequested: IsoDatetime;
+    dateBroadcasted?: IsoDatetime;
+    dateConfirmed?: IsoDatetime;
+};
+export type PaginatedTransferList = {
+    walletId: EntityId;
+    items: TransferRequest[];
+    nextPageToken?: string;
+};
+export type TransactionRequest = {
+    id: EntityId;
+    walletId: EntityId;
+    network: BlockchainNetwork;
+    txHash?: string;
+    requester: RequesterIdentity;
+    requestBody: BroadcastTransactionBody;
+    status: TransactionStatus;
+    error?: string;
+    fee?: Amount;
+    dateRequested: IsoDatetime;
+    dateBroadcasted?: IsoDatetime;
+    dateConfirmed?: IsoDatetime;
+};
+export type PaginatedTransactionList = {
+    walletId: EntityId;
+    items: TransactionRequest[];
+    nextPageToken?: string;
+};
+export type Signature = {
+    r: string;
+    s: string;
+    recid?: number;
+};
+export type SignatureRequest = {
+    id: EntityId;
+    walletId: EntityId;
+    requester: RequesterIdentity;
+    requestBody: GenerateSignatureBody;
+    signature?: Signature;
+    status: SignatureStatus;
+    error?: string;
+    dateRequested: IsoDatetime;
+    datePolicyResolved?: IsoDatetime;
+    dateSigned?: IsoDatetime;
+};
+export type PaginatedSignatureList = {
+    walletId: EntityId;
+    items: SignatureRequest[];
+    nextPageToken?: string;
+};
+export type RequesterIdentity = {
+    userId: EntityId;
+    tokenId?: EntityId;
+    appId?: EntityId;
+};
+export type CreateWalletBody = {
+    network: BlockchainNetwork;
+    externalId?: string;
+    tags?: Tag[];
+    name?: string;
+};
+export type TransferAssetBody = TransferNativeAsset | TransferErc20Asset | TransferErc721Asset;
+export type BroadcastTransactionBody = BroadcastEvmTransaction;
+export type GenerateSignatureBody = SignHash | SignEip712TypedData;
+export type BlockchainEvent = NativeTransferEvent | Erc20TransferEvent | Erc721TransferEvent;
+export declare enum TransferKind {
+    Native = "Native",
+    Erc20 = "Erc20",
+    Erc721 = "Erc721"
+}
+export declare enum TransactionKind {
+    Evm = "Evm"
+}
+export declare enum SignatureKind {
+    Hash = "Hash",
+    Eip712 = "Eip712"
+}
+export declare enum WalletStatus {
+    Active = "Active",
+    Creating = "Creating",
+    Failed = "Failed"
+}
+export declare enum EventKind {
+    NativeTransfer = "NativeTransfer",
+    Erc20Transfer = "Erc20Transfer",
+    Erc721Transfer = "Erc721Transfer"
+}
+export declare enum TransferDirection {
+    In = "In",
+    Out = "Out"
+}
+export declare enum TransferStatus {
+    Pending = "Pending",
+    Broadcasted = "Broadcasted",
+    Confirmed = "Confirmed",
+    Failed = "Failed"
+}
+export declare enum TransactionStatus {
+    Pending = "Pending",
+    Broadcasted = "Broadcasted",
+    Confirmed = "Confirmed",
+    Failed = "Failed"
+}
+export declare enum SignatureStatus {
+    Pending = "Pending",
+    Signed = "Signed",
+    Failed = "Failed"
+}
+export declare enum BlockchainNetwork {
+    Bitcoin = "Bitcoin",
+    BitcoinTestnet = "BitcoinTestnet",
+    Bsc = "Bsc",
+    BscTestnet = "BscTestnet",
+    Ethereum = "Ethereum",
+    EthereumGoerli = "EthereumGoerli",
+    EthereumSepolia = "EthereumSepolia",
+    Polygon = "Polygon",
+    PolygonMumbai = "PolygonMumbai",
+    Ripple = "Ripple",
+    RippleTestnet = "RippleTestnet",
+    Solana = "Solana",
+    SolanaDevnet = "SolanaDevnet",
+    Tron = "Tron",
+    TronShasta = "TronShasta"
+}

package/codegen/datamodel/Wallets/types.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BlockchainNetwork = exports.SignatureStatus = exports.TransactionStatus = exports.TransferStatus = exports.TransferDirection = exports.EventKind = exports.WalletStatus = exports.SignatureKind = exports.TransactionKind = exports.TransferKind = void 0;
+// FIXME: Missing documentation for TransferKind
+var TransferKind;
+(function (TransferKind) {
+    // FIXME: Missing documentation for Native
+    TransferKind["Native"] = "Native";
+    // FIXME: Missing documentation for Erc20
+    TransferKind["Erc20"] = "Erc20";
+    // FIXME: Missing documentation for Erc721
+    TransferKind["Erc721"] = "Erc721";
+})(TransferKind = exports.TransferKind || (exports.TransferKind = {}));
+// FIXME: Missing documentation for TransactionKind
+var TransactionKind;
+(function (TransactionKind) {
+    // FIXME: Missing documentation for Evm
+    TransactionKind["Evm"] = "Evm";
+})(TransactionKind = exports.TransactionKind || (exports.TransactionKind = {}));
+// FIXME: Missing documentation for SignatureKind
+var SignatureKind;
+(function (SignatureKind) {
+    // FIXME: Missing documentation for Hash
+    SignatureKind["Hash"] = "Hash";
+    // FIXME: Missing documentation for Eip712
+    SignatureKind["Eip712"] = "Eip712";
+})(SignatureKind = exports.SignatureKind || (exports.SignatureKind = {}));
+// FIXME: Missing documentation for WalletStatus
+var WalletStatus;
+(function (WalletStatus) {
+    // FIXME: Missing documentation for Active
+    WalletStatus["Active"] = "Active";
+    //Initial state of `AssetAccount` entity, indicating that it’s being created at the moment.
+    WalletStatus["Creating"] = "Creating";
+    // FIXME: Missing documentation for Failed
+    WalletStatus["Failed"] = "Failed";
+})(WalletStatus = exports.WalletStatus || (exports.WalletStatus = {}));
+// FIXME: Missing documentation for EventKind
+var EventKind;
+(function (EventKind) {
+    // FIXME: Missing documentation for NativeTransfer
+    EventKind["NativeTransfer"] = "NativeTransfer";
+    // FIXME: Missing documentation for Erc20Transfer
+    EventKind["Erc20Transfer"] = "Erc20Transfer";
+    // FIXME: Missing documentation for Erc721Transfer
+    EventKind["Erc721Transfer"] = "Erc721Transfer";
+})(EventKind = exports.EventKind || (exports.EventKind = {}));
+// FIXME: Missing documentation for TransferDirection
+var TransferDirection;
+(function (TransferDirection) {
+    // FIXME: Missing documentation for In
+    TransferDirection["In"] = "In";
+    // FIXME: Missing documentation for Out
+    TransferDirection["Out"] = "Out";
+})(TransferDirection = exports.TransferDirection || (exports.TransferDirection = {}));
+// FIXME: Missing documentation for TransferStatus
+var TransferStatus;
+(function (TransferStatus) {
+    // FIXME: Missing documentation for Pending
+    TransferStatus["Pending"] = "Pending";
+    // FIXME: Missing documentation for Broadcasted
+    TransferStatus["Broadcasted"] = "Broadcasted";
+    // FIXME: Missing documentation for Confirmed
+    TransferStatus["Confirmed"] = "Confirmed";
+    // FIXME: Missing documentation for Failed
+    TransferStatus["Failed"] = "Failed";
+})(TransferStatus = exports.TransferStatus || (exports.TransferStatus = {}));
+// FIXME: Missing documentation for TransactionStatus
+var TransactionStatus;
+(function (TransactionStatus) {
+    // FIXME: Missing documentation for Pending
+    TransactionStatus["Pending"] = "Pending";
+    // FIXME: Missing documentation for Broadcasted
+    TransactionStatus["Broadcasted"] = "Broadcasted";
+    // FIXME: Missing documentation for Confirmed
+    TransactionStatus["Confirmed"] = "Confirmed";
+    // FIXME: Missing documentation for Failed
+    TransactionStatus["Failed"] = "Failed";
+})(TransactionStatus = exports.TransactionStatus || (exports.TransactionStatus = {}));
+// FIXME: Missing documentation for SignatureStatus
+var SignatureStatus;
+(function (SignatureStatus) {
+    // FIXME: Missing documentation for Pending
+    SignatureStatus["Pending"] = "Pending";
+    // FIXME: Missing documentation for Signed
+    SignatureStatus["Signed"] = "Signed";
+    // FIXME: Missing documentation for Failed
+    SignatureStatus["Failed"] = "Failed";
+})(SignatureStatus = exports.SignatureStatus || (exports.SignatureStatus = {}));
+// FIXME: Missing documentation for BlockchainNetwork
+var BlockchainNetwork;
+(function (BlockchainNetwork) {
+    // FIXME: Missing documentation for Bitcoin
+    BlockchainNetwork["Bitcoin"] = "Bitcoin";
+    // FIXME: Missing documentation for BitcoinTestnet
+    BlockchainNetwork["BitcoinTestnet"] = "BitcoinTestnet";
+    // FIXME: Missing documentation for Bsc
+    BlockchainNetwork["Bsc"] = "Bsc";
+    // FIXME: Missing documentation for BscTestnet
+    BlockchainNetwork["BscTestnet"] = "BscTestnet";
+    // FIXME: Missing documentation for Ethereum
+    BlockchainNetwork["Ethereum"] = "Ethereum";
+    // FIXME: Missing documentation for EthereumGoerli
+    BlockchainNetwork["EthereumGoerli"] = "EthereumGoerli";
+    // FIXME: Missing documentation for EthereumSepolia
+    BlockchainNetwork["EthereumSepolia"] = "EthereumSepolia";
+    // FIXME: Missing documentation for Polygon
+    BlockchainNetwork["Polygon"] = "Polygon";
+    // FIXME: Missing documentation for PolygonMumbai
+    BlockchainNetwork["PolygonMumbai"] = "PolygonMumbai";
+    // FIXME: Missing documentation for Ripple
+    BlockchainNetwork["Ripple"] = "Ripple";
+    // FIXME: Missing documentation for RippleTestnet
+    BlockchainNetwork["RippleTestnet"] = "RippleTestnet";
+    // FIXME: Missing documentation for Solana
+    BlockchainNetwork["Solana"] = "Solana";
+    // FIXME: Missing documentation for SolanaDevnet
+    BlockchainNetwork["SolanaDevnet"] = "SolanaDevnet";
+    // FIXME: Missing documentation for Tron
+    BlockchainNetwork["Tron"] = "Tron";
+    // FIXME: Missing documentation for TronShasta
+    BlockchainNetwork["TronShasta"] = "TronShasta";
+})(BlockchainNetwork = exports.BlockchainNetwork || (exports.BlockchainNetwork = {}));

package/dfnsApiClient.d.ts

@@ -0,0 +1,27 @@
+import { DfnsBaseApiOptions } from './baseAuthApi';
+import { AssetsClient } from './codegen/Assets';
+import { AuthClient } from './codegen/Auth';
+import { BlockchainsClient } from './codegen/Blockchains';
+import { CallbacksClient } from './codegen/Callbacks';
+import { PermissionsClient } from './codegen/Permissions';
+import { PolicyExecutionClient } from './codegen/PolicyExecution';
+import { PolicyManagementClient } from './codegen/PolicyManagement';
+import { PublicKeysClient } from './codegen/PublicKeys';
+import { WalletsClient } from './codegen/Wallets';
+import { CredentialSigner } from './signer';
+export type DfnsApiClientOptions = DfnsBaseApiOptions & {
+    signer: CredentialSigner;
+};
+export declare class DfnsApiClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsApiClientOptions);
+    get assets(): AssetsClient;
+    get auth(): AuthClient;
+    get blockchains(): BlockchainsClient;
+    get callbacks(): CallbacksClient;
+    get permissions(): PermissionsClient;
+    get policyExecution(): PolicyExecutionClient;
+    get policyManagement(): PolicyManagementClient;
+    get publicKeys(): PublicKeysClient;
+    get wallets(): WalletsClient;
+}

package/dfnsApiClient.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsApiClient = void 0;
+const Assets_1 = require("./codegen/Assets");
+const Auth_1 = require("./codegen/Auth");
+const Blockchains_1 = require("./codegen/Blockchains");
+const Callbacks_1 = require("./codegen/Callbacks");
+const Permissions_1 = require("./codegen/Permissions");
+const PolicyExecution_1 = require("./codegen/PolicyExecution");
+const PolicyManagement_1 = require("./codegen/PolicyManagement");
+const PublicKeys_1 = require("./codegen/PublicKeys");
+const Wallets_1 = require("./codegen/Wallets");
+class DfnsApiClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    get assets() {
+        return new Assets_1.AssetsClient(this.apiOptions);
+    }
+    get auth() {
+        return new Auth_1.AuthClient(this.apiOptions);
+    }
+    get blockchains() {
+        return new Blockchains_1.BlockchainsClient(this.apiOptions);
+    }
+    get callbacks() {
+        return new Callbacks_1.CallbacksClient(this.apiOptions);
+    }
+    get permissions() {
+        return new Permissions_1.PermissionsClient(this.apiOptions);
+    }
+    get policyExecution() {
+        return new PolicyExecution_1.PolicyExecutionClient(this.apiOptions);
+    }
+    get policyManagement() {
+        return new PolicyManagement_1.PolicyManagementClient(this.apiOptions);
+    }
+    get publicKeys() {
+        return new PublicKeys_1.PublicKeysClient(this.apiOptions);
+    }
+    get wallets() {
+        return new Wallets_1.WalletsClient(this.apiOptions);
+    }
+}
+exports.DfnsApiClient = DfnsApiClient;

package/dfnsAuthenticator.d.ts

@@ -0,0 +1,17 @@
+import { CredentialStore } from './store';
+import { CredentialSigner } from './signer';
+import { CreateUserLoginChallengeRequest, CreateUserRegistrationChallengeRequest, DfnsBaseApiOptions, UserLoginResponse, UserRegistrationResponse } from './baseAuthApi';
+export type LoginRequest = CreateUserLoginChallengeRequest;
+export type LoginResponse = UserLoginResponse;
+export type RegisterRequest = CreateUserRegistrationChallengeRequest;
+export type RegisterResponse = UserRegistrationResponse;
+export type DfnsAuthenticatorOptions = Omit<DfnsBaseApiOptions, 'authToken'> & {
+    signer: CredentialSigner & Partial<CredentialStore>;
+};
+export declare class DfnsAuthenticator {
+    private apiOptions;
+    private api;
+    constructor(apiOptions: DfnsAuthenticatorOptions);
+    login(request: LoginRequest): Promise<LoginResponse>;
+    register(request: RegisterRequest): Promise<RegisterResponse>;
+}

package/dfnsAuthenticator.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsAuthenticator = void 0;
+const baseAuthApi_1 = require("./baseAuthApi");
+class DfnsAuthenticator {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    async login(request) {
+        const { challenge, challengeIdentifier, allowCredentials } = await baseAuthApi_1.BaseAuthApi.createUserLoginChallenge(request, this.apiOptions);
+        const assertion = await this.apiOptions.signer.sign(challenge, allowCredentials);
+        return baseAuthApi_1.BaseAuthApi.createUserLogin({
+            challengeIdentifier,
+            firstFactor: assertion,
+        }, this.apiOptions);
+    }
+    async register(request) {
+        if (!this.apiOptions.signer.create) {
+            throw new Error(`Provided signer does not implement 'create'`);
+        }
+        const challenge = await baseAuthApi_1.BaseAuthApi.createUserRegistrationChallenge(request, this.apiOptions);
+        const attestation = await this.apiOptions.signer.create(challenge);
+        return baseAuthApi_1.BaseAuthApi.createUserRegistration({ firstFactorCredential: attestation }, {
+            ...this.apiOptions,
+            authToken: challenge.temporaryAuthenticationToken,
+        });
+    }
+}
+exports.DfnsAuthenticator = DfnsAuthenticator;

package/dfnsDelegatedApiClient.d.ts

@@ -0,0 +1,24 @@
+import { DfnsBaseApiOptions } from './baseAuthApi';
+import { DelegatedAssetsClient } from './codegen/Assets';
+import { DelegatedBlockchainsClient } from './codegen/Blockchains';
+import { DelegatedCallbacksClient } from './codegen/Callbacks';
+import { DelegatedPermissionsClient } from './codegen/Permissions';
+import { DelegatedPolicyExecutionClient } from './codegen/PolicyExecution';
+import { DelegatedPolicyManagementClient } from './codegen/PolicyManagement';
+import { DelegatedPublicKeysClient } from './codegen/PublicKeys';
+import { DelegatedWalletsClient } from './codegen/Wallets';
+export type DfnsDelegatedApiClientOptions = DfnsBaseApiOptions & {
+    authToken: string;
+};
+export declare class DfnsDelegatedApiClient {
+    private apiOptions;
+    constructor(apiOptions: DfnsDelegatedApiClientOptions);
+    get assets(): DelegatedAssetsClient;
+    get blockchains(): DelegatedBlockchainsClient;
+    get callbacks(): DelegatedCallbacksClient;
+    get permissions(): DelegatedPermissionsClient;
+    get policyExecution(): DelegatedPolicyExecutionClient;
+    get policyManagement(): DelegatedPolicyManagementClient;
+    get publicKeys(): DelegatedPublicKeysClient;
+    get wallets(): DelegatedWalletsClient;
+}

package/dfnsDelegatedApiClient.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DfnsDelegatedApiClient = void 0;
+const Assets_1 = require("./codegen/Assets");
+const Blockchains_1 = require("./codegen/Blockchains");
+const Callbacks_1 = require("./codegen/Callbacks");
+const Permissions_1 = require("./codegen/Permissions");
+const PolicyExecution_1 = require("./codegen/PolicyExecution");
+const PolicyManagement_1 = require("./codegen/PolicyManagement");
+const PublicKeys_1 = require("./codegen/PublicKeys");
+const Wallets_1 = require("./codegen/Wallets");
+class DfnsDelegatedApiClient {
+    constructor(apiOptions) {
+        this.apiOptions = apiOptions;
+    }
+    get assets() {
+        return new Assets_1.DelegatedAssetsClient(this.apiOptions);
+    }
+    get blockchains() {
+        return new Blockchains_1.DelegatedBlockchainsClient(this.apiOptions);
+    }
+    get callbacks() {
+        return new Callbacks_1.DelegatedCallbacksClient(this.apiOptions);
+    }
+    get permissions() {
+        return new Permissions_1.DelegatedPermissionsClient(this.apiOptions);
+    }
+    get policyExecution() {
+        return new PolicyExecution_1.DelegatedPolicyExecutionClient(this.apiOptions);
+    }
+    get policyManagement() {
+        return new PolicyManagement_1.DelegatedPolicyManagementClient(this.apiOptions);
+    }
+    get publicKeys() {
+        return new PublicKeys_1.DelegatedPublicKeysClient(this.apiOptions);
+    }
+    get wallets() {
+        return new Wallets_1.DelegatedWalletsClient(this.apiOptions);
+    }
+}
+exports.DfnsDelegatedApiClient = DfnsDelegatedApiClient;

package/dfnsError.d.ts

@@ -0,0 +1,5 @@
+export declare class DfnsError extends Error {
+    httpStatus: number;
+    context?: unknown;
+    constructor(httpStatus: number, message: string, context?: unknown);
+}