@inco/shield-js 0.0.0-bootstrap.0 → 0.2.0

package/dist/shield/intent.js

@@ -1,29 +1,37 @@
-import { createPublicClient, encodeAbiParameters, getAbiItem, http, } from 'viem';
+import { encodeAbiParameters, http, zeroHash, } from 'viem';
 import { createBundlerClient, entryPoint07Address, } from 'viem/account-abstraction';
-import { shieldAbiStubAbi } from '../contracts/abi.js';
+import { computeErc20AssetId, erc20Asset, NATIVE_ASSET, } from '../contracts/utils.js';
 import { BundlerGasEstimateIncomplete } from '../errors.js';
 import { IntentKind } from '../generated/inco/shield/v2/drafting_pb.js';
-import { userOpFromIntentForGasEstimation } from './userop/gas-estimation.js';
-import { convertEthWeiToTokenUnits } from './userop/token-exchange.js';
-import { getChainFromId } from './utils/chain.js';
-// Main function of this file: createIntent and createDelegatedIntent
-/**
- * Create an intent with gas estimation. Generic over the intent kind: the returned
- * `Intent` variant matches the kind of the supplied `IntentOp`.
- */
-async function createIntent(intentOp, salt, signer, shieldConfig, publicClient, gas, bundlerUrl) {
-    const chain = getChainFromId(Number(shieldConfig.chainId));
-    const bundlerPublicClient = createPublicClient({
-        chain,
-        transport: http(chain.rpcUrls.default.http[0]),
-    });
+import { encodeStruct } from './abi.js';
+import { reserveUnmeasuredSignatureGas, userOpFromIntentForGasEstimation, } from './userop/gas-estimation.js';
+import { assertFeeTokenSupported, convertEthWeiToTokenUnits, } from './userop/token-exchange.js';
+import { defaultBundlerUrl } from './utils/chain.js';
+const NATIVE_ASSET_MOVEMENT = {
+    account: '0x0000000000000000000000000000000000000000',
+    assetAdapter: '0x0000000000000000000000000000000000000000',
+    movementArgs: '0x',
+};
+export function isNativeSettlement(gasAssetId) {
+    return BigInt(gasAssetId) === 0n;
+}
+async function createIntent(intentOp, salt, signer, shieldConfig, publicClient, gas, paymasterContext) {
+    const bundlerUrl = shieldConfig.bundlerUrl ?? defaultBundlerUrl(Number(shieldConfig.chainId));
     const bundlerClient = createBundlerClient({
-        client: bundlerPublicClient,
+        client: publicClient,
         transport: http(bundlerUrl),
     });
-    // Step1: build a placeholder UserOp for the bundler to estimate against
-    const placeholderUserOp = await userOpFromIntentForGasEstimation(intentOp, signer, shieldConfig, publicClient, gas);
-    // Step2: ask the bundler to fill in the gas limits
+    const feeToken = gas.feeToken;
+    const assetId = feeToken === undefined ? zeroHash : computeErc20AssetId(feeToken);
+    const feeRates = {
+        maxFeePerGas: gas.maxFeePerGas,
+        maxPriorityFeePerGas: gas.maxPriorityFeePerGas,
+    };
+    if (feeToken !== undefined) {
+        await assertFeeTokenSupported(publicClient, paymasterContext.paymaster, feeToken);
+    }
+    const usesPaymaster = !isNativeSettlement(assetId);
+    const { userOp: placeholderUserOp, signerCount } = await userOpFromIntentForGasEstimation(intentOp, shieldConfig, publicClient, gas, usesPaymaster ? paymasterContext.paymaster : undefined);
     const gasEstimate = await bundlerClient.estimateUserOperationGas({
         entryPointAddress: entryPoint07Address,
         sender: placeholderUserOp.sender,
@@ -35,18 +43,28 @@ async function createIntent(intentOp, salt, signer, shieldConfig, publicClient,
         callGasLimit: placeholderUserOp.callGasLimit,
         maxFeePerGas: placeholderUserOp.maxFeePerGas,
         maxPriorityFeePerGas: placeholderUserOp.maxPriorityFeePerGas,
-        paymasterVerificationGasLimit: placeholderUserOp.paymasterVerificationGasLimit,
-        paymasterPostOpGasLimit: placeholderUserOp.paymasterPostOpGasLimit,
+        ...(usesPaymaster
+            ? {
+                paymaster: placeholderUserOp.paymaster,
+                paymasterData: placeholderUserOp.paymasterData,
+                paymasterVerificationGasLimit: placeholderUserOp.paymasterVerificationGasLimit,
+                paymasterPostOpGasLimit: placeholderUserOp.paymasterPostOpGasLimit,
+            }
+            : {}),
     });
     const preVerificationGas = gasEstimate.preVerificationGas;
-    const verificationGasLimit = gasEstimate.verificationGasLimit;
+    const estimatedVerificationGasLimit = gasEstimate.verificationGasLimit;
     const callGasLimit = gasEstimate.callGasLimit;
-    const paymasterVerificationGasLimit = gasEstimate.paymasterVerificationGasLimit;
-    const paymasterPostOpGasLimit = gasEstimate.paymasterPostOpGasLimit;
+    const paymasterVerificationGasLimit = usesPaymaster
+        ? placeholderUserOp.paymasterVerificationGasLimit
+        : 0n;
+    const paymasterPostOpGasLimit = usesPaymaster
+        ? placeholderUserOp.paymasterPostOpGasLimit
+        : 0n;
     const missingFields = [];
     if (preVerificationGas === undefined)
         missingFields.push('preVerificationGas');
-    if (verificationGasLimit === undefined)
+    if (estimatedVerificationGasLimit === undefined)
         missingFields.push('verificationGasLimit');
     if (callGasLimit === undefined)
         missingFields.push('callGasLimit');
@@ -55,7 +73,7 @@ async function createIntent(intentOp, salt, signer, shieldConfig, publicClient,
     if (paymasterPostOpGasLimit === undefined)
         missingFields.push('paymasterPostOpGasLimit');
     if (preVerificationGas === undefined ||
-        verificationGasLimit === undefined ||
+        estimatedVerificationGasLimit === undefined ||
         callGasLimit === undefined ||
         paymasterVerificationGasLimit === undefined ||
         paymasterPostOpGasLimit === undefined) {
@@ -64,24 +82,20 @@ async function createIntent(intentOp, salt, signer, shieldConfig, publicClient,
             missingFields,
         });
     }
-    // Step3: derive `maxAmount` — the cap the user signs over, denominated
-    // in `gas.assetId` smallest-units (e.g. 1_000_000 = 1 USDC).
-    //
-    // We compute that ETH-wei cost, then convert to token units via a Chainlink RAY-precision exchange rate, ceiling-
-    // rounded to match the paymaster's on-chain rounding so the signed cap can never come in below what `_postOp` actually charges.
+    const verificationGasLimit = reserveUnmeasuredSignatureGas(estimatedVerificationGasLimit, signerCount);
     const totalGasUnits = preVerificationGas +
         verificationGasLimit +
         callGasLimit +
         paymasterVerificationGasLimit +
         paymasterPostOpGasLimit;
     const maxGasCostWei = totalGasUnits * gas.maxFeePerGas;
-    const maxAmount = await convertEthWeiToTokenUnits(publicClient, gas.assetId, maxGasCostWei);
-    // Bake in every bundler-estimated limit — the same five summed into
-    // `totalGasUnits` above — so the signed `Gas` matches the cap derived
-    // from it. Writing back only `callGasLimit` would leave the intent's
-    // other limits at the caller's placeholders, inconsistent with `maxAmount`.
+    const maxAmount = feeToken === undefined
+        ? 0n
+        : await convertEthWeiToTokenUnits(publicClient, paymasterContext.paymaster, feeToken, maxGasCostWei);
     const estimatedGas = {
-        ...gas,
+        asset: feeToken === undefined ? NATIVE_ASSET : erc20Asset(feeToken),
+        assetMovement: resolveGasAssetMovement(feeToken, paymasterContext.paymaster, paymasterContext.adapter, maxAmount),
+        ...feeRates,
         callGasLimit,
         verificationGasLimit,
         preVerificationGas,
@@ -91,98 +105,64 @@ async function createIntent(intentOp, salt, signer, shieldConfig, publicClient,
     };
     return assembleIntent(intentOp.op, signer, estimatedGas, salt);
 }
-async function createDelegatedIntent(intentOp, salt, spender, attestation, signer, shieldConfig, publicClient, gas, bundlerUrl) {
-    const intent = await createIntent(intentOp, salt, signer, shieldConfig, publicClient, gas, bundlerUrl);
-    return { intent, spender, attestation };
+function resolveGasAssetMovement(feeToken, paymaster, adapter, amount) {
+    if (feeToken === undefined) {
+        return NATIVE_ASSET_MOVEMENT;
+    }
+    return {
+        account: paymaster,
+        assetAdapter: adapter,
+        movementArgs: encodeAbiParameters([{ type: 'uint256' }], [amount]),
+    };
+}
+async function createDelegatedIntent(intentOp, salt, spender, permissionId, signer, shieldConfig, publicClient, gas, paymasterContext) {
+    const intent = await createIntent(intentOp, salt, signer, shieldConfig, publicClient, gas, paymasterContext);
+    return { intent, spender, permissionId };
 }
 function assembleIntent(op, signer, gas, salt) {
     return { op, signer: signer.address, gas, salt };
 }
-// Exported functions
-export async function createTransferIntent(transferIntentOp, salt, signer, shieldConfig, publicClient, gas, bundlerUrl) {
-    return createIntent({ kind: IntentKind.TRANSFER, op: transferIntentOp }, salt, signer, shieldConfig, publicClient, gas, bundlerUrl);
+export async function createTransferIntent(transferIntentOp, salt, signer, shieldConfig, publicClient, gas, paymasterContext) {
+    return createIntent({ kind: IntentKind.TRANSFER, op: transferIntentOp }, salt, signer, shieldConfig, publicClient, gas, paymasterContext);
 }
-export async function createWithdrawIntent(withdrawalIntentOp, salt, signer, shieldConfig, publicClient, gas, bundlerUrl) {
-    return createIntent({ kind: IntentKind.WITHDRAW, op: withdrawalIntentOp }, salt, signer, shieldConfig, publicClient, gas, bundlerUrl);
+export async function createWithdrawIntent(withdrawalIntentOp, salt, signer, shieldConfig, publicClient, gas, paymasterContext) {
+    return createIntent({ kind: IntentKind.WITHDRAW, op: withdrawalIntentOp }, salt, signer, shieldConfig, publicClient, gas, paymasterContext);
 }
-export async function createDefiInteractionIntent(defiInteractionIntentOp, salt, signer, shieldConfig, publicClient, gas, bundlerUrl) {
-    return createIntent({ kind: IntentKind.DEFI_INTERACTION, op: defiInteractionIntentOp }, salt, signer, shieldConfig, publicClient, gas, bundlerUrl);
+export async function createDefiInteractionIntent(defiInteractionIntentOp, salt, signer, shieldConfig, publicClient, gas, paymasterContext) {
+    return createIntent({ kind: IntentKind.DEFI_INTERACTION, op: defiInteractionIntentOp }, salt, signer, shieldConfig, publicClient, gas, paymasterContext);
 }
-export async function createIndividualRevocationIntent(individualRevocationIntentOp, salt, signer, shieldConfig, publicClient, gas, bundlerUrl) {
+export async function createIndividualRevocationIntent(individualRevocationIntentOp, salt, signer, shieldConfig, publicClient, gas, paymasterContext) {
     return createIntent({
         kind: IntentKind.INDIVIDUAL_REVOCATION,
         op: individualRevocationIntentOp,
-    }, salt, signer, shieldConfig, publicClient, gas, bundlerUrl);
+    }, salt, signer, shieldConfig, publicClient, gas, paymasterContext);
 }
-export async function createUserWideRevocationIntent(userWideRevocationIntentOp, salt, signer, shieldConfig, publicClient, gas, bundlerUrl) {
-    return createIntent({ kind: IntentKind.USER_WIDE_REVOCATION, op: userWideRevocationIntentOp }, salt, signer, shieldConfig, publicClient, gas, bundlerUrl);
+export async function createUserWideRevocationIntent(userWideRevocationIntentOp, salt, signer, shieldConfig, publicClient, gas, paymasterContext) {
+    return createIntent({ kind: IntentKind.USER_WIDE_REVOCATION, op: userWideRevocationIntentOp }, salt, signer, shieldConfig, publicClient, gas, paymasterContext);
 }
-export async function createDelegatedTransferIntent(transferIntentOp, salt, spender, attestation, signer, shieldConfig, publicClient, gas, bundlerUrl) {
-    return createDelegatedIntent({ kind: IntentKind.DELEGATED_TRANSFER, op: transferIntentOp }, salt, spender, attestation, signer, shieldConfig, publicClient, gas, bundlerUrl);
+export async function createDelegatedTransferIntent(transferIntentOp, salt, spender, permissionId, signer, shieldConfig, publicClient, gas, paymasterContext) {
+    return createDelegatedIntent({ kind: IntentKind.DELEGATED_TRANSFER, op: transferIntentOp }, salt, spender, permissionId, signer, shieldConfig, publicClient, gas, paymasterContext);
 }
-export async function createDelegatedWithdrawIntent(withdrawalIntentOp, salt, spender, attestation, signer, shieldConfig, publicClient, gas, bundlerUrl) {
-    return createDelegatedIntent({ kind: IntentKind.DELEGATED_WITHDRAW, op: withdrawalIntentOp }, salt, spender, attestation, signer, shieldConfig, publicClient, gas, bundlerUrl);
+export async function createDelegatedWithdrawIntent(withdrawalIntentOp, salt, spender, permissionId, signer, shieldConfig, publicClient, gas, paymasterContext) {
+    return createDelegatedIntent({ kind: IntentKind.DELEGATED_WITHDRAW, op: withdrawalIntentOp }, salt, spender, permissionId, signer, shieldConfig, publicClient, gas, paymasterContext);
 }
-export async function createDelegatedDefiInteractionIntent(defiInteractionIntentOp, salt, spender, attestation, signer, shieldConfig, publicClient, gas, bundlerUrl) {
+export async function createDelegatedDefiInteractionIntent(defiInteractionIntentOp, salt, spender, permissionId, signer, shieldConfig, publicClient, gas, paymasterContext) {
     return createDelegatedIntent({
         kind: IntentKind.DELEGATED_DEFI_INTERACTION,
         op: defiInteractionIntentOp,
-    }, salt, spender, attestation, signer, shieldConfig, publicClient, gas, bundlerUrl);
+    }, salt, spender, permissionId, signer, shieldConfig, publicClient, gas, paymasterContext);
 }
-// ABI Encoding
-const transferIntentAbi = getAbiItem({
-    abi: shieldAbiStubAbi,
-    name: 'transferIntent',
-}).inputs[0];
-const withdrawalIntentAbi = getAbiItem({
-    abi: shieldAbiStubAbi,
-    name: 'withdrawalIntent',
-}).inputs[0];
-const defiInteractionIntentAbi = getAbiItem({
-    abi: shieldAbiStubAbi,
-    name: 'defiInteractionIntent',
-}).inputs[0];
-const individualRevocationIntentAbi = getAbiItem({
-    abi: shieldAbiStubAbi,
-    name: 'individualRevocationIntent',
-}).inputs[0];
-const userWideRevocationIntentAbi = getAbiItem({
-    abi: shieldAbiStubAbi,
-    name: 'userWideRevocationIntent',
-}).inputs[0];
-const delegatedTransferIntentAbi = getAbiItem({
-    abi: shieldAbiStubAbi,
-    name: 'delegatedTransferIntent',
-}).inputs[0];
-const delegatedWithdrawalIntentAbi = getAbiItem({
-    abi: shieldAbiStubAbi,
-    name: 'delegatedWithdrawalIntent',
-}).inputs[0];
-const delegatedDefiInteractionIntentAbi = getAbiItem({
-    abi: shieldAbiStubAbi,
-    name: 'delegatedDefiInteractionIntent',
-}).inputs[0];
-/**
- * Mapping from the intent kind to the abi item.
- */
-export const intentAbi = {
-    [IntentKind.TRANSFER]: transferIntentAbi,
-    [IntentKind.WITHDRAW]: withdrawalIntentAbi,
-    [IntentKind.DEFI_INTERACTION]: defiInteractionIntentAbi,
-    [IntentKind.INDIVIDUAL_REVOCATION]: individualRevocationIntentAbi,
-    [IntentKind.USER_WIDE_REVOCATION]: userWideRevocationIntentAbi,
-    [IntentKind.DELEGATED_TRANSFER]: delegatedTransferIntentAbi,
-    [IntentKind.DELEGATED_WITHDRAW]: delegatedWithdrawalIntentAbi,
-    [IntentKind.DELEGATED_DEFI_INTERACTION]: delegatedDefiInteractionIntentAbi,
+const intentStructName = {
+    [IntentKind.TRANSFER]: 'TransferIntent',
+    [IntentKind.WITHDRAW]: 'WithdrawalIntent',
+    [IntentKind.DEFI_INTERACTION]: 'DefiInteractionIntent',
+    [IntentKind.INDIVIDUAL_REVOCATION]: 'IndividualRevocationIntent',
+    [IntentKind.USER_WIDE_REVOCATION]: 'UserWideRevocationIntent',
+    [IntentKind.DELEGATED_TRANSFER]: 'DelegatedTransferIntent',
+    [IntentKind.DELEGATED_WITHDRAW]: 'DelegatedWithdrawalIntent',
+    [IntentKind.DELEGATED_DEFI_INTERACTION]: 'DelegatedDefiInteractionIntent',
 };
-/**
- * ABI-encode an intent.
- */
 export function encodeIntent(kind, intent) {
-    // viem's `encodeAbiParameters` over-constrains the value tuple when the
-    // parameter list is a union. `intentAbi[kind]` and `IntentMapping[K]['intent']`
-    // are paired by construction, so we erase the union to a single `AbiParameter`
-    // before encoding.
-    const params = [intentAbi[kind]];
-    return encodeAbiParameters(params, [intent]);
+    const name = intentStructName[kind];
+    return encodeStruct(name, intent);
 }

package/dist/shield/permission-status.d.ts

@@ -0,0 +1,9 @@
+export declare const PERMISSION_STATUS: {
+    readonly unspecified: 0;
+    readonly active: 1;
+    readonly notYetActive: 2;
+    readonly expired: 3;
+    readonly revoked: 4;
+    readonly generationRevoked: 5;
+};
+export type PermissionStatus = (typeof PERMISSION_STATUS)[keyof typeof PERMISSION_STATUS];

package/dist/shield/permission-status.js

@@ -0,0 +1,8 @@
+export const PERMISSION_STATUS = {
+    unspecified: 0,
+    active: 1,
+    notYetActive: 2,
+    expired: 3,
+    revoked: 4,
+    generationRevoked: 5,
+};

package/dist/shield/rpc.d.ts

@@ -1,72 +1,73 @@
 import type { Client } from '@connectrpc/connect';
-import { type Hex } from 'viem';
+import { type Address, type Hex, type PublicClient, type TypedDataDomain } from 'viem';
 import type { UserOperation } from 'viem/account-abstraction';
-import type { ConductorService as ConductorServiceType } from '../generated/inco/shield/v2/conductor_connect.js';
-import { type PermissionAttestation, type PermissionAttestationRequest, type TransferIntentOp, type WithdrawalIntentOp } from './shield.eip712.gen.js';
-import type { Balance, DepositAttestation, GetBalanceParams, GetPermissionDetailsParams, GetPermissionsByOwnerParams, GetPermissionsBySpenderParams, PermissionDetails, PermissionInfo, PermissionIntent, RequestDepositAttestationParams, ShieldSigner } from './types.js';
+import { type ConductorService as ConductorServiceType } from '../generated/inco/shield/v2/conductor_pb.js';
+import { type PaymasterContext, type UserGasParams } from './intent.js';
+import { type BalanceHistoryResponse, type BalanceQuery, type BalanceResponse, type DepositAttestation, type GetPermissionDetails, type GetPermissionsByOwner, type GetPermissionsBySpender, type HistoryCursor, type OwnerGenerationResponse, type Permission, type PermissionAttestation, type PermissionDetailsResponse, type PermissionListResponse, type PermissionRequest, type PortfolioHistoryResponse, type PortfolioResponse, type ResponsePagination, type TransferIntentOp, type ViewingSession, type WithdrawalIntentOp } from './shield.eip712.gen.js';
+import type { ResolvedSigner, ShieldConfig } from './types.js';
 import type { ENTRYPOINT_VERSION } from './userop/types.js';
 export type Rpc = Client<typeof ConductorServiceType>;
 export type RpcContext = {
     rpc: Rpc;
-    domainSeparator: Hex;
-    signer: ShieldSigner;
+    domain: TypedDataDomain;
+    signer: ResolvedSigner;
     teePublicKey: CryptoKey;
+    publicClient: PublicClient;
+    shieldConfig: ShieldConfig;
+    paymasterContext: PaymasterContext;
 };
-/**
- * Inputs to the salted `permissionId` formula. Mirrors `PermissionIntent` minus
- * `intentExpiry` (which gates issuance, not identity).
- */
-export type PermissionIdInput = Omit<PermissionIntent, 'intentExpiry'>;
-/**
- * `permissionId = keccak256(abi.encode(...))` over the 9 identity fields. Must
- * match the umbo helper bit-for-bit; cross-checked in `sdk/test/permission-id.test.ts`.
- *
- * Off-chain only — no on-chain code recomputes this.
- */
+export type PermissionIdInput = Permission;
 export declare function computePermissionId(input: PermissionIdInput): Hex;
-export declare function issueTransfer(ctx: RpcContext, intentOp: TransferIntentOp): Promise<{
+export declare function issueTransfer(ctx: RpcContext, intentOp: TransferIntentOp, gas?: UserGasParams): Promise<{
     userOp: UserOperation<typeof ENTRYPOINT_VERSION>;
 }>;
-export declare function issueWithdraw(ctx: RpcContext, intentOp: WithdrawalIntentOp): Promise<{
+export declare function issueWithdraw(ctx: RpcContext, intentOp: WithdrawalIntentOp, gas?: UserGasParams): Promise<{
     userOp: UserOperation<typeof ENTRYPOINT_VERSION>;
 }>;
-/**
- * Owner-side issuance flow: sign the intent, hand it to the TEE, receive a
- * long-lived `PermissionAttestation` for the spender. The spender presents
- * the attestation on every subsequent draft.
- *
- * Doc-mandated client cross-check: recompute `permissionId` locally from
- * intent terms and verify the TEE's returned attestation matches. A mismatch
- * means the TEE substituted a different identity — fail closed.
- */
-export declare function requestPermissionAttestation(ctx: RpcContext, req: PermissionAttestationRequest): Promise<PermissionAttestation>;
-/**
- * Spender-side delegated transfer draft: sign the transfer intent, present the
- * owner's `PermissionAttestation` to the TEE, receive a spending note. The TEE
- * verifies the attestation signature and runs all 7 validation steps before
- * drafting the spend.
- */
-export declare function issueDelegatedTransfer(ctx: RpcContext, intentOp: TransferIntentOp, attestation: PermissionAttestation): Promise<{
+export declare function requestPermissionAttestation(ctx: RpcContext, req: PermissionRequest): Promise<PermissionAttestation>;
+export declare function issueDelegatedTransfer(ctx: RpcContext, intentOp: TransferIntentOp, permissionId: Hex, gas?: UserGasParams): Promise<{
     userOp: UserOperation<typeof ENTRYPOINT_VERSION>;
 }>;
-/**
- * The resulting cheque settles byte-identically to a direct withdraw —
- * observers cannot distinguish delegated from direct.
- */
-export declare function issueDelegatedWithdraw(ctx: RpcContext, intentOp: WithdrawalIntentOp, attestation: PermissionAttestation): Promise<{
+export declare function issueDelegatedWithdraw(ctx: RpcContext, intentOp: WithdrawalIntentOp, permissionId: Hex, gas?: UserGasParams): Promise<{
     userOp: UserOperation<typeof ENTRYPOINT_VERSION>;
 }>;
 export declare function revokeOne(ctx: RpcContext, params: {
     permissionId: Hex;
-}): Promise<{
+}, gas?: UserGasParams): Promise<{
     userOp: UserOperation<typeof ENTRYPOINT_VERSION>;
 }>;
-export declare function revokeAll(ctx: RpcContext): Promise<{
+export declare function revokeAll(ctx: RpcContext, gas?: UserGasParams): Promise<{
     userOp: UserOperation<typeof ENTRYPOINT_VERSION>;
 }>;
-export declare function getBalance(ctx: RpcContext, params: GetBalanceParams): Promise<Balance>;
-export declare function requestDepositAttestation(ctx: RpcContext, params: RequestDepositAttestationParams): Promise<DepositAttestation>;
-export declare function getPermissionsByOwner(ctx: RpcContext, params: GetPermissionsByOwnerParams): Promise<PermissionInfo[]>;
-export declare function getPermissionsBySpender(ctx: RpcContext, params: GetPermissionsBySpenderParams): Promise<PermissionInfo[]>;
-export declare function getPermissionDetails(ctx: RpcContext, params: GetPermissionDetailsParams): Promise<PermissionDetails>;
-export declare function getOwnerGeneration(ctx: RpcContext): Promise<bigint>;
+export type ViewingSessionParams = Pick<ViewingSession, 'expiresAt'> & Partial<Pick<ViewingSession, 'owner' | 'periodStart' | 'periodEnd'>>;
+export type SignedViewingSession = {
+    readonly session: ViewingSession;
+    readonly signature: Hex;
+};
+export declare function createViewingSession(ctx: RpcContext, params: ViewingSessionParams): Promise<SignedViewingSession>;
+export type GetBalanceParams = Pick<BalanceQuery, 'assetId'>;
+export declare function getBalance(ctx: RpcContext, viewing: SignedViewingSession, params: GetBalanceParams): Promise<BalanceResponse>;
+export declare function getPortfolio(ctx: RpcContext, viewing: SignedViewingSession): Promise<PortfolioResponse>;
+export declare function nextHistoryCursor(response: ResponsePagination): HistoryCursor | undefined;
+export type HistoryPageOptions = {
+    cursor?: HistoryCursor;
+    limit?: number;
+};
+export declare function getBalanceHistory(ctx: RpcContext, viewing: SignedViewingSession, assetId: Hex, options?: HistoryPageOptions): Promise<BalanceHistoryResponse>;
+export declare function getPortfolioHistory(ctx: RpcContext, viewing: SignedViewingSession, options?: HistoryPageOptions): Promise<PortfolioHistoryResponse>;
+export type DepositAttestationParams = {
+    recipient: Address;
+    assetAdapter: Address;
+    assetIdentificationArgs: Hex;
+    memo: Hex;
+    escapeHatch: Hex;
+};
+export declare function requestDepositAttestation(ctx: RpcContext, params: DepositAttestationParams): Promise<DepositAttestation>;
+export type GetPermissionsByOwnerParams = Partial<Pick<GetPermissionsByOwner, 'includeExpired'>>;
+export type GetPermissionsBySpenderParams = Partial<Pick<GetPermissionsBySpender, 'includeExpired'>>;
+export type GetPermissionDetailsParams = Pick<GetPermissionDetails, 'permissionId'>;
+export declare function getPermissionsByOwner(ctx: RpcContext, params?: GetPermissionsByOwnerParams): Promise<PermissionListResponse>;
+export declare function getPermissionsBySpender(ctx: RpcContext, params?: GetPermissionsBySpenderParams): Promise<PermissionListResponse>;
+export declare function getPermissionDetails(ctx: RpcContext, params: GetPermissionDetailsParams): Promise<PermissionDetailsResponse>;
+export declare function getOwnerGeneration(ctx: RpcContext): Promise<OwnerGenerationResponse>;
+export declare function getLatestHandle(ctx: RpcContext): Promise<Hex>;