@newton-xyz/sdk 1.0.5 → 1.0.6

package/dist/types/modules/avs/index.d.mts

@@ -0,0 +1,90 @@
+import { type RegisterWebhookParams, type RegisterWebhookResult, type SimulatePolicyDataParams, type SimulatePolicyDataResult, type SimulatePolicyDataWithClientParams, type SimulatePolicyDataWithClientResult, type SimulatePolicyParams, type SimulatePolicyResult, type SimulateTaskParams, type SimulateTaskResult, type SubmitEvaluationRequestParams, type SubmitIntentResult, type Task, type TaskId, type TaskResponseResult, TaskStatus, type UnregisterWebhookResult } from '@core/types/task';
+import { type Address, type PublicClient as Client, type Hex, type WalletClient } from 'viem';
+export interface CreateTaskResult {
+    task_id: Hex;
+    task_request: unknown;
+    status: 'Completed' | 'Failed';
+    aggregation_response: unknown;
+    timestamp: number;
+    error?: unknown;
+}
+export interface PendingTaskBuilder {
+    readonly taskId?: TaskId;
+    waitForTaskResponded: ({ timeoutMs, }: {
+        timeoutMs?: number;
+    }) => Promise<TaskResponseResult>;
+}
+declare const waitForTaskResponded: (publicClient: Client, args: {
+    taskId?: Hex;
+    timeoutMs?: number;
+    abortSignal?: AbortSignal;
+}, taskManagerAddress: Address, taskRequestedAtBlock?: bigint) => Promise<TaskResponseResult>;
+declare const getTaskResponseHash: (publicClient: Client, args: {
+    taskId: TaskId;
+}, taskManagerAddress: Address) => Promise<Hex | null>;
+declare const getTaskStatus: (publicClient: Client, args: {
+    taskId: TaskId;
+}, taskManagerAddress: Address, attestationValidatorAddress: Address) => Promise<TaskStatus>;
+declare function submitEvaluationRequest(walletClient: WalletClient, args: SubmitEvaluationRequestParams, taskManagerAddress: Address, apiKey: string, gatewayApiUrlOverride?: string): Promise<{
+    result: {
+        taskId: Hex;
+        txHash: Hex;
+    };
+} & PendingTaskBuilder>;
+/**
+ * Evaluate intent directly without waiting for task response confirmation on source chain.
+ * Results are to be used with `validateAttestationDirect` on NewtonPolicyClient (NewtonProverTaskManagerShared)
+ *
+ * @param walletClient - Wallet client
+ * @param args - Evaluation request parameters
+ * @param apiKey - API key
+ * @param gatewayApiUrlOverride - Gateway API URL override
+ * @returns Evaluation result
+ */
+declare function evaluateIntentDirect(walletClient: WalletClient, args: SubmitEvaluationRequestParams, apiKey: string, gatewayApiUrlOverride?: string): Promise<{
+    result: {
+        evaluationResult: boolean;
+        task: Task;
+        taskResponse: unknown;
+        blsSignature: unknown;
+    };
+}>;
+/**
+ * Submit intent and subscribe to task response on source chain (this will be slower but can be used to challenge the task evaluation)
+ * Results are to be used with `validateAttestation` on NewtonPolicyClient (NewtonProverTaskManager)
+ *
+ * @param walletClient - Wallet client
+ * @param args
+ * @param apiKey
+ * @param gatewayApiUrlOverride
+ * @returns
+ */
+declare function submitIntentAndSubscribe(walletClient: WalletClient, args: SubmitEvaluationRequestParams, apiKey: string, gatewayApiUrlOverride?: string): Promise<{
+    result: SubmitIntentResult;
+    ws: WebSocket;
+}>;
+/**
+ * Simulates task evaluation (newt_simulateTask). Forwards to an operator and returns allow/deny without executing on-chain.
+ */
+declare function simulateTask(walletClient: WalletClient, args: SimulateTaskParams, apiKey: string, gatewayApiUrlOverride?: string): Promise<SimulateTaskResult>;
+/**
+ * Simulates full Rego policy evaluation (newt_simulatePolicy). Tests policy with sample intent and policy data; may require ownership if PolicyData uses stored secrets.
+ */
+declare function simulatePolicy(walletClient: WalletClient, args: SimulatePolicyParams, apiKey: string, gatewayApiUrlOverride?: string): Promise<SimulatePolicyResult>;
+/**
+ * Simulates PolicyData WASM execution with caller-provided secrets (newt_simulatePolicyData). No ownership verification.
+ */
+declare function simulatePolicyData(walletClient: WalletClient, args: SimulatePolicyDataParams, apiKey: string, gatewayApiUrlOverride?: string): Promise<SimulatePolicyDataResult>;
+/**
+ * Simulates PolicyData WASM execution with stored secrets for a policy client (newt_simulatePolicyDataWithClient). Requires ownership.
+ */
+declare function simulatePolicyDataWithClient(walletClient: WalletClient, args: SimulatePolicyDataWithClientParams, apiKey: string, gatewayApiUrlOverride?: string): Promise<SimulatePolicyDataWithClientResult>;
+/**
+ * Register a webhook for task failure notifications (newt_registerWebhook).
+ */
+declare function registerWebhook(chainId: number, apiKey: string, params: RegisterWebhookParams, gatewayApiUrlOverride?: string): Promise<RegisterWebhookResult>;
+/**
+ * Unregister the webhook for the API key (newt_unregisterWebhook).
+ */
+declare function unregisterWebhook(chainId: number, apiKey: string, gatewayApiUrlOverride?: string): Promise<UnregisterWebhookResult>;
+export { submitEvaluationRequest, waitForTaskResponded, getTaskResponseHash, getTaskStatus, evaluateIntentDirect, submitIntentAndSubscribe, simulateTask, simulatePolicy, simulatePolicyData, simulatePolicyDataWithClient, registerWebhook, unregisterWebhook, };

package/dist/types/modules/identity/index.d.mts

@@ -0,0 +1,55 @@
+/**
+ * Newton Identity Module
+ *
+ * - `registerIdentityData` — store identity data reference on-chain with gateway co-signature
+ * - `identityDomainHash` — compute keccak256 domain identifier
+ * - `linkIdentity*` / `unlinkIdentity*` — direct contract calls to IdentityRegistry
+ */
+import type { LinkIdentityAsSignerAndUserParams, LinkIdentityAsSignerParams, LinkIdentityAsUserParams, LinkIdentityParams, RegisterIdentityDataParams, UnlinkIdentityAsSignerParams, UnlinkIdentityAsUserParams } from '@core/types/identity';
+import { type Hex, type WalletClient } from 'viem';
+/**
+ * Compute the bytes32 identity domain hash from a human-readable domain name.
+ *
+ * Matches the Rust convention: `keccak256(toBytes("kyc"))` producing a bytes32 hash.
+ */
+export declare function identityDomainHash(domainName: string): Hex;
+/**
+ * Register an identity data reference on-chain.
+ *
+ * The identity owner (msg.sender) calls this after uploading encrypted data
+ * to the gateway via `newt_uploadIdentityEncrypted`. The gateway returns a
+ * `data_ref_id`, `gateway_signature`, and `deadline` which are passed here.
+ *
+ * The contract verifies the gateway signature against `REGISTER_IDENTITY_TYPEHASH`
+ * and checks that the signer is a registered task generator.
+ */
+export declare function registerIdentityData(walletClient: WalletClient, params: RegisterIdentityDataParams): Promise<Hex>;
+/**
+ * Link identity data when the caller is both identity owner and client user.
+ * msg.sender must have submitted identity data for the given domains.
+ */
+export declare function linkIdentityAsSignerAndUser(walletClient: WalletClient, params: LinkIdentityAsSignerAndUserParams): Promise<Hex>;
+/**
+ * Link identity data as the identity owner (signer).
+ * Requires a counterparty signature from the client user.
+ */
+export declare function linkIdentityAsSigner(walletClient: WalletClient, params: LinkIdentityAsSignerParams): Promise<Hex>;
+/**
+ * Link identity data as the client user.
+ * Requires a counterparty signature from the identity owner.
+ */
+export declare function linkIdentityAsUser(walletClient: WalletClient, params: LinkIdentityAsUserParams): Promise<Hex>;
+/**
+ * Link identity data as a 3rd party with signatures from both identity owner and client user.
+ */
+export declare function linkIdentity(walletClient: WalletClient, params: LinkIdentityParams): Promise<Hex>;
+/**
+ * Unlink identity data as the identity owner (signer).
+ * Only the identity owner who created the link can call this.
+ */
+export declare function unlinkIdentityAsSigner(walletClient: WalletClient, params: UnlinkIdentityAsSignerParams): Promise<Hex>;
+/**
+ * Unlink identity data as the client user.
+ * Allows users to revoke links to their own account.
+ */
+export declare function unlinkIdentityAsUser(walletClient: WalletClient, params: UnlinkIdentityAsUserParams): Promise<Hex>;

package/dist/types/modules/policy/index.d.mts

@@ -0,0 +1,239 @@
+import type { PolicyId, PolicyParamsJson } from '@core/types/policy';
+import { type Address, type Hex, type PublicClient, type WalletClient } from 'viem';
+type InitializeContractArgs = {
+    factory: Address;
+    entrypoint: string;
+    policyCid: string;
+    schemaCid: string;
+    policyData: Address[];
+    metadataCid: string;
+    owner: Address;
+};
+/**
+ * Args for `initialize`. Callers must supply the policy code hash one of two ways:
+ *
+ * - `policyCodeHash`: pre-computed `keccak256` of the Rego policy bytes (e.g. read from
+ *   `policy_cids.json` or another out-of-band source). Takes precedence when both are set.
+ * - `policyBytes`: the raw Rego policy bytes — the SDK computes `keccak256` for you. Use
+ *   this when fetching from IPFS via `policyCid`, reading a local file, or any other
+ *   transport. Bringing the bytes lets the SDK stay browser/edge friendly without taking
+ *   an opinion on an IPFS gateway.
+ *
+ * Mirrors the resolution strategy in `newton-cli` (`commands/policy.rs`).
+ */
+export type InitializePolicyArgs = InitializeContractArgs & ({
+    policyCodeHash: Hex;
+} | {
+    policyBytes: Uint8Array;
+});
+type InitializeArgs = InitializePolicyArgs & {
+    walletClient: WalletClient;
+    policyContractAddress: Address;
+};
+export declare const policyWriteFunctions: {
+    initialize: ({ walletClient, policyContractAddress, ...args }: InitializeArgs) => Promise<`0x${string}`>;
+    renounceOwnership: ({ walletClient, policyContractAddress, }: {
+        walletClient: WalletClient;
+        policyContractAddress: Address;
+    }) => Promise<`0x${string}`>;
+    transferOwnership: ({ walletClient, policyContractAddress, ...args }: {
+        walletClient: WalletClient;
+        policyContractAddress: Address;
+        newOwner: Address;
+    }) => Promise<`0x${string}`>;
+};
+export declare const policyReadFunctions: {
+    getPolicyId: ({ publicClient, policyContractAddress, client, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+        client: Address;
+    }) => Promise<`0x${string}`>;
+    getPolicyConfig: ({ publicClient, policyContractAddress, policyId, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+        policyId: `0x${string}`;
+    }) => Promise<{
+        policyParams: string | object;
+        policyParamsHex: `0x${string}`;
+        expireAfter: number;
+    }>;
+    supportsInterface: ({ publicClient, policyContractAddress, interfaceId, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+        interfaceId: `0x${string}`;
+    }) => Promise<boolean>;
+    owner: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<Address>;
+    factory: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<Address>;
+    entrypoint: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    clientToPolicyId: ({ publicClient, policyContractAddress, client, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+        client: Address;
+    }) => Promise<`0x${string}`>;
+    policyData: ({ publicClient, policyContractAddress, index, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+        index: number;
+    }) => Promise<Address>;
+    getEntrypoint: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    getMetadataCid: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    getPolicyCid: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    getPolicyData: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<Address[]>;
+    getSchemaCid: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    isPolicyVerified: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<boolean>;
+    metadataCid: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    policyCid: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    schemaCid: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    precomputePolicyId: ({ publicClient, policyContractAddress, ...args }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+        policyContract: Address;
+        policyData: Address[];
+        params: PolicyParamsJson;
+        client: Address;
+        policyUri: string;
+        schemaUri: string;
+        entrypoint: string;
+        expireAfter?: number;
+        blockTimestamp?: bigint;
+    }) => PolicyId;
+};
+export declare const policyFunctions: {
+    initialize: ({ walletClient, policyContractAddress, ...args }: InitializeArgs) => Promise<`0x${string}`>;
+    renounceOwnership: ({ walletClient, policyContractAddress, }: {
+        walletClient: WalletClient;
+        policyContractAddress: Address;
+    }) => Promise<`0x${string}`>;
+    transferOwnership: ({ walletClient, policyContractAddress, ...args }: {
+        walletClient: WalletClient;
+        policyContractAddress: Address;
+        newOwner: Address;
+    }) => Promise<`0x${string}`>;
+    getPolicyId: ({ publicClient, policyContractAddress, client, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+        client: Address;
+    }) => Promise<`0x${string}`>;
+    getPolicyConfig: ({ publicClient, policyContractAddress, policyId, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+        policyId: `0x${string}`;
+    }) => Promise<{
+        policyParams: string | object;
+        policyParamsHex: `0x${string}`;
+        expireAfter: number;
+    }>;
+    supportsInterface: ({ publicClient, policyContractAddress, interfaceId, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+        interfaceId: `0x${string}`;
+    }) => Promise<boolean>;
+    owner: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<Address>;
+    factory: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<Address>;
+    entrypoint: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    clientToPolicyId: ({ publicClient, policyContractAddress, client, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+        client: Address;
+    }) => Promise<`0x${string}`>;
+    policyData: ({ publicClient, policyContractAddress, index, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+        index: number;
+    }) => Promise<Address>;
+    getEntrypoint: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    getMetadataCid: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    getPolicyCid: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    getPolicyData: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<Address[]>;
+    getSchemaCid: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    isPolicyVerified: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<boolean>;
+    metadataCid: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    policyCid: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    schemaCid: ({ publicClient, policyContractAddress, }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+    }) => Promise<string>;
+    precomputePolicyId: ({ publicClient, policyContractAddress, ...args }: {
+        publicClient: PublicClient;
+        policyContractAddress: Address;
+        policyContract: Address;
+        policyData: Address[];
+        params: PolicyParamsJson;
+        client: Address;
+        policyUri: string;
+        schemaUri: string;
+        entrypoint: string;
+        expireAfter?: number;
+        blockTimestamp?: bigint;
+    }) => PolicyId;
+};
+export {};

package/dist/types/modules/privacy/index.d.mts

@@ -0,0 +1,105 @@
+/**
+ * Newton Privacy Module — Client-side HPKE encryption for privacy-preserving policy evaluation.
+ *
+ * Encryption suite: X25519 KEM + HKDF-SHA256 + ChaCha20-Poly1305 (RFC 9180, Base mode).
+ * Compatible with the Rust gateway's `crates/core/src/crypto/hpke.rs`.
+ *
+ * Key design constraints:
+ * - Zero network calls during encrypt/createSecureEnvelope
+ * - Offline capable once the gateway public key is known
+ * - Ephemeral keys zeroed after encryption
+ */
+import type { CreateSecureEnvelopeParams, Ed25519KeyPair, GetConfidentialDataResult, GetIdentityEncryptedResult, PrivacyAuthorizationResult, PrivacyPublicKeyResponse, SecretsPublicKeyResponse, SecureEnvelopeResult, SignPrivacyAuthorizationParams, StoreEncryptedSecretsParams, StoreEncryptedSecretsResponse, UploadConfidentialDataParams, UploadConfidentialDataResult, UploadIdentityEncryptedParams, UploadIdentityEncryptedResponse } from '@core/types/privacy';
+/**
+ * Create a SecureEnvelope by encrypting plaintext with HPKE.
+ *
+ * This is a pure, offline function — zero network calls.
+ * The ephemeral HPKE key is generated internally and zeroed after use.
+ *
+ * SECURITY: The caller owns the signingKey buffer lifecycle and must zeroize it when done.
+ * This function copies the key internally and zeroes the copy after signing, but the
+ * original Uint8Array remains in the caller's control.
+ *
+ * @param params - Encryption parameters
+ * @param signingKey - Ed25519 private key seed (32 bytes as Uint8Array)
+ * @returns Envelope + Ed25519 signature over the serialized envelope
+ */
+export declare function createSecureEnvelope(params: CreateSecureEnvelopeParams, signingKey: Uint8Array): Promise<SecureEnvelopeResult>;
+/**
+ * Fetch the gateway's X25519 HPKE public key.
+ *
+ * Clients call this once to discover which key to encrypt SecureEnvelopes to.
+ * The result can be cached — the key only changes on gateway restart or key rotation.
+ */
+export declare function getPrivacyPublicKey(chainId: number, apiKey: string, gatewayApiUrlOverride?: string): Promise<PrivacyPublicKeyResponse>;
+/**
+ * Upload encrypted identity data to the gateway.
+ *
+ * The caller must provide a pre-built SecureEnvelope (via createSecureEnvelope)
+ * and an EIP-712 signature of the envelope JSON from the identity owner.
+ * The gateway stores the envelope and returns a data_ref_id + gateway signature
+ * for the on-chain registerIdentityData call.
+ */
+export declare function uploadIdentityEncrypted(chainId: number, apiKey: string, params: UploadIdentityEncryptedParams, gatewayApiUrlOverride?: string): Promise<UploadIdentityEncryptedResponse>;
+/**
+ * Fetch encrypted identity data by its content-hash reference ID.
+ *
+ * Used to resolve a data_ref_id (stored on-chain in IdentityRegistry) back to
+ * the actual encrypted data blob (stored off-chain in the gateway).
+ */
+export declare function getIdentityEncrypted(chainId: number, apiKey: string, dataRefId: string, gatewayApiUrlOverride?: string): Promise<GetIdentityEncryptedResult>;
+/**
+ * Fetch the gateway's X25519 HPKE public key for WASM secrets encryption.
+ *
+ * In threshold DKG mode, this returns a different key than getPrivacyPublicKey.
+ * Use this key when encrypting secrets via storeEncryptedSecrets.
+ */
+export declare function getSecretsPublicKey(chainId: number, apiKey: string, gatewayApiUrlOverride?: string): Promise<SecretsPublicKeyResponse>;
+/**
+ * Generate a random Ed25519 key pair for signing envelopes and privacy authorization.
+ *
+ * This is a pure offline function. The private key is generated from 32 bytes of
+ * cryptographically secure randomness via `crypto.getRandomValues`.
+ */
+export declare function generateSigningKeyPair(): Ed25519KeyPair;
+/**
+ * Upload HPKE-encrypted secrets for a policy client's PolicyData.
+ *
+ * The gateway decrypts the HPKE envelope, validates the plaintext against
+ * the PolicyData schema, and stores the envelope for operator-side decryption
+ * during policy evaluation.
+ */
+export declare function storeEncryptedSecrets(chainId: number, apiKey: string, params: StoreEncryptedSecretsParams, gatewayApiUrlOverride?: string): Promise<StoreEncryptedSecretsResponse>;
+/**
+ * Compute dual Ed25519 signatures for privacy-enabled task creation.
+ *
+ * Dual signatures prevent the app from forging user authorization, and ensure
+ * the app explicitly acknowledges which encrypted data refs are being used.
+ * The gateway validates both when `encrypted_data_refs` are present in `newt_createTask`.
+ *
+ * Signature scheme (must match `crates/gateway/src/processor/privacy_auth.rs`):
+ * - User signs: keccak256(abi.encodePacked(policy_client, intent_hash, ref_id_1, ref_id_2, ...))
+ * - App signs: keccak256(abi.encodePacked(policy_client, intent_hash, user_signature))
+ *
+ * This is a pure offline function — zero network calls.
+ */
+export declare function signPrivacyAuthorization(params: SignPrivacyAuthorizationParams): PrivacyAuthorizationResult;
+/**
+ * Upload HPKE-encrypted confidential data (blacklists, allowlists, sanctions lists, etc.)
+ * to the gateway.
+ *
+ * The provider encrypts data client-side using HPKE and uploads the envelope.
+ * The gateway stores it and returns a content-hash data_ref_id. The provider
+ * then calls ConfidentialDataRegistry.publishData(domain, dataRefId) on-chain.
+ *
+ * If recipientPublicKey is not provided, it is fetched from the gateway first
+ * via newt_getPrivacyPublicKey.
+ */
+export declare function uploadConfidentialData(chainId: number, apiKey: string, params: UploadConfidentialDataParams, gatewayApiUrlOverride?: string): Promise<UploadConfidentialDataResult>;
+/**
+ * Retrieve encrypted confidential data by its data reference ID.
+ *
+ * Returns the HPKE-encrypted envelope along with the domain and provider address.
+ * The caller is responsible for decryption using their HPKE private key.
+ */
+export declare function getConfidentialData(chainId: number, apiKey: string, dataRefId: string, gatewayApiUrlOverride?: string): Promise<GetConfidentialDataResult>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newton-xyz/sdk",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "Official SDK for the Newton Protocol.",
   "author": "Newton Protocol <https://x.com/newton_xyz> (https://newton.xyz)",
   "private": false,