@privy-io/api-types 0.10.0 → 0.12.0

package/src/resources/policies.ts

@@ -4,287 +4,8 @@ import { APIResource } from '../core/resource';
 import * as PoliciesAPI from './policies';
 import * as SharedAPI from './shared';
 import * as WalletsAPI from './wallets/wallets';
-import { APIPromise } from '../core/api-promise';
-import { buildHeaders } from '../internal/headers';
-import { RequestOptions } from '../internal/request-options';
-import { path } from '../internal/utils/path';
 
-/**
- * Operations related to policies
- */
-export class Policies extends APIResource {
-  /**
-   * Create a new policy.
-   *
-   * @example
-   * ```ts
-   * const policy = await client.policies.create({
-   *   chain_type: 'ethereum',
-   *   name: 'x',
-   *   rules: [
-   *     {
-   *       action: 'ALLOW',
-   *       conditions: [
-   *         {
-   *           field: 'to',
-   *           field_source: 'ethereum_transaction',
-   *           operator: 'eq',
-   *           value: 'string',
-   *         },
-   *       ],
-   *       method: 'eth_sendTransaction',
-   *       name: 'x',
-   *     },
-   *   ],
-   *   version: '1.0',
-   * });
-   * ```
-   */
-  create(params: PolicyCreateParams, options?: RequestOptions): APIPromise<Policy> {
-    const { 'privy-idempotency-key': privyIdempotencyKey, ...body } = params;
-    return this._client.post('/v1/policies', {
-      body,
-      ...options,
-      headers: buildHeaders([
-        { ...(privyIdempotencyKey != null ? { 'privy-idempotency-key': privyIdempotencyKey } : undefined) },
-        options?.headers,
-      ]),
-    });
-  }
-
-  /**
-   * Create a new rule for a policy.
-   *
-   * @example
-   * ```ts
-   * const policyRuleResponse =
-   *   await client.policies._createRule(
-   *     'xxxxxxxxxxxxxxxxxxxxxxxx',
-   *     {
-   *       action: 'ALLOW',
-   *       conditions: [
-   *         {
-   *           field: 'to',
-   *           field_source: 'ethereum_transaction',
-   *           operator: 'eq',
-   *           value: 'string',
-   *         },
-   *       ],
-   *       method: 'eth_sendTransaction',
-   *       name: 'x',
-   *     },
-   *   );
-   * ```
-   */
-  _createRule(
-    policyID: string,
-    params: PolicyCreateRuleParams,
-    options?: RequestOptions,
-  ): APIPromise<PolicyRuleResponse> {
-    const {
-      'privy-authorization-signature': privyAuthorizationSignature,
-      'privy-request-expiry': privyRequestExpiry,
-      ...body
-    } = params;
-    return this._client.post(path`/v1/policies/${policyID}/rules`, {
-      body,
-      ...options,
-      headers: buildHeaders([
-        {
-          ...(privyAuthorizationSignature != null ?
-            { 'privy-authorization-signature': privyAuthorizationSignature }
-          : undefined),
-          ...(privyRequestExpiry != null ? { 'privy-request-expiry': privyRequestExpiry } : undefined),
-        },
-        options?.headers,
-      ]),
-    });
-  }
-
-  /**
-   * Delete a policy by policy ID.
-   *
-   * @example
-   * ```ts
-   * const successResponse = await client.policies._delete(
-   *   'xxxxxxxxxxxxxxxxxxxxxxxx',
-   * );
-   * ```
-   */
-  _delete(
-    policyID: string,
-    params: PolicyDeleteParams | null | undefined = {},
-    options?: RequestOptions,
-  ): APIPromise<SharedAPI.SuccessResponse> {
-    const {
-      'privy-authorization-signature': privyAuthorizationSignature,
-      'privy-request-expiry': privyRequestExpiry,
-    } = params ?? {};
-    return this._client.delete(path`/v1/policies/${policyID}`, {
-      ...options,
-      headers: buildHeaders([
-        {
-          ...(privyAuthorizationSignature != null ?
-            { 'privy-authorization-signature': privyAuthorizationSignature }
-          : undefined),
-          ...(privyRequestExpiry != null ? { 'privy-request-expiry': privyRequestExpiry } : undefined),
-        },
-        options?.headers,
-      ]),
-    });
-  }
-
-  /**
-   * Delete a rule by policy ID and rule ID.
-   *
-   * @example
-   * ```ts
-   * const successResponse = await client.policies._deleteRule(
-   *   'xxxxxxxxxxxxxxxxxxxxxxxx',
-   *   { policy_id: 'xxxxxxxxxxxxxxxxxxxxxxxx' },
-   * );
-   * ```
-   */
-  _deleteRule(
-    ruleID: string,
-    params: PolicyDeleteRuleParams,
-    options?: RequestOptions,
-  ): APIPromise<SharedAPI.SuccessResponse> {
-    const {
-      policy_id,
-      'privy-authorization-signature': privyAuthorizationSignature,
-      'privy-request-expiry': privyRequestExpiry,
-    } = params;
-    return this._client.delete(path`/v1/policies/${policy_id}/rules/${ruleID}`, {
-      ...options,
-      headers: buildHeaders([
-        {
-          ...(privyAuthorizationSignature != null ?
-            { 'privy-authorization-signature': privyAuthorizationSignature }
-          : undefined),
-          ...(privyRequestExpiry != null ? { 'privy-request-expiry': privyRequestExpiry } : undefined),
-        },
-        options?.headers,
-      ]),
-    });
-  }
-
-  /**
-   * Update a policy by policy ID.
-   *
-   * @example
-   * ```ts
-   * const policy = await client.policies._update(
-   *   'xxxxxxxxxxxxxxxxxxxxxxxx',
-   * );
-   * ```
-   */
-  _update(policyID: string, params: PolicyUpdateParams, options?: RequestOptions): APIPromise<Policy> {
-    const {
-      'privy-authorization-signature': privyAuthorizationSignature,
-      'privy-request-expiry': privyRequestExpiry,
-      ...body
-    } = params;
-    return this._client.patch(path`/v1/policies/${policyID}`, {
-      body,
-      ...options,
-      headers: buildHeaders([
-        {
-          ...(privyAuthorizationSignature != null ?
-            { 'privy-authorization-signature': privyAuthorizationSignature }
-          : undefined),
-          ...(privyRequestExpiry != null ? { 'privy-request-expiry': privyRequestExpiry } : undefined),
-        },
-        options?.headers,
-      ]),
-    });
-  }
-
-  /**
-   * Update a rule by policy ID and rule ID.
-   *
-   * @example
-   * ```ts
-   * const policyRuleResponse =
-   *   await client.policies._updateRule(
-   *     'xxxxxxxxxxxxxxxxxxxxxxxx',
-   *     {
-   *       policy_id: 'xxxxxxxxxxxxxxxxxxxxxxxx',
-   *       action: 'ALLOW',
-   *       conditions: [
-   *         {
-   *           field: 'to',
-   *           field_source: 'ethereum_transaction',
-   *           operator: 'eq',
-   *           value: 'string',
-   *         },
-   *       ],
-   *       method: 'eth_sendTransaction',
-   *       name: 'x',
-   *     },
-   *   );
-   * ```
-   */
-  _updateRule(
-    ruleID: string,
-    params: PolicyUpdateRuleParams,
-    options?: RequestOptions,
-  ): APIPromise<PolicyRuleResponse> {
-    const {
-      policy_id,
-      'privy-authorization-signature': privyAuthorizationSignature,
-      'privy-request-expiry': privyRequestExpiry,
-      ...body
-    } = params;
-    return this._client.patch(path`/v1/policies/${policy_id}/rules/${ruleID}`, {
-      body,
-      ...options,
-      headers: buildHeaders([
-        {
-          ...(privyAuthorizationSignature != null ?
-            { 'privy-authorization-signature': privyAuthorizationSignature }
-          : undefined),
-          ...(privyRequestExpiry != null ? { 'privy-request-expiry': privyRequestExpiry } : undefined),
-        },
-        options?.headers,
-      ]),
-    });
-  }
-
-  /**
-   * Get a policy by policy ID.
-   *
-   * @example
-   * ```ts
-   * const policy = await client.policies.get(
-   *   'xxxxxxxxxxxxxxxxxxxxxxxx',
-   * );
-   * ```
-   */
-  get(policyID: string, options?: RequestOptions): APIPromise<Policy> {
-    return this._client.get(path`/v1/policies/${policyID}`, options);
-  }
-
-  /**
-   * Get a rule by policy ID and rule ID.
-   *
-   * @example
-   * ```ts
-   * const policyRuleResponse = await client.policies.getRule(
-   *   'xxxxxxxxxxxxxxxxxxxxxxxx',
-   *   { policy_id: 'xxxxxxxxxxxxxxxxxxxxxxxx' },
-   * );
-   * ```
-   */
-  getRule(
-    ruleID: string,
-    params: PolicyGetRuleParams,
-    options?: RequestOptions,
-  ): APIPromise<PolicyRuleResponse> {
-    const { policy_id } = params;
-    return this._client.get(path`/v1/policies/${policy_id}/rules/${ruleID}`, options);
-  }
-}
+export class Policies extends APIResource {}
 
 /**
  * A parameter in a Solidity ABI function or event definition.
@@ -734,11 +455,9 @@ export type PolicyMethod =
   | 'eth_signUserOperation'
   | 'eth_signTypedData_v4'
   | 'eth_sign7702Authorization'
-  | 'personal_sign'
   | 'wallet_sendCalls'
   | 'signTransaction'
   | 'signAndSendTransaction'
-  | 'signMessage'
   | 'exportPrivateKey'
   | 'exportSeedPhrase'
   | 'signTransactionBytes'
@@ -1046,212 +765,6 @@ export interface UpdateConditionSetRequestBody {
   owner_id?: SharedAPI.OwnerIDInput | null;
 }
 
-export interface PolicyCreateParams {
-  /**
-   * Body param: The wallet chain types.
-   */
-  chain_type: WalletsAPI.WalletChainType;
-
-  /**
-   * Body param: Name to assign to policy.
-   */
-  name: string;
-
-  /**
-   * Body param
-   */
-  rules: Array<PolicyCreateParams.Rule>;
-
-  /**
-   * Body param: Version of the policy. Currently, 1.0 is the only version.
-   */
-  version: '1.0';
-
-  /**
-   * Body param: The owner of the resource, specified as a Privy user ID, a P-256
-   * public key, or null to remove the current owner.
-   */
-  owner?: SharedAPI.OwnerInput | null;
-
-  /**
-   * Body param: The key quorum ID to set as the owner of the resource. If you
-   * provide this, do not specify an owner.
-   */
-  owner_id?: SharedAPI.OwnerIDInput | null;
-
-  /**
-   * Header param: Idempotency keys ensure API requests are executed only once within
-   * a 24-hour window.
-   */
-  'privy-idempotency-key'?: string;
-}
-
-export namespace PolicyCreateParams {
-  export interface Rule {
-    /**
-     * The action to take when a policy rule matches.
-     */
-    action: PoliciesAPI.PolicyAction;
-
-    conditions: Array<PoliciesAPI.PolicyCondition>;
-
-    /**
-     * Method the rule applies to.
-     */
-    method: PoliciesAPI.PolicyMethod;
-
-    name: string;
-
-    id?: string;
-  }
-}
-
-export interface PolicyCreateRuleParams {
-  /**
-   * Body param: The action to take when a policy rule matches.
-   */
-  action: PolicyAction;
-
-  /**
-   * Body param
-   */
-  conditions: Array<PolicyCondition>;
-
-  /**
-   * Body param: Method the rule applies to.
-   */
-  method: PolicyMethod;
-
-  /**
-   * Body param
-   */
-  name: string;
-
-  /**
-   * Header param: Request authorization signature. If multiple signatures are
-   * required, they should be comma separated.
-   */
-  'privy-authorization-signature'?: string;
-
-  /**
-   * Header param: Request expiry. Value is a Unix timestamp in milliseconds
-   * representing the deadline by which the request must be processed.
-   */
-  'privy-request-expiry'?: string;
-}
-
-export interface PolicyDeleteParams {
-  /**
-   * Request authorization signature. If multiple signatures are required, they
-   * should be comma separated.
-   */
-  'privy-authorization-signature'?: string;
-
-  /**
-   * Request expiry. Value is a Unix timestamp in milliseconds representing the
-   * deadline by which the request must be processed.
-   */
-  'privy-request-expiry'?: string;
-}
-
-export interface PolicyDeleteRuleParams {
-  /**
-   * Path param
-   */
-  policy_id: string;
-
-  /**
-   * Header param: Request authorization signature. If multiple signatures are
-   * required, they should be comma separated.
-   */
-  'privy-authorization-signature'?: string;
-
-  /**
-   * Header param: Request expiry. Value is a Unix timestamp in milliseconds
-   * representing the deadline by which the request must be processed.
-   */
-  'privy-request-expiry'?: string;
-}
-
-export interface PolicyUpdateParams {
-  /**
-   * Body param: Name to assign to policy.
-   */
-  name?: string;
-
-  /**
-   * Body param: The owner of the resource, specified as a Privy user ID, a P-256
-   * public key, or null to remove the current owner.
-   */
-  owner?: SharedAPI.OwnerInput | null;
-
-  /**
-   * Body param: The key quorum ID to set as the owner of the resource. If you
-   * provide this, do not specify an owner.
-   */
-  owner_id?: SharedAPI.OwnerIDInput | null;
-
-  /**
-   * Body param
-   */
-  rules?: Array<PolicyRuleRequestBody>;
-
-  /**
-   * Header param: Request authorization signature. If multiple signatures are
-   * required, they should be comma separated.
-   */
-  'privy-authorization-signature'?: string;
-
-  /**
-   * Header param: Request expiry. Value is a Unix timestamp in milliseconds
-   * representing the deadline by which the request must be processed.
-   */
-  'privy-request-expiry'?: string;
-}
-
-export interface PolicyUpdateRuleParams {
-  /**
-   * Path param
-   */
-  policy_id: string;
-
-  /**
-   * Body param: The action to take when a policy rule matches.
-   */
-  action: PolicyAction;
-
-  /**
-   * Body param
-   */
-  conditions: Array<PolicyCondition>;
-
-  /**
-   * Body param: Method the rule applies to.
-   */
-  method: PolicyMethod;
-
-  /**
-   * Body param
-   */
-  name: string;
-
-  /**
-   * Header param: Request authorization signature. If multiple signatures are
-   * required, they should be comma separated.
-   */
-  'privy-authorization-signature'?: string;
-
-  /**
-   * Header param: Request expiry. Value is a Unix timestamp in milliseconds
-   * representing the deadline by which the request must be processed.
-   */
-  'privy-request-expiry'?: string;
-}
-
-export interface PolicyGetRuleParams {
-  policy_id: string;
-}
-
 export declare namespace Policies {
   export {
     type AbiParameter as AbiParameter,
@@ -1295,12 +808,5 @@ export declare namespace Policies {
     type TronCalldataCondition as TronCalldataCondition,
     type TronTransactionCondition as TronTransactionCondition,
     type UpdateConditionSetRequestBody as UpdateConditionSetRequestBody,
-    type PolicyCreateParams as PolicyCreateParams,
-    type PolicyCreateRuleParams as PolicyCreateRuleParams,
-    type PolicyDeleteParams as PolicyDeleteParams,
-    type PolicyDeleteRuleParams as PolicyDeleteRuleParams,
-    type PolicyUpdateParams as PolicyUpdateParams,
-    type PolicyUpdateRuleParams as PolicyUpdateRuleParams,
-    type PolicyGetRuleParams as PolicyGetRuleParams,
   };
 }

package/src/resources/swaps.ts

@@ -6,28 +6,55 @@ import * as WalletsAPI from './wallets/wallets';
 export class Swaps extends APIResource {}
 
 /**
- * Input for requesting a token swap quote.
+ * The output side of a swap execution request.
  */
-export interface SwapQuoteRequestBody {
+export interface SwapDestination {
   /**
-   * Amount in base units (e.g., wei for ETH).
+   * Token contract address to buy, or "native" for the chain's native token.
    */
-  amount: string;
+  asset_address: string;
 
   /**
-   * Chain identifier (e.g., "eip155:1" for Ethereum mainnet).
+   * CAIP-2 chain identifier for the destination. Must match source chain —
+   * cross-chain swaps are not yet supported. Defaults to source chain if omitted.
    */
-  caip2: string;
+  caip2?: string;
+}
 
+/**
+ * The output side of a swap quote request.
+ */
+export interface SwapQuoteDestination {
   /**
-   * Token address to sell, or "native" for the chain's native token.
+   * Token contract address to buy, or "native" for the chain's native token.
    */
-  input_token: string;
+  asset_address: string;
 
   /**
-   * Token address to buy, or "native" for the chain's native token.
+   * CAIP-2 chain identifier for the destination. Must match source chain —
+   * cross-chain swaps are not yet supported. Defaults to source chain if omitted.
    */
-  output_token: string;
+  caip2?: string;
+}
+
+/**
+ * Input for requesting a token swap quote.
+ */
+export interface SwapQuoteRequestBody {
+  /**
+   * Amount in base units (e.g., wei for ETH). Must be a non-negative integer string.
+   */
+  base_amount: string;
+
+  /**
+   * The output side of a swap quote request.
+   */
+  destination: SwapQuoteDestination;
+
+  /**
+   * The input side of a swap request, including token and chain.
+   */
+  source: SwapSource;
 
   /**
    * Whether the amount refers to the input token or output token.
@@ -86,46 +113,53 @@ export interface SwapQuoteResponse {
  */
 export interface SwapRequestBody {
   /**
-   * Amount in base units (e.g., wei for ETH).
+   * Amount in base units (e.g., wei for ETH). Must be a non-negative integer string.
    */
-  amount: string;
+  base_amount: string;
 
   /**
-   * Chain identifier (e.g., "eip155:1" for Ethereum mainnet).
+   * The output side of a swap execution request.
    */
-  caip2: string;
+  destination: SwapDestination;
 
   /**
-   * Token address to sell, or "native" for the chain's native token.
+   * The input side of a swap request, including token and chain.
    */
-  input_token: string;
+  source: SwapSource;
 
   /**
-   * Token address to buy, or "native" for the chain's native token.
+   * Whether the amount refers to the input token or output token.
    */
-  output_token: string;
+  amount_type?: WalletsAPI.AmountType;
 
   /**
-   * Whether the amount refers to the input token or output token.
+   * Maximum slippage tolerance in basis points (e.g., 50 for 0.5%).
    */
-  amount_type?: WalletsAPI.AmountType;
+  slippage_bps?: number;
+}
 
+/**
+ * The input side of a swap request, including token and chain.
+ */
+export interface SwapSource {
   /**
-   * Address to receive the output tokens. Defaults to the wallet address if not
-   * specified.
+   * Token contract address to sell, or "native" for the chain's native token.
    */
-  recipient?: string;
+  asset_address: string;
 
   /**
-   * Maximum slippage tolerance in basis points (e.g., 50 for 0.5%).
+   * CAIP-2 chain identifier (e.g., "eip155:1").
    */
-  slippage_bps?: number;
+  caip2: string;
 }
 
 export declare namespace Swaps {
   export {
+    type SwapDestination as SwapDestination,
+    type SwapQuoteDestination as SwapQuoteDestination,
     type SwapQuoteRequestBody as SwapQuoteRequestBody,
     type SwapQuoteResponse as SwapQuoteResponse,
     type SwapRequestBody as SwapRequestBody,
+    type SwapSource as SwapSource,
   };
 }