opacity-issuer-core 0.2.1 → 0.3.0

package/dist/index.d.cts

@@ -1,9 +1,9 @@
-import { O as OpacityIssuerError } from './transport-uaC5Yl3p.cjs';
-export { F as FetchLike, a as OpacityAttestationError, b as OpacityConfigError } from './transport-uaC5Yl3p.cjs';
+import { O as OpacityIssuerError, a as OpacityIndexerNamespace } from './index-B8xCRZt1.cjs';
+export { F as FetchLike, K as OpacityAttestationError, M as OpacityConfigError } from './index-B8xCRZt1.cjs';
 export { AttestationSessionResponseLike, BuildSandboxAddSelfTransactionParams, BuildSandboxRegisterIssuerTransactionParams, BuildSandboxSetSelfTraitTransactionParams, DOCUMENT_ACCEPTANCE_PRIMARY_TYPE, DOCUMENT_ACCEPTANCE_TYPEHASH, DOCUMENT_ACCEPTANCE_TYPES, DOCUMENT_ATTESTOR_DOMAIN_NAME, DOCUMENT_ATTESTOR_DOMAIN_VERSION, DocumentAcceptanceMessage, DocumentAcceptanceTypedData, DocumentAttestorDomain, ECDSA_SIGNATURE_BYTES, EIP712_DOMAIN_TYPE, Eip712JsonPayload, Eip712TypeField, EthersTypedData, JsonRpcTransaction, MAX_ATTESTATION_LIFETIME_SECONDS, ProbeSandboxRegistryParams, SANDBOX_CHAIN_ID, SANDBOX_DEPLOYMENTS, SANDBOX_IMPLEMENTATION_VERSION, SANDBOX_TRAIT_IDS, SEPOLIA_CHAIN_ID, SandboxAddSelfWriteContractRequest, SandboxDeployment, SandboxProbeClient, SandboxProbeEvidence, SandboxRegisterIssuerWriteContractRequest, SandboxRegistryProbe, SandboxSetSelfTraitWriteContractRequest, ServerAttestationTypedData, ToViemTypedDataOptions, VerifyAttestationSessionFields, VerifyAttestationSessionParams, VerifyAttestationSessionResponseParams, WriteContractRequest, assertDocumentMatchesHash, buildAttestDocumentTransaction, buildDocumentAcceptanceTypedData, buildSandboxAddSelfTransaction, buildSandboxRegisterIssuerTransaction, buildSandboxSetSelfTraitTransaction, documentAttestorAbi, documentTraitId, getSandboxDeployment, hashDocument, hashDocumentAcceptance, probeSandboxRegistry, requireSandboxDeployment, sandboxAllowlistRegistryAbi, sandboxUserId, toEip1193Json, toEip1193TypedData, toEip712Json, toEip712JsonPayload, toEthersTypedData, toJsonRpcTransaction, toSandboxAddSelfWriteContractRequest, toSandboxRegisterIssuerWriteContractRequest, toSandboxSetSelfTraitWriteContractRequest, toViemTypedData, toWriteContractRequest, verifyAttestationSession } from './documents/index.cjs';
 export { A as AttestationErrorCode, a as AttestationSession, B as BuildAttestDocumentTransactionParams, b as BuildDocumentAcceptanceTypedDataParams, C as ClockOptions, D as DocumentAttestorContext, T as TransactionRequest } from './types-B4Yi7WA4.cjs';
 import * as viem from 'viem';
-import { PublicClient, WalletClient, Address, Hex, Hash, TransactionReceipt, ContractFunctionArgs, Abi, ContractFunctionName, Transport, Chain, PrivateKeyAccount } from 'viem';
+import { PublicClient, WalletClient, Address, Hex, Hash, TransactionReceipt, Abi, ContractFunctionName, ContractFunctionArgs, Transport, Chain, PrivateKeyAccount } from 'viem';
 
 /** SecurityTokenVault deposit plus errors from its ERC20 / SecurityToken mint path. */
 declare const securityTokenVaultAbi: readonly [{
@@ -10060,130 +10060,6 @@ declare function createTransfersNamespace(options?: TransferClientOptions): {
 };
 type OpacityTransfersNamespace = ReturnType<typeof createTransfersNamespace>;
 
-/** Trusted protocol addresses, obtained from the deployment manifest, not issuerId or a URL. */
-interface IssuerProtocolDeployment {
-    chainId: number;
-    factory: Address;
-    allowlistRegistry: Address;
-    beaconRegistry: Address;
-    policyEngine?: Address | undefined;
-    policyRegistry?: Address | undefined;
-    tokenTraitRegistry?: Address | undefined;
-    overrideHelper?: Address | undefined;
-    ruleSetOrchestrator?: Address | undefined;
-}
-type FactoryArgs = ContractFunctionArgs<typeof issuerFactoryAbi, 'nonpayable', 'deployToken'>;
-type IssuerTokenConfig = FactoryArgs[0];
-type IssuerEngineConfig = FactoryArgs[1];
-type IssuerAttachedPolicy = IssuerEngineConfig['policies'][number];
-interface IssuerDeployTokenParams {
-    deployment: IssuerProtocolDeployment;
-    issuer: Address;
-    config: IssuerTokenConfig;
-    engine: IssuerEngineConfig;
-    /** Optional optimistic check before send. Factory has no on-chain expected-nonce argument. */
-    expectedNonce?: bigint | undefined;
-}
-interface IssuerClientOptions {
-    chainId?: number | undefined;
-    publicClient?: PublicClient | undefined;
-    walletClient?: WalletClient | undefined;
-}
-/** Explicit wallet intent, usable by any wallet adapter. Absence of to means contract creation. */
-interface IssuerTransaction {
-    to?: Address | undefined;
-    from: Address;
-    chainId: number;
-    data: Hex;
-    value: 0n;
-}
-type IssuerDeploymentBlocker = 'issuer-not-authorized' | 'factory-not-authorized' | 'inactive-beacon' | 'policy-not-approved' | 'nonce-changed';
-interface PreparedIssuerDeployment {
-    params: IssuerDeployTokenParams;
-    blockNumber: bigint;
-    issuerNonce: bigint;
-    predictedToken: Address;
-    resolvedBeaconVariant: Hex;
-    beacon: Address;
-    issuerAuthorized: boolean;
-    factoryAuthorized: boolean;
-    /** Investor KYC is a distinct permission from issuer authorization. */
-    issuerAllowed: boolean;
-    registryAdmin: Address;
-    nativeBalance: bigint;
-    unapprovedPolicies: readonly Address[];
-    blockers: readonly IssuerDeploymentBlocker[];
-    readyToSimulate: boolean;
-    transaction: IssuerTransaction;
-}
-interface SubmittedIssuerTransaction {
-    kind: 'transaction';
-    hash: Hash;
-    transaction: IssuerTransaction;
-}
-interface SubmittedIssuerDeployment {
-    kind: 'deployment';
-    hash: Hash;
-    transaction: IssuerTransaction;
-    params: IssuerDeployTokenParams;
-    predictedToken: Address;
-    issuerNonce: bigint;
-}
-interface IssuerWaitOptions {
-    confirmations?: number | undefined;
-    timeout?: number | undefined;
-    pollingInterval?: number | undefined;
-}
-interface IssuerReceiptResult {
-    /** confirmed proves the exact transaction succeeded, not permanent state or an economic outcome. */
-    status: 'confirmed' | 'reverted' | 'unverified' | 'replaced';
-    submittedHash: Hash;
-    hash: Hash;
-    receipt: TransactionReceipt;
-    replacementReason?: 'repriced' | 'cancelled' | 'replaced' | undefined;
-}
-interface IssuerDeploymentReceiptResult extends IssuerReceiptResult {
-    /** Present only after exact transaction AND factory deployment event verification. */
-    token?: Address | undefined;
-}
-interface IssuerTokenParams {
-    chainId: number;
-    token: Address;
-    tokenId?: bigint | undefined;
-    account?: Address | undefined;
-}
-type IssuerSandboxRegistrationBlocker = 'unsupported-sandbox-version' | 'registry-paused' | 'terminal-identity';
-/** Use a trusted deployment manifest, or an explicit registry operation context. */
-type IssuerSandboxAccountParams = IssuerOperationContext | {
-    deployment: IssuerProtocolDeployment;
-    from: Address;
-};
-/** Capability marker describes the registry, not the policy registry, orchestrator or vault variant. */
-interface IssuerSandboxCapabilities {
-    chainId: number;
-    registry: Address;
-    account: Address;
-    blockNumber: bigint;
-    /** null means sandboxVersion is absent/reverts; transport failures are propagated instead. */
-    sandboxVersion: bigint | null;
-    supportsSelfOnboarding: boolean;
-    supportsSelfTraits: boolean;
-    supportsIssuerRegistration: boolean;
-    paused: boolean;
-    issuerAuthorized: boolean;
-    allowed: boolean;
-    userId: Hex;
-    entryStatus: number;
-}
-interface IssuerPolicyApprovalParams extends IssuerOperationContext {
-    implementation: Address;
-}
-/** An explicit full replacement of the target token's current attachment list. */
-interface IssuerRuleSetParams extends IssuerOperationContext {
-    token: Address;
-    rules: ContractFunctionArgs<typeof issuerRuleSetOrchestratorAbi, 'nonpayable', 'applyRuleSet'>[1];
-}
-
 /** PR #156 ordinals; these are part of the contracts' wire format. */
 declare const IssuerRuleType: {
     readonly tradingDisabled: 0;
@@ -10547,6 +10423,175 @@ declare function buildOverrideTransferTransaction(params: {
     from: Address;
 }): IssuerTransaction;
 
+/** Protocol addresses resolved from the configured indexer and verified on chain, or explicitly trusted by the caller. */
+interface IssuerProtocolDeployment {
+    chainId: number;
+    factory: Address;
+    allowlistRegistry: Address;
+    beaconRegistry: Address;
+    policyEngine?: Address | undefined;
+    policyRegistry?: Address | undefined;
+    tokenTraitRegistry?: Address | undefined;
+    overrideHelper?: Address | undefined;
+    ruleSetOrchestrator?: Address | undefined;
+}
+type FactoryArgs = ContractFunctionArgs<typeof issuerFactoryAbi, 'nonpayable', 'deployToken'>;
+type IssuerTokenConfig = FactoryArgs[0];
+type IssuerEngineConfig = FactoryArgs[1];
+type IssuerAttachedPolicy = IssuerEngineConfig['policies'][number];
+interface IssuerDeployTokenParams {
+    deployment: IssuerProtocolDeployment;
+    issuer: Address;
+    config: IssuerTokenConfig;
+    engine: IssuerEngineConfig;
+    /** Optional optimistic check before send. Factory has no on-chain expected-nonce argument. */
+    expectedNonce?: bigint | undefined;
+}
+interface IssuerClientOptions {
+    chainId?: number | undefined;
+    publicClient?: PublicClient | undefined;
+    walletClient?: WalletClient | undefined;
+    /** Required only for discoverDeployment; never inferred from static sandbox manifests. */
+    indexer?: IssuerDiscoveryIndexer | undefined;
+}
+/** Explicit wallet intent, usable by any wallet adapter. Absence of to means contract creation. */
+interface IssuerTransaction {
+    to?: Address | undefined;
+    from: Address;
+    chainId: number;
+    data: Hex;
+    value: 0n;
+}
+type IssuerDeploymentBlocker = 'issuer-not-authorized' | 'factory-not-authorized' | 'inactive-beacon' | 'policy-not-approved' | 'nonce-changed';
+interface PreparedIssuerDeployment {
+    params: IssuerDeployTokenParams;
+    blockNumber: bigint;
+    issuerNonce: bigint;
+    predictedToken: Address;
+    resolvedBeaconVariant: Hex;
+    beacon: Address;
+    issuerAuthorized: boolean;
+    factoryAuthorized: boolean;
+    /** Investor KYC is a distinct permission from issuer authorization. */
+    issuerAllowed: boolean;
+    registryAdmin: Address;
+    nativeBalance: bigint;
+    unapprovedPolicies: readonly Address[];
+    blockers: readonly IssuerDeploymentBlocker[];
+    readyToSimulate: boolean;
+    transaction: IssuerTransaction;
+}
+interface SubmittedIssuerTransaction {
+    kind: 'transaction';
+    hash: Hash;
+    transaction: IssuerTransaction;
+}
+interface SubmittedIssuerDeployment {
+    kind: 'deployment';
+    hash: Hash;
+    transaction: IssuerTransaction;
+    params: IssuerDeployTokenParams;
+    predictedToken: Address;
+    issuerNonce: bigint;
+}
+interface IssuerWaitOptions {
+    confirmations?: number | undefined;
+    timeout?: number | undefined;
+    pollingInterval?: number | undefined;
+}
+interface IssuerReceiptResult {
+    /** confirmed proves the exact transaction succeeded, not permanent state or an economic outcome. */
+    status: 'confirmed' | 'reverted' | 'unverified' | 'replaced';
+    submittedHash: Hash;
+    hash: Hash;
+    receipt: TransactionReceipt;
+    replacementReason?: 'repriced' | 'cancelled' | 'replaced' | undefined;
+}
+interface IssuerDeploymentReceiptResult extends IssuerReceiptResult {
+    /** Present only after exact transaction AND factory deployment event verification. */
+    token?: Address | undefined;
+}
+interface IssuerTokenParams {
+    chainId: number;
+    token: Address;
+    tokenId?: bigint | undefined;
+    account?: Address | undefined;
+}
+type IssuerSandboxRegistrationBlocker = 'unsupported-sandbox-version' | 'registry-paused' | 'terminal-identity';
+/** Use a trusted deployment manifest, or an explicit registry operation context. */
+type IssuerSandboxAccountParams = IssuerOperationContext | {
+    deployment: IssuerProtocolDeployment;
+    from: Address;
+};
+/** Capability marker describes the registry, not the policy registry, orchestrator or vault variant. */
+interface IssuerSandboxCapabilities {
+    chainId: number;
+    registry: Address;
+    account: Address;
+    blockNumber: bigint;
+    /** null means sandboxVersion is absent/reverts; transport failures are propagated instead. */
+    sandboxVersion: bigint | null;
+    supportsSelfOnboarding: boolean;
+    supportsSelfTraits: boolean;
+    supportsIssuerRegistration: boolean;
+    paused: boolean;
+    issuerAuthorized: boolean;
+    allowed: boolean;
+    userId: Hex;
+    entryStatus: number;
+}
+interface IssuerPolicyApprovalParams extends IssuerOperationContext {
+    implementation: Address;
+}
+/** An explicit full replacement of the target token's current attachment list. */
+interface IssuerRuleSetParams extends IssuerOperationContext {
+    token: Address;
+    rules: ContractFunctionArgs<typeof issuerRuleSetOrchestratorAbi, 'nonpayable', 'applyRuleSet'>[1];
+}
+
+/** Works with either the direct subgraph client or the existing hosted indexer endpoints. */
+type IssuerDiscoveryIndexer = Pick<OpacityIndexerNamespace, 'getMetadata' | 'getRegistry' | 'listTokens' | 'getToken'>;
+interface ResolveIssuerDeploymentParams {
+    chainId: number;
+    /** Optional existing indexed token that selects an environment; it need not belong to you. */
+    token?: Address;
+    /** Fail rather than silently truncate discovery. Default 100; maximum 1000. */
+    maxTokens?: number;
+}
+interface ResolvedIssuerDeployment {
+    deployment: IssuerProtocolDeployment;
+    /** Approved implementations of every policy kind supported by this SDK, not attached rules. */
+    policies: Record<IssuerPolicyKind, readonly Address[]>;
+    defaultBeaconVariant: Hex;
+    beacon: Address;
+    evidence: {
+        subgraphDeployment: string;
+        blockNumber: bigint;
+        blockHash: Hash;
+        timestamp: bigint;
+        verifiedAtBlock: bigint;
+        verifiedAtBlockHash: Hash;
+        sourceTokens: readonly Address[];
+    };
+}
+interface ResolveIssuerDeploymentOptions {
+    indexer?: IssuerDiscoveryIndexer | undefined;
+    publicClient?: PublicClient | undefined;
+}
+/**
+ * Read-only discovery for NEW asset deployments. No issuer ownership, preset addresses, wallet,
+ * or backend tenant is needed. The configured indexer is the environment selection boundary:
+ * canonical RPC receipts and current contract relationships independently verify its candidates.
+ *
+ * Existing indexed token deployment events identify factories because the deployed subgraph's
+ * public API does not enumerate factory contracts. An empty index cannot bootstrap a brand-new
+ * protocol deployment. Ambiguous factories require an explicit source token selection.
+ * Policy infrastructure is rooted in the registry owner's platformOperator configuration,
+ * never an issuer-selected token engine. The operator must expose its governed policyEngine.
+ * Asset-specific trait registries, administrators and helpers are deliberately never inherited.
+ */
+declare function resolveIssuerDeployment(input: ResolveIssuerDeploymentParams, options: ResolveIssuerDeploymentOptions): Promise<ResolvedIssuerDeployment>;
+
 /** Explicit opt-in to an engine-free token; base registry compliance still applies. */
 declare const EMPTY_ISSUER_ENGINE: IssuerEngineConfig;
 declare const DEFAULT_ISSUER_BEACON_VARIANT: "0x0000000000000000000000000000000000000000000000000000000000000000";
@@ -10576,7 +10621,10 @@ declare function buildIssuerAdapterDeployment(input: IssuerAdapterDeploymentPara
 /** A plain, permissionless registry deployment. Assign it to the token before setting traits. */
 declare function buildIssuerTokenTraitRegistryDeployment(input: IssuerAuxiliaryDeploymentParams): IssuerTransaction;
 
-/** Verified v3 sandbox: public issuer enrollment, eight approved policies and shared token traits. */
+/**
+ * Historical v3 snapshot, not live address discovery.
+ * @deprecated Use issuers.discoverDeployment() for the configured indexed environment.
+ */
 declare const SANDBOX_ISSUER_DEPLOYMENT: Readonly<IssuerProtocolDeployment>;
 
 declare class OpacityIssuerOperationError extends OpacityIssuerError {
@@ -10586,11 +10634,15 @@ declare class OpacityIssuerOperationError extends OpacityIssuerError {
     });
 }
 
+type IssuerDiscoverDeploymentParams = Omit<ResolveIssuerDeploymentParams, 'chainId'> & {
+    chainId?: number | undefined;
+};
 /**
- * RPC-only issuer lifecycle. Explicit sends simulate once immediately before a wallet action.
+ * Indexed deployment discovery and RPC-verified issuer lifecycle. Explicit sends simulate once immediately before a wallet action.
  * Save records immediately; after an uncertain send/receipt, reconcile before any resubmission.
  */
 declare function createIssuersNamespace(options?: IssuerClientOptions): {
+    discoverDeployment: (params?: IssuerDiscoverDeploymentParams) => Promise<ResolvedIssuerDeployment>;
     prepareDeployment: (input: IssuerDeployTokenParams) => Promise<PreparedIssuerDeployment>;
     simulateDeployment: (input: IssuerDeployTokenParams) => Promise<PreparedIssuerDeployment>;
     sendDeployment: (input: IssuerDeployTokenParams) => Promise<SubmittedIssuerDeployment>;
@@ -11085,4 +11137,257 @@ declare class SandboxTransferError extends Error {
  */
 declare function transferSandboxUser(publicClient: PublicClient, params: TransferSandboxUserParams): Promise<SandboxTransferProgress>;
 
-export { type CeilingBalanceConfig, type CreateSandboxUserParams, DEFAULT_ISSUER_BEACON_VARIANT, EMPTY_ISSUER_ENGINE, ISSUER_CONTRACTS_COMMIT, ISSUER_CONTRACTS_PR, type IssuerAdapterDeploymentParams, type IssuerAttachedPolicy, type IssuerAuxiliaryDeploymentParams, type IssuerClientOptions, IssuerDenominatorMode, type IssuerDeployTokenParams, type IssuerDeploymentBlocker, type IssuerDeploymentReceiptResult, type IssuerEngineConfig, IssuerGuardMode, type IssuerOperationContext, type IssuerOperationParams, type IssuerOverrideAuthorization, type IssuerOverrideOperation, type IssuerPolicyApprovalParams, type IssuerPolicyEngineOperation, type IssuerPolicyKind, type IssuerProtocolDeployment, type IssuerReceiptResult, type IssuerRuleSetParams, IssuerRuleType, type IssuerSandboxAccountParams, type IssuerSandboxCapabilities, type IssuerSandboxRegistrationBlocker, type IssuerSandboxRegistryOperation, type IssuerSandboxVaultAdminOperation, type IssuerSandboxVaultAdminParams, type IssuerTokenConfig, type IssuerTokenOperation, type IssuerTokenParams, type IssuerTransaction, type IssuerVaultDeploymentParams, type IssuerWaitOptions, OpacityIssuerError, OpacityIssuerOperationError, type OpacityIssuersNamespace, OpacityPurchaseError, type OpacityPurchasesNamespace, OpacityTransferError, type OpacityTransfersNamespace, type PolicyAttachment, type PolicyBatchOperation, type PolicyChange, type PolicyGuard, type PrepareSandboxUserParams, type PreparedIssuerDeployment, type PreparedPurchase, type PreparedSandboxUser, type PreparedTransfer, type PurchaseApprovalRequest, type PurchaseApprovalStep, type PurchaseBlocker, type PurchaseBuyerState, type PurchaseClientOptions, type PurchaseDeployment, type PurchaseOffering, type PurchaseParams, type PurchaseQuote, type PurchaseQuoteParams, type PurchaseReceiptResult, type PurchaseTransaction, type PurchaseWaitOptions, type PurchaseWriteRequest, type RestoreSandboxUserWalletOptions, SANDBOX_ISSUER_DEPLOYMENT, SANDBOX_PURCHASE_DEPLOYMENT, SEPOLIA_SANDBOX_MANIFEST, SandboxTransferError, type SandboxTransferProgress, type SandboxUserBlocker, SandboxUserCreationError, type SandboxUserCreationProgress, type SandboxUserFundingTransaction, type SandboxUserStep, type SandboxUserTrait, type SandboxUserTraits, type SubmittedIssuerDeployment, type SubmittedIssuerTransaction, type SubmittedPurchase, type SubmittedPurchaseApproval, type SubmittedSandboxUserFunding, type SubmittedTransfer, type TransferBlocker, type TransferClientOptions, type TransferDeployment, type TransferGasEstimate, type TransferParams, type TransferReceiptResult, type TransferRejection, type TransferSandboxUserParams, type TransferTransaction, type TransferWaitOptions, type TransferWriteRequest, buildAdapterOperation, buildConfigureVaultTransaction, buildForcedTransferTransaction, buildIssuerAdapterDeployment, buildIssuerDeployTokenTransaction, buildIssuerSandboxAddSelfTransaction, buildIssuerSandboxRegisterIssuerTransaction, buildIssuerSandboxSetSelfTraitTransaction, buildIssuerSandboxVaultDeployment, buildIssuerTokenTraitRegistryDeployment, buildIssuerVaultDeployment, buildMintTransaction, buildOverrideOperation, buildOverrideTransferTransaction, buildOverrideTransferTypedData, buildPaymentTokenOperation, buildPolicyEngineOperation, buildPolicyModuleOperation, buildPolicyRegistryOperation, buildPurchaseTransaction, buildPurchaseWriteRequest, buildRuleSetOperation, buildSandboxRegistryOperation, buildSandboxVaultOperation, buildSetIssuerAdminTransaction, buildSetUserTraitsTransactions, buildSetWalletsTransaction, buildTokenMetadataTransactions, buildTokenOperation, buildTransferTransaction, buildTransferWriteRequest, buildVaultOperation, createIssuersNamespace, createPolicyAttachment, createPolicyBatch, createPolicyReplacementBatch, createPurchasesNamespace, createSandboxUser, createTransfersNamespace, encodeAllowedTransfereeConfig, encodeCeilingBalanceConfig, encodeDenylistConfig, encodeFloorBalanceConfig, encodeHolderCountCapConfig, encodeInsiderFreezeConfig, encodeSelfTransferOnlyConfig, encodeTradingDisabledConfig, issuerAdapterAbi, issuerAdapterBytecode, issuerBeaconRegistryAbi, issuerFactoryAbi, issuerLensAbi, issuerOverrideHelperAbi, issuerOverrideTypes, issuerPaymentTokenAbi, issuerPolicyEngineAbi, issuerPolicyModuleAbis, issuerPolicyRegistryAbi, issuerPolicyTypes, issuerRegistryAbi, issuerRuleSetOrchestratorAbi, issuerSandboxVaultAbi, issuerSandboxVaultBytecode, issuerTokenAbi, issuerTokenTraitRegistryAbi, issuerTokenTraitRegistryBytecode, issuerVaultAbi, issuerVaultBytecode, parsePurchaseAmount, parseTransferAmount, prepareSandboxUser, purchasePaymentTokenAbi, purchaseRegistryAbi, purchaseSecurityTokenAbi, resolveSandboxUserTraits, restoreSandboxUserWallet, sandboxJurisdictionTraitId, sandboxTraitId, securityTokenVaultAbi, transferSandboxUser, waitForSandboxUserFunding };
+/** Dedicated capability: sandboxVersion 2 does not imply wallet linking or issuer registration. */
+declare const sandboxWalletLinkAbi: readonly [{
+    readonly type: "function";
+    readonly name: "sandboxWalletLinkingVersion";
+    readonly stateMutability: "pure";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "sandboxWalletLinkUsed";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly name: "digest";
+        readonly type: "bytes32";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+}, {
+    readonly type: "function";
+    readonly name: "sandboxLinkWallet";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly name: "newWallet";
+        readonly type: "address";
+    }, {
+        readonly name: "nonce";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint64";
+    }, {
+        readonly name: "newWalletSignature";
+        readonly type: "bytes";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly type: "event";
+    readonly name: "SandboxWalletLinked";
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly name: "existingWallet";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "newWallet";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "userId";
+        readonly type: "bytes32";
+        readonly indexed: true;
+    }, {
+        readonly name: "nonce";
+        readonly type: "bytes32";
+        readonly indexed: false;
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint64";
+        readonly indexed: false;
+    }];
+}];
+declare const sandboxWalletLinkTypes: {
+    readonly SandboxWalletLink: readonly [{
+        readonly name: "existingWallet";
+        readonly type: "address";
+    }, {
+        readonly name: "newWallet";
+        readonly type: "address";
+    }, {
+        readonly name: "userId";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "nonce";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "deadline";
+        readonly type: "uint64";
+    }];
+};
+interface SandboxWalletLinkParams {
+    chainId: number;
+    registryAddress: Address;
+    existingWallet: Address;
+    newWallet: Address;
+    nonce: Hex;
+    deadline: bigint;
+    /** Nonempty inventory for this offering. Each token must use this registry; all target balances must be zero.
+     * This does not prove absence of balances in omitted tokens. Link before any fund tokens arrive. */
+    checkedAssets: readonly {
+        token: Address;
+        tokenId: bigint;
+    }[];
+}
+interface SandboxWalletLinkIntent extends SandboxWalletLinkParams {
+    userId: Hex;
+}
+type SandboxWalletLinkBlocker = 'unsupported-wallet-linking' | 'registry-paused' | 'source-not-approved' | 'source-identity-missing' | 'target-already-linked' | 'target-not-fresh' | 'target-is-issuer' | 'consent-expired' | 'consent-used' | 'target-holds-assets';
+interface PreparedSandboxWalletLink {
+    intent: SandboxWalletLinkIntent;
+    blockNumber: bigint;
+    sourceExpiry: bigint;
+    blockers: SandboxWalletLinkBlocker[];
+    ready: boolean;
+    /** Available after signature simulation; an estimate, not a guarantee of final gas cost. */
+    gas?: {
+        estimatedGas: bigint;
+        gasPrice: bigint;
+        estimatedCost: bigint;
+        nativeBalance: bigint;
+    };
+}
+/** Public journal: no keys, signatures or signature-containing calldata. Persist with bigint support. */
+interface SandboxWalletLinkProgress {
+    kind: 'wallet-link';
+    intent: SandboxWalletLinkIntent;
+    stage: 'prepared' | 'sending' | 'submitted' | 'rejected' | 'complete';
+    hash?: Hash;
+    /** Source account nonce explicitly bound before broadcast; reconcile this nonce if no hash returned. */
+    senderNonce?: number;
+    result?: IssuerReceiptResult;
+}
+interface SubmittedSandboxWalletLink extends SandboxWalletLinkProgress {
+    stage: 'submitted' | 'complete';
+    hash: Hash;
+    senderNonce: number;
+}
+interface SendSandboxWalletLinkParams {
+    intent: SandboxWalletLinkIntent;
+    /** Volatile consent; never included in journal records or SDK errors. */
+    signature: Hex;
+    persist(progress: SandboxWalletLinkProgress): Promise<void>;
+}
+declare class SandboxWalletLinkError extends Error {
+    readonly code: 'blocked' | 'stale-intent' | 'send-in-progress' | 'rejected' | 'uncertain' | 'persistence-failed' | 'check-unavailable' | 'insufficient-gas';
+    readonly progress?: SandboxWalletLinkProgress | undefined;
+    constructor(code: 'blocked' | 'stale-intent' | 'send-in-progress' | 'rejected' | 'uncertain' | 'persistence-failed' | 'check-unavailable' | 'insufficient-gas', message: string, progress?: SandboxWalletLinkProgress | undefined);
+}
+declare function walletLinkData(value: unknown, label: string, keys: readonly string[]): void;
+declare function validateSandboxWalletLinkParams(input: SandboxWalletLinkParams): SandboxWalletLinkParams;
+declare function validateSandboxWalletLinkIntent(input: SandboxWalletLinkIntent): SandboxWalletLinkIntent;
+declare function buildSandboxWalletLinkTypedData(input: SandboxWalletLinkIntent): {
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: `0x${string}`;
+    };
+    types: {
+        readonly SandboxWalletLink: readonly [{
+            readonly name: "existingWallet";
+            readonly type: "address";
+        }, {
+            readonly name: "newWallet";
+            readonly type: "address";
+        }, {
+            readonly name: "userId";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "nonce";
+            readonly type: "bytes32";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint64";
+        }];
+    };
+    primaryType: "SandboxWalletLink";
+    message: {
+        existingWallet: `0x${string}`;
+        newWallet: `0x${string}`;
+        userId: `0x${string}`;
+        nonce: `0x${string}`;
+        deadline: bigint;
+    };
+};
+declare function buildSandboxWalletLinkTransaction(input: SandboxWalletLinkIntent, signature: Hex): {
+    from: `0x${string}`;
+    to: `0x${string}`;
+    chainId: number;
+    value: 0n;
+    data: `0x${string}`;
+};
+declare function walletLinkWaitOptions(value?: IssuerWaitOptions): IssuerWaitOptions;
+/** Direct RPC implementation; hosted SDK wrappers reuse this exact logic. No automatic sends/retries. */
+declare function createSandboxWalletLinksNamespace(options: {
+    publicClient: PublicClient;
+    walletClient?: WalletClient | undefined;
+    chainId?: number | undefined;
+}): {
+    prepareWalletLink: (input: SandboxWalletLinkParams) => Promise<PreparedSandboxWalletLink>;
+    signWalletLink: (input: SandboxWalletLinkIntent, newWalletClient: WalletClient) => Promise<Hex>;
+    preflightWalletLink: (input: SandboxWalletLinkIntent, signature: Hex) => Promise<{
+        gas: {
+            estimatedGas: bigint;
+            gasPrice: bigint;
+            estimatedCost: bigint;
+            nativeBalance: bigint;
+        };
+        intent: SandboxWalletLinkIntent;
+        blockNumber: bigint;
+        sourceExpiry: bigint;
+        blockers: SandboxWalletLinkBlocker[];
+        ready: boolean;
+    }>;
+    sendWalletLink: (input: SendSandboxWalletLinkParams) => Promise<SubmittedSandboxWalletLink>;
+    waitForWalletLink: (input: SubmittedSandboxWalletLink, wait?: IssuerWaitOptions) => Promise<IssuerReceiptResult>;
+};
+type SandboxWalletLinksNamespace = ReturnType<typeof createSandboxWalletLinksNamespace>;
+
+/** Contains a plaintext throwaway key. Store privately. userId is confirmed only after complete. */
+interface SandboxLinkedWalletProgress {
+    kind: 'linked-wallet';
+    wallet: Address;
+    existingWallet: Address;
+    privateKey: Hex;
+    chainId: number;
+    registryAddress: Address;
+    userId: Hex;
+    stage: 'created' | 'linking' | 'complete';
+    link: SandboxWalletLinkProgress;
+}
+interface CreateSandboxLinkedWalletParams {
+    chainId: number;
+    registryAddress: Address;
+    existingWallet: Address;
+    checkedAssets: SandboxWalletLinkParams['checkedAssets'];
+    sourceWalletClient: WalletClient;
+    /** Persist credentials before any signature or send; then persist every journal transition. */
+    persist(progress: SandboxLinkedWalletProgress): Promise<void>;
+    /** Omit to generate a fresh account. Supplied keys must never have held registry assets. */
+    privateKey?: Hex;
+    nonce?: Hex;
+    /** Defaults to fifteen minutes after the latest block timestamp. */
+    deadline?: bigint;
+    wait?: IssuerWaitOptions;
+}
+declare class SandboxLinkedWalletCreationError extends Error {
+    readonly progress: SandboxLinkedWalletProgress;
+    constructor(progress: SandboxLinkedWalletProgress);
+}
+/**
+ * Generate, save and link a fresh wallet. Only the existing wallet submits/pays for the transaction.
+ * Never self-onboards the new wallet, assigns a second identity, funds, or changes any traits.
+ * No automatic retries; receipt recovery uses waitForWalletLink with the saved public journal.
+ */
+declare function createSandboxLinkedWallet(publicClient: PublicClient, input: CreateSandboxLinkedWalletParams): Promise<SandboxLinkedWalletProgress>;
+/** Shape/deployment validation only; saved completion is historical and live eligibility can change. */
+declare function validateSandboxLinkedWalletProgress(input: SandboxLinkedWalletProgress): SandboxLinkedWalletProgress;
+/** Restore a completed linked test wallet without funding, onboarding, signing, or network I/O. */
+declare function restoreSandboxLinkedWallet<chain extends Chain>(input: SandboxLinkedWalletProgress, options: RestoreSandboxUserWalletOptions<chain>): WalletClient<Transport, chain, PrivateKeyAccount>;
+
+export { type CeilingBalanceConfig, type CreateSandboxLinkedWalletParams, type CreateSandboxUserParams, DEFAULT_ISSUER_BEACON_VARIANT, EMPTY_ISSUER_ENGINE, ISSUER_CONTRACTS_COMMIT, ISSUER_CONTRACTS_PR, type IssuerAdapterDeploymentParams, type IssuerAttachedPolicy, type IssuerAuxiliaryDeploymentParams, type IssuerClientOptions, IssuerDenominatorMode, type IssuerDeployTokenParams, type IssuerDeploymentBlocker, type IssuerDeploymentReceiptResult, type IssuerDiscoverDeploymentParams, type IssuerDiscoveryIndexer, type IssuerEngineConfig, IssuerGuardMode, type IssuerOperationContext, type IssuerOperationParams, type IssuerOverrideAuthorization, type IssuerOverrideOperation, type IssuerPolicyApprovalParams, type IssuerPolicyEngineOperation, type IssuerPolicyKind, type IssuerProtocolDeployment, type IssuerReceiptResult, type IssuerRuleSetParams, IssuerRuleType, type IssuerSandboxAccountParams, type IssuerSandboxCapabilities, type IssuerSandboxRegistrationBlocker, type IssuerSandboxRegistryOperation, type IssuerSandboxVaultAdminOperation, type IssuerSandboxVaultAdminParams, type IssuerTokenConfig, type IssuerTokenOperation, type IssuerTokenParams, type IssuerTransaction, type IssuerVaultDeploymentParams, type IssuerWaitOptions, OpacityIssuerError, OpacityIssuerOperationError, type OpacityIssuersNamespace, OpacityPurchaseError, type OpacityPurchasesNamespace, OpacityTransferError, type OpacityTransfersNamespace, type PolicyAttachment, type PolicyBatchOperation, type PolicyChange, type PolicyGuard, type PrepareSandboxUserParams, type PreparedIssuerDeployment, type PreparedPurchase, type PreparedSandboxUser, type PreparedSandboxWalletLink, type PreparedTransfer, type PurchaseApprovalRequest, type PurchaseApprovalStep, type PurchaseBlocker, type PurchaseBuyerState, type PurchaseClientOptions, type PurchaseDeployment, type PurchaseOffering, type PurchaseParams, type PurchaseQuote, type PurchaseQuoteParams, type PurchaseReceiptResult, type PurchaseTransaction, type PurchaseWaitOptions, type PurchaseWriteRequest, type ResolveIssuerDeploymentOptions, type ResolveIssuerDeploymentParams, type ResolvedIssuerDeployment, type RestoreSandboxUserWalletOptions, SANDBOX_ISSUER_DEPLOYMENT, SANDBOX_PURCHASE_DEPLOYMENT, SEPOLIA_SANDBOX_MANIFEST, SandboxLinkedWalletCreationError, type SandboxLinkedWalletProgress, SandboxTransferError, type SandboxTransferProgress, type SandboxUserBlocker, SandboxUserCreationError, type SandboxUserCreationProgress, type SandboxUserFundingTransaction, type SandboxUserStep, type SandboxUserTrait, type SandboxUserTraits, type SandboxWalletLinkBlocker, SandboxWalletLinkError, type SandboxWalletLinkIntent, type SandboxWalletLinkParams, type SandboxWalletLinkProgress, type SandboxWalletLinksNamespace, type SendSandboxWalletLinkParams, type SubmittedIssuerDeployment, type SubmittedIssuerTransaction, type SubmittedPurchase, type SubmittedPurchaseApproval, type SubmittedSandboxUserFunding, type SubmittedSandboxWalletLink, type SubmittedTransfer, type TransferBlocker, type TransferClientOptions, type TransferDeployment, type TransferGasEstimate, type TransferParams, type TransferReceiptResult, type TransferRejection, type TransferSandboxUserParams, type TransferTransaction, type TransferWaitOptions, type TransferWriteRequest, buildAdapterOperation, buildConfigureVaultTransaction, buildForcedTransferTransaction, buildIssuerAdapterDeployment, buildIssuerDeployTokenTransaction, buildIssuerSandboxAddSelfTransaction, buildIssuerSandboxRegisterIssuerTransaction, buildIssuerSandboxSetSelfTraitTransaction, buildIssuerSandboxVaultDeployment, buildIssuerTokenTraitRegistryDeployment, buildIssuerVaultDeployment, buildMintTransaction, buildOverrideOperation, buildOverrideTransferTransaction, buildOverrideTransferTypedData, buildPaymentTokenOperation, buildPolicyEngineOperation, buildPolicyModuleOperation, buildPolicyRegistryOperation, buildPurchaseTransaction, buildPurchaseWriteRequest, buildRuleSetOperation, buildSandboxRegistryOperation, buildSandboxVaultOperation, buildSandboxWalletLinkTransaction, buildSandboxWalletLinkTypedData, buildSetIssuerAdminTransaction, buildSetUserTraitsTransactions, buildSetWalletsTransaction, buildTokenMetadataTransactions, buildTokenOperation, buildTransferTransaction, buildTransferWriteRequest, buildVaultOperation, createIssuersNamespace, createPolicyAttachment, createPolicyBatch, createPolicyReplacementBatch, createPurchasesNamespace, createSandboxLinkedWallet, createSandboxUser, createSandboxWalletLinksNamespace, createTransfersNamespace, encodeAllowedTransfereeConfig, encodeCeilingBalanceConfig, encodeDenylistConfig, encodeFloorBalanceConfig, encodeHolderCountCapConfig, encodeInsiderFreezeConfig, encodeSelfTransferOnlyConfig, encodeTradingDisabledConfig, issuerAdapterAbi, issuerAdapterBytecode, issuerBeaconRegistryAbi, issuerFactoryAbi, issuerLensAbi, issuerOverrideHelperAbi, issuerOverrideTypes, issuerPaymentTokenAbi, issuerPolicyEngineAbi, issuerPolicyModuleAbis, issuerPolicyRegistryAbi, issuerPolicyTypes, issuerRegistryAbi, issuerRuleSetOrchestratorAbi, issuerSandboxVaultAbi, issuerSandboxVaultBytecode, issuerTokenAbi, issuerTokenTraitRegistryAbi, issuerTokenTraitRegistryBytecode, issuerVaultAbi, issuerVaultBytecode, parsePurchaseAmount, parseTransferAmount, prepareSandboxUser, purchasePaymentTokenAbi, purchaseRegistryAbi, purchaseSecurityTokenAbi, resolveIssuerDeployment, resolveSandboxUserTraits, restoreSandboxLinkedWallet, restoreSandboxUserWallet, sandboxJurisdictionTraitId, sandboxTraitId, sandboxWalletLinkAbi, sandboxWalletLinkTypes, securityTokenVaultAbi, transferSandboxUser, validateSandboxLinkedWalletProgress, validateSandboxWalletLinkIntent, validateSandboxWalletLinkParams, waitForSandboxUserFunding, walletLinkData, walletLinkWaitOptions };