@omegax/protocol-sdk 0.5.0 → 0.6.3

package/README.md

@@ -61,7 +61,11 @@ npm install @omegax/protocol-sdk
 ### 1) Create clients
 
 ```ts
-import { createConnection, createProtocolClient, createRpcClient } from '@omegax/protocol-sdk';
+import {
+  createConnection,
+  createProtocolClient,
+  createRpcClient,
+} from '@omegax/protocol-sdk';
 
 const connection = createConnection({
   network: 'devnet',
@@ -77,7 +81,7 @@ const rpc = createRpcClient(connection);
 ### 2) Build an unsigned reward-claim transaction
 
 ```ts
-const tx = protocol.buildSubmitRewardClaimTx!({
+const tx = protocol.buildSubmitRewardClaimTx({
   claimant: '<claimant-pubkey>',
   poolAddress: '<pool-pubkey>',
   member: '<member-pubkey>',
@@ -183,6 +187,9 @@ For the normal local workspace layout, this reads from:
 Run the full local compatibility gate before pushing SDK changes that may affect protocol behavior:
 
 ```bash
+npm run typecheck
+npm run lint
+npm run format:check
 npm run verify:protocol:local
 ```
 
@@ -204,12 +211,15 @@ npm run sdk:check
 
 Latest fixture sync metadata:
 
-- Source commit: `e32313b5c49fb06a609252f845845fcf2d49e98d`
-- Fixture SHA-256: `da54336ff190407d1dfa89ae8ca976c1f025cf3c53ffdabb853b661c157e4ee9`
+- Source commit: `eb6c94226f034233d0eb6990e7feddcf7bf80642`
+- Fixture SHA-256: `1001bdd4a979f115a9589e1dd309676776aad90672a1aeae0ab63863a466cfb2`
 
 ## Development commands
 
 ```bash
+npm run typecheck
+npm run lint
+npm run format:check
 npm run build
 npm test
 npm pack --dry-run

package/dist/claims.js

@@ -1,35 +1,12 @@
 import nacl from 'tweetnacl';
 import { PublicKey, SystemProgram, Transaction, TransactionInstruction, } from '@solana/web3.js';
-import { anchorDiscriminator, encodeU64Le, fromHex, } from './utils.js';
+import { fromHex } from './utils.js';
 import { decodeSolanaTransaction, solanaTransactionFirstSignature, solanaTransactionIntentMessageBytes, solanaTransactionMessageBytes, solanaTransactionRequiredSigner, solanaTransactionSignerSignature, } from './transactions.js';
 import { deriveClaimPda, deriveConfigPda, deriveOutcomeAggregatePda, derivePoolCompliancePolicyPda, derivePoolOraclePolicyPda, derivePoolTreasuryReservePda, derivePoolTermsPda, deriveMembershipPda, ZERO_PUBKEY, } from './protocol_seeds.js';
-const SUBMIT_REWARD_CLAIM_DISCRIMINATOR = anchorDiscriminator('global', 'submit_reward_claim');
+import { encodeSubmitRewardClaimPayload, validateRewardClaimOptionalAccounts, } from './internal/reward-claim.js';
 function bytesEqual(left, right) {
-    return left.length === right.length && left.every((value, index) => value === right[index]);
-}
-function validateRewardClaimOptionalAccounts(params) {
-    const providedCount = [
-        params.poolAssetVault,
-        params.poolVaultTokenAccount,
-        params.recipientTokenAccount,
-    ].filter((value) => typeof value === 'string' && value.length > 0).length;
-    if (providedCount !== 0 && providedCount !== 3) {
-        throw new Error('poolAssetVault, poolVaultTokenAccount, and recipientTokenAccount must be provided together');
-    }
-}
-function serializeSubmitRewardClaimPayload(params) {
-    const cycleHash = fromHex(params.cycleHashHex, 32);
-    const ruleHash = fromHex(params.ruleHashHex, 32);
-    const intentHash = fromHex(params.intentHashHex, 32);
-    return Buffer.concat([
-        SUBMIT_REWARD_CLAIM_DISCRIMINATOR,
-        new PublicKey(params.member).toBuffer(),
-        Buffer.from(cycleHash),
-        Buffer.from(ruleHash),
-        Buffer.from(intentHash),
-        encodeU64Le(params.payoutAmount),
-        new PublicKey(params.recipient).toBuffer(),
-    ]);
+    return (left.length === right.length &&
+        left.every((value, index) => value === right[index]));
 }
 export function buildUnsignedRewardClaimTx(params) {
     validateRewardClaimOptionalAccounts(params);
@@ -110,13 +87,29 @@ export function buildUnsignedRewardClaimTx(params) {
             isSigner: false,
             isWritable: params.cohortSettlementRoot != null,
         },
-        { pubkey: new PublicKey(params.recipientSystemAccount), isSigner: false, isWritable: true },
+        {
+            pubkey: new PublicKey(params.recipientSystemAccount),
+            isSigner: false,
+            isWritable: true,
+        },
         { pubkey: claimDelegateAccount, isSigner: false, isWritable: false },
         { pubkey: poolAssetVaultAccount, isSigner: false, isWritable: false },
-        { pubkey: poolVaultTokenAccount, isSigner: false, isWritable: params.poolVaultTokenAccount != null },
-        { pubkey: recipientTokenAccount, isSigner: false, isWritable: params.recipientTokenAccount != null },
+        {
+            pubkey: poolVaultTokenAccount,
+            isSigner: false,
+            isWritable: params.poolVaultTokenAccount != null,
+        },
+        {
+            pubkey: recipientTokenAccount,
+            isSigner: false,
+            isWritable: params.recipientTokenAccount != null,
+        },
         { pubkey: claimRecordPda, isSigner: false, isWritable: true },
-        { pubkey: new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'), isSigner: false, isWritable: false },
+        {
+            pubkey: new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'),
+            isSigner: false,
+            isWritable: false,
+        },
         { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
         {
             pubkey: params.includePoolCompliancePolicy
@@ -129,7 +122,7 @@ export function buildUnsignedRewardClaimTx(params) {
     const instruction = new TransactionInstruction({
         keys,
         programId,
-        data: serializeSubmitRewardClaimPayload(params),
+        data: encodeSubmitRewardClaimPayload(params),
     });
     const tx = new Transaction({
         recentBlockhash: params.recentBlockhash,
@@ -157,7 +150,8 @@ export function validateSignedClaimTx(params) {
             signer: null,
         };
     }
-    if (typeof params.expectedUnsignedTxBase64 === 'string' && params.expectedUnsignedTxBase64.length > 0) {
+    if (typeof params.expectedUnsignedTxBase64 === 'string' &&
+        params.expectedUnsignedTxBase64.length > 0) {
         try {
             const expectedUnsignedTx = decodeSolanaTransaction(params.expectedUnsignedTxBase64);
             const signedMessageBytes = solanaTransactionMessageBytes(tx);
@@ -248,23 +242,24 @@ export function normalizeClaimSimulationFailure(params) {
             ? params.err
             : JSON.stringify(params.err));
     const haystack = `${logsText}\n${errText}`;
-    if (haystack.includes('insufficientpoolliquidity')
-        || haystack.includes('insufficient funds')
-        || haystack.includes('insufficient lamports')) {
+    if (haystack.includes('insufficientpoolliquidity') ||
+        haystack.includes('insufficient funds') ||
+        haystack.includes('insufficient lamports')) {
         return {
             code: 'simulation_failed_insufficient_funds',
             message: 'Pool does not have sufficient liquidity for this claim.',
         };
     }
-    if (haystack.includes('poolnotactive') || haystack.includes('pool is not active')) {
+    if (haystack.includes('poolnotactive') ||
+        haystack.includes('pool is not active')) {
         return {
             code: 'simulation_failed_pool_paused',
             message: 'Pool is paused or not active for claims.',
         };
     }
-    if (haystack.includes('membershipnotactive')
-        || haystack.includes('membership member mismatch')
-        || haystack.includes('membership')) {
+    if (haystack.includes('membershipnotactive') ||
+        haystack.includes('membership member mismatch') ||
+        haystack.includes('membership')) {
         return {
             code: 'simulation_failed_membership_invalid',
             message: 'Membership is not active for this pool.',
@@ -278,9 +273,9 @@ export function normalizeClaimSimulationFailure(params) {
 export function normalizeClaimRpcFailure(error) {
     const message = error instanceof Error ? error.message : String(error);
     const normalized = lower(message);
-    if (normalized.includes('timeout')
-        || normalized.includes('timed out')
-        || normalized.includes('blockhash not found')) {
+    if (normalized.includes('timeout') ||
+        normalized.includes('timed out') ||
+        normalized.includes('blockhash not found')) {
         return {
             code: 'rpc_timeout',
             message: message || 'RPC timeout while submitting claim transaction.',

package/dist/internal/protocol/all.d.ts

@@ -0,0 +1,283 @@
+import { AddressLookupTableAccount, Connection, PublicKey, Transaction, VersionedTransaction } from '@solana/web3.js';
+import type { BuildAttestPremiumPaidOffchainTxParams, BuildActivateCycleWithQuoteSolTxParams, BuildActivateCycleWithQuoteSplTxParams, BuildApproveCoverageClaimTxParams, BuildAttachCoverageClaimDecisionSupportTxParams, BuildCancelPoolLiquidityRedemptionTxParams, BuildClaimApprovedCoveragePayoutTxParams, BuildCloseCoverageClaimTxParams, BuildCloseOutcomeSchemaTxParams, BuildClaimOracleTxParams, BuildCreatePoolTxParams, BuildDenyCoverageClaimTxParams, BuildDepositPoolLiquiditySolTxParams, BuildDepositPoolLiquiditySplTxParams, BuildEnrollMemberInvitePermitTxParams, BuildEnrollMemberOpenTxParams, BuildEnrollMemberTokenGateTxParams, BuildFailPoolLiquidityRedemptionTxParams, BuildFinalizeCohortSettlementRootTxParams, BuildFulfillPoolLiquidityRedemptionSolTxParams, BuildFulfillPoolLiquidityRedemptionSplTxParams, BuildFinalizeUnstakeTxParams, BuildFundPoolSolTxParams, BuildFundPoolSplTxParams, BuildInitializePoolLiquiditySolTxParams, BuildInitializePoolLiquiditySplTxParams, BuildInitializeProtocolTxParams, BuildIssuePolicyPositionTxParams, BuildMintPolicyNftTxParams, BuildOpenCycleOutcomeDisputeTxParams, BuildPayCoverageClaimTxParams, BuildPayPremiumSolTxParams, BuildPayPremiumSplTxParams, BuildCreatePolicySeriesTxParams, BuildRegisterPoolCapitalClassTxParams, BuildUpsertPolicySeriesPaymentOptionTxParams, BuildRedeemPoolLiquiditySolTxParams, BuildRedeemPoolLiquiditySplTxParams, BuildRegisterInviteIssuerTxParams, BuildRegisterOutcomeSchemaTxParams, BuildRegisterOracleTxParams, BuildBackfillSchemaDependencyLedgerTxParams, BuildRequestPoolLiquidityRedemptionTxParams, BuildRequestUnstakeTxParams, BuildResolveCycleOutcomeDisputeTxParams, BuildReviewCoverageClaimTxParams, BuildRotateGovernanceAuthorityTxParams, BuildSchedulePoolLiquidityRedemptionTxParams, BuildSetClaimDelegateTxParams, BuildSetPoolAutomationPolicyTxParams, BuildSetPoolCompliancePolicyTxParams, BuildSetPoolOraclePolicyTxParams, BuildSetPoolOraclePermissionsTxParams, BuildSetPoolOracleTxParams, BuildSetPoolControlAuthoritiesTxParams, BuildSetPoolLiquidityEnabledTxParams, BuildSetPoolTermsHashTxParams, BuildSetPoolRiskControlsTxParams, BuildSetPoolStatusTxParams, BuildSetProtocolParamsTxParams, BuildSetPoolCoverageReserveFloorTxParams, BuildSettleCycleCommitmentSolTxParams, BuildSettleCycleCommitmentTxParams, BuildSettleCoverageClaimTxParams, BuildSlashOracleTxParams, BuildStakeOracleTxParams, BuildSubmitCoverageClaimTxParams, BuildSubscribePolicySeriesTxParams, BuildSubmitRewardClaimTxParams, BuildUpdatePolicySeriesTxParams, BuildUpdateOracleProfileTxParams, BuildVerifyOutcomeSchemaTxParams, BuildUpdateOracleMetadataTxParams, BuildSetPoolOutcomeRuleTxParams, BuildSubmitOutcomeAttestationVoteTxParams, BuildFinalizeCycleOutcomeTxParams, BuildWithdrawPoolTreasurySolTxParams, BuildWithdrawPoolTreasurySplTxParams, BuildWithdrawPoolOracleFeeSolTxParams, BuildWithdrawPoolOracleFeeSplTxParams, BuildWithdrawProtocolFeeSolTxParams, BuildWithdrawProtocolFeeSplTxParams, ProtocolClaimRecordAccount, ProtocolClaimDelegateAuthorizationAccount, ProtocolClient, ProtocolCoverageClaimRecordAccount, ProtocolPolicyPositionNftAccount, ProtocolPolicySeriesAccount, ProtocolPolicySeriesPaymentOptionAccount, ProtocolCohortSettlementRootAccount, ProtocolCycleQuoteReplayAccount, ProtocolAttestationVoteAccount, ProtocolConfigAccount, ProtocolPolicyPositionAccount, ProtocolCycleOutcomeAccount, ProtocolCycleOutcomeAggregateAccount, ProtocolInviteIssuerRegistryEntryAccount, ProtocolMembershipRecordAccount, ProtocolEnrollmentPermitReplayAccount, ProtocolOracleProfileAccount, ProtocolOracleStakePositionAccount, ProtocolOracleRegistryEntryAccount, ProtocolPoolAccount, ProtocolPoolAssetVaultAccount, ProtocolPoolAutomationPolicyAccount, ProtocolPoolCapitalClassAccount, ProtocolPoolCompliancePolicyAccount, ProtocolPoolControlAuthorityAccount, ProtocolPoolLiquidityConfigAccount, ProtocolPoolOracleFeeVaultAccount, ProtocolPoolOraclePermissionSetAccount, ProtocolPoolOraclePolicyAccount, ProtocolPoolRedemptionRequestAccount, ProtocolPoolRiskConfigAccount, ProtocolPoolTreasuryReserveAccount, ProtocolFeeVaultAccount, ProtocolPoolTermsAccount, ProtocolPoolOracleApprovalAccount, ProtocolPoolOutcomeRuleAccount, ProtocolPremiumLedgerAccount, ProtocolPremiumAttestationReplayAccount, ProtocolOutcomeSchemaRegistryEntryAccount, ProtocolSchemaDependencyLedgerAccount, ProtocolCycleQuoteFields, ProtocolMemberCycleAccount } from '../../types.js';
+export declare const PROTOCOL_PROGRAM_ID = "Bn6eixac1QEEVErGBvBjxAd6pgB9e2q4XHvAkinQ5y1B";
+export declare function buildCycleQuoteMessage(fields: ProtocolCycleQuoteFields): Buffer;
+export declare function buildCycleQuoteHash(input: ProtocolCycleQuoteFields | Uint8Array): Buffer;
+export declare function buildCycleQuoteSignatureMessage(input: ProtocolCycleQuoteFields | Uint8Array): Buffer;
+export declare function compileTransactionToV0(transaction: Transaction, lookupTableAccounts: AddressLookupTableAccount[]): VersionedTransaction;
+export declare function decodePoolAccount(address: string, data: Buffer): ProtocolPoolAccount;
+export declare function decodeOracleRegistryEntryAccount(address: string, data: Buffer): ProtocolOracleRegistryEntryAccount;
+export declare function decodeOracleProfileAccount(address: string, data: Buffer): ProtocolOracleProfileAccount;
+export declare function decodePoolOracleApprovalAccount(address: string, data: Buffer): ProtocolPoolOracleApprovalAccount;
+export declare function decodeMembershipRecordAccount(address: string, data: Buffer): ProtocolMembershipRecordAccount;
+export declare function decodeCycleOutcomeAccount(address: string, data: Buffer): ProtocolCycleOutcomeAccount;
+export declare function decodeCycleOutcomeAggregateAccount(address: string, data: Buffer): ProtocolCycleOutcomeAggregateAccount;
+export declare function decodeProtocolConfigAccount(address: string, data: Buffer): ProtocolConfigAccount;
+export declare function decodeOracleStakePositionAccount(address: string, data: Buffer): ProtocolOracleStakePositionAccount;
+export declare function decodePoolOraclePolicyAccount(address: string, data: Buffer): ProtocolPoolOraclePolicyAccount;
+export declare function decodePoolTermsAccount(address: string, data: Buffer): ProtocolPoolTermsAccount;
+export declare function decodePoolAssetVaultAccount(address: string, data: Buffer): ProtocolPoolAssetVaultAccount;
+export declare function decodePoolLiquidityConfigAccount(address: string, data: Buffer): ProtocolPoolLiquidityConfigAccount;
+export declare function decodePoolRiskConfigAccount(address: string, data: Buffer): ProtocolPoolRiskConfigAccount;
+export declare function decodePoolCapitalClassAccount(address: string, data: Buffer): ProtocolPoolCapitalClassAccount;
+export declare function decodePoolCompliancePolicyAccount(address: string, data: Buffer): ProtocolPoolCompliancePolicyAccount;
+export declare function decodePoolControlAuthorityAccount(address: string, data: Buffer): ProtocolPoolControlAuthorityAccount;
+export declare function decodePoolAutomationPolicyAccount(address: string, data: Buffer): ProtocolPoolAutomationPolicyAccount;
+export declare function decodeProtocolFeeVaultAccount(address: string, data: Buffer): ProtocolFeeVaultAccount;
+export declare function decodePoolOracleFeeVaultAccount(address: string, data: Buffer): ProtocolPoolOracleFeeVaultAccount;
+export declare function decodePoolOraclePermissionSetAccount(address: string, data: Buffer): ProtocolPoolOraclePermissionSetAccount;
+export declare function decodeMemberCycleAccount(address: string, data: Buffer): ProtocolMemberCycleAccount;
+export declare function decodeCycleQuoteReplayAccount(address: string, data: Buffer): ProtocolCycleQuoteReplayAccount;
+export declare function decodePoolTreasuryReserveAccount(address: string, data: Buffer): ProtocolPoolTreasuryReserveAccount;
+export declare function decodeCohortSettlementRootAccount(address: string, data: Buffer): ProtocolCohortSettlementRootAccount;
+export declare function decodeOutcomeSchemaAccount(address: string, data: Buffer): ProtocolOutcomeSchemaRegistryEntryAccount;
+export declare function decodeSchemaDependencyLedgerAccount(address: string, data: Buffer): ProtocolSchemaDependencyLedgerAccount;
+export declare function decodePoolOutcomeRuleAccount(address: string, data: Buffer): ProtocolPoolOutcomeRuleAccount;
+export declare function decodeInviteIssuerAccount(address: string, data: Buffer): ProtocolInviteIssuerRegistryEntryAccount;
+export declare function decodeEnrollmentPermitReplayAccount(address: string, data: Buffer): ProtocolEnrollmentPermitReplayAccount;
+export declare function decodeAttestationVoteAccount(address: string, data: Buffer): ProtocolAttestationVoteAccount;
+export declare function decodeClaimDelegateAccount(address: string, data: Buffer): ProtocolClaimDelegateAuthorizationAccount;
+export declare function decodePolicyPositionAccount(address: string, data: Buffer): ProtocolPolicyPositionAccount;
+export declare function decodePremiumLedgerAccount(address: string, data: Buffer): ProtocolPremiumLedgerAccount;
+export declare function decodeClaimRecordAccount(address: string, data: Buffer): ProtocolClaimRecordAccount;
+export declare function decodePolicySeriesAccount(address: string, data: Buffer): ProtocolPolicySeriesAccount;
+export declare function decodePolicySeriesPaymentOptionAccount(address: string, data: Buffer): ProtocolPolicySeriesPaymentOptionAccount;
+export declare function decodePolicyPositionNftAccount(address: string, data: Buffer): ProtocolPolicyPositionNftAccount;
+export declare function decodePremiumAttestationReplayAccount(address: string, data: Buffer): ProtocolPremiumAttestationReplayAccount;
+export declare function decodeCoverageClaimRecordAccount(address: string, data: Buffer): ProtocolCoverageClaimRecordAccount;
+export declare function decodePoolRedemptionRequestAccount(address: string, data: Buffer): ProtocolPoolRedemptionRequestAccount;
+export declare function createProtocolBuilders(connection: Connection, programId: PublicKey): {
+    buildSubmitOutcomeAttestationVoteTx(params: BuildSubmitOutcomeAttestationVoteTxParams): Transaction;
+    buildFinalizeCycleOutcomeTx(params: BuildFinalizeCycleOutcomeTxParams): Transaction;
+    buildOpenCycleOutcomeDisputeTx(params: BuildOpenCycleOutcomeDisputeTxParams): Transaction;
+    buildResolveCycleOutcomeDisputeTx(params: BuildResolveCycleOutcomeDisputeTxParams): Transaction;
+    buildInitializeProtocolTx(params: BuildInitializeProtocolTxParams): Transaction;
+    buildSetProtocolParamsTx(params: BuildSetProtocolParamsTxParams): Transaction;
+    buildRotateGovernanceAuthorityTx(params: BuildRotateGovernanceAuthorityTxParams): Transaction;
+    buildRegisterOracleTx(params: BuildRegisterOracleTxParams): Transaction;
+    buildClaimOracleTx(params: BuildClaimOracleTxParams): Transaction;
+    buildUpdateOracleProfileTx(params: BuildUpdateOracleProfileTxParams): Transaction;
+    buildUpdateOracleMetadataTx(params: BuildUpdateOracleMetadataTxParams): Transaction;
+    buildStakeOracleTx(params: BuildStakeOracleTxParams): Transaction;
+    buildRequestUnstakeTx(params: BuildRequestUnstakeTxParams): Transaction;
+    buildFinalizeUnstakeTx(params: BuildFinalizeUnstakeTxParams): Transaction;
+    buildSlashOracleTx(params: BuildSlashOracleTxParams): Transaction;
+    buildCreatePoolTx(params: BuildCreatePoolTxParams): Transaction;
+    buildSetPoolStatusTx(params: BuildSetPoolStatusTxParams): Transaction;
+    buildSetPoolOracleTx(params: BuildSetPoolOracleTxParams): Transaction;
+    buildSetPoolOraclePolicyTx(params: BuildSetPoolOraclePolicyTxParams): Transaction;
+    buildSetPoolRiskControlsTx(params: BuildSetPoolRiskControlsTxParams): Transaction;
+    buildSetPoolCompliancePolicyTx(params: BuildSetPoolCompliancePolicyTxParams): Transaction;
+    buildSetPoolControlAuthoritiesTx(params: BuildSetPoolControlAuthoritiesTxParams): Transaction;
+    buildSetPoolAutomationPolicyTx(params: BuildSetPoolAutomationPolicyTxParams): Transaction;
+    buildSetPoolOraclePermissionsTx(params: BuildSetPoolOraclePermissionsTxParams): Transaction;
+    buildSetPoolCoverageReserveFloorTx(params: BuildSetPoolCoverageReserveFloorTxParams): Transaction;
+    buildSetPoolTermsHashTx(params: BuildSetPoolTermsHashTxParams): Transaction;
+    buildRegisterOutcomeSchemaTx(params: BuildRegisterOutcomeSchemaTxParams): Transaction;
+    buildVerifyOutcomeSchemaTx(params: BuildVerifyOutcomeSchemaTxParams): Transaction;
+    buildBackfillSchemaDependencyLedgerTx(params: BuildBackfillSchemaDependencyLedgerTxParams): Transaction;
+    buildCloseOutcomeSchemaTx(params: BuildCloseOutcomeSchemaTxParams): Transaction;
+    buildSetPolicySeriesOutcomeRuleTx(params: BuildSetPoolOutcomeRuleTxParams): Transaction;
+    buildRegisterInviteIssuerTx(params: BuildRegisterInviteIssuerTxParams): Transaction;
+    buildEnrollMemberOpenTx(params: BuildEnrollMemberOpenTxParams): Transaction;
+    buildEnrollMemberTokenGateTx(params: BuildEnrollMemberTokenGateTxParams): Transaction;
+    buildEnrollMemberInvitePermitTx(params: BuildEnrollMemberInvitePermitTxParams): Transaction;
+    buildSetClaimDelegateTx(params: BuildSetClaimDelegateTxParams): Transaction;
+    buildFundPoolSolTx(params: BuildFundPoolSolTxParams): Transaction;
+    buildFundPoolSplTx(params: BuildFundPoolSplTxParams): Transaction;
+    buildInitializePoolLiquiditySolTx(params: BuildInitializePoolLiquiditySolTxParams): Transaction;
+    buildInitializePoolLiquiditySplTx(params: BuildInitializePoolLiquiditySplTxParams): Transaction;
+    buildSetPoolLiquidityEnabledTx(params: BuildSetPoolLiquidityEnabledTxParams): Transaction;
+    buildRegisterPoolCapitalClassTx(params: BuildRegisterPoolCapitalClassTxParams): Transaction;
+    buildDepositPoolLiquiditySolTx(params: BuildDepositPoolLiquiditySolTxParams): Transaction;
+    buildDepositPoolLiquiditySplTx(params: BuildDepositPoolLiquiditySplTxParams): Transaction;
+    buildRedeemPoolLiquiditySolTx(params: BuildRedeemPoolLiquiditySolTxParams): Transaction;
+    buildRedeemPoolLiquiditySplTx(params: BuildRedeemPoolLiquiditySplTxParams): Transaction;
+    buildRequestPoolLiquidityRedemptionTx(params: BuildRequestPoolLiquidityRedemptionTxParams): Transaction;
+    buildSchedulePoolLiquidityRedemptionTx(params: BuildSchedulePoolLiquidityRedemptionTxParams): Transaction;
+    buildCancelPoolLiquidityRedemptionTx(params: BuildCancelPoolLiquidityRedemptionTxParams): Transaction;
+    buildFailPoolLiquidityRedemptionTx(params: BuildFailPoolLiquidityRedemptionTxParams): Transaction;
+    buildFulfillPoolLiquidityRedemptionSolTx(params: BuildFulfillPoolLiquidityRedemptionSolTxParams): Transaction;
+    buildFulfillPoolLiquidityRedemptionSplTx(params: BuildFulfillPoolLiquidityRedemptionSplTxParams): Transaction;
+    buildSubmitRewardClaimTx(params: BuildSubmitRewardClaimTxParams): Transaction;
+    buildCreatePolicySeriesTx(params: BuildCreatePolicySeriesTxParams): Transaction;
+    buildUpsertPolicySeriesPaymentOptionTx(params: BuildUpsertPolicySeriesPaymentOptionTxParams): Transaction;
+    buildUpdatePolicySeriesTx(params: BuildUpdatePolicySeriesTxParams): Transaction;
+    buildSubscribePolicySeriesTx(params: BuildSubscribePolicySeriesTxParams): Transaction;
+    buildIssuePolicyPositionTx(params: BuildIssuePolicyPositionTxParams): Transaction;
+    buildMintPolicyNftTx(params: BuildMintPolicyNftTxParams): Transaction;
+    buildPayPremiumSolTx(params: BuildPayPremiumSolTxParams): Transaction;
+    buildPayPremiumSplTx(params: BuildPayPremiumSplTxParams): Transaction;
+    buildAttestPremiumPaidOffchainTx(params: BuildAttestPremiumPaidOffchainTxParams): Transaction;
+    buildSubmitCoverageClaimTx(params: BuildSubmitCoverageClaimTxParams): Transaction;
+    buildReviewCoverageClaimTx(params: BuildReviewCoverageClaimTxParams): Transaction;
+    buildAttachCoverageClaimDecisionSupportTx(params: BuildAttachCoverageClaimDecisionSupportTxParams): Transaction;
+    buildApproveCoverageClaimTx(params: BuildApproveCoverageClaimTxParams): Transaction;
+    buildDenyCoverageClaimTx(params: BuildDenyCoverageClaimTxParams): Transaction;
+    buildPayCoverageClaimTx(params: BuildPayCoverageClaimTxParams): Transaction;
+    buildClaimApprovedCoveragePayoutTx(params: BuildClaimApprovedCoveragePayoutTxParams): Transaction;
+    buildCloseCoverageClaimTx(params: BuildCloseCoverageClaimTxParams): Transaction;
+    buildSettleCoverageClaimTx(params: BuildSettleCoverageClaimTxParams): Transaction;
+    buildActivateCycleWithQuoteSolTx(params: BuildActivateCycleWithQuoteSolTxParams): Transaction;
+    buildActivateCycleWithQuoteSplTx(params: BuildActivateCycleWithQuoteSplTxParams): Transaction;
+    buildSettleCycleCommitmentTx(params: BuildSettleCycleCommitmentTxParams): Transaction;
+    buildSettleCycleCommitmentSolTx(params: BuildSettleCycleCommitmentSolTxParams): Transaction;
+    buildFinalizeCohortSettlementRootTx(params: BuildFinalizeCohortSettlementRootTxParams): Transaction;
+    buildWithdrawPoolTreasurySplTx(params: BuildWithdrawPoolTreasurySplTxParams): Transaction;
+    buildWithdrawPoolTreasurySolTx(params: BuildWithdrawPoolTreasurySolTxParams): Transaction;
+    buildWithdrawProtocolFeeSplTx(params: BuildWithdrawProtocolFeeSplTxParams): Transaction;
+    buildWithdrawProtocolFeeSolTx(params: BuildWithdrawProtocolFeeSolTxParams): Transaction;
+    buildWithdrawPoolOracleFeeSplTx(params: BuildWithdrawPoolOracleFeeSplTxParams): Transaction;
+    buildWithdrawPoolOracleFeeSolTx(params: BuildWithdrawPoolOracleFeeSolTxParams): Transaction;
+};
+export declare function createProtocolFetchers(connection: Connection, programId: PublicKey): {
+    fetchProtocolConfig(): Promise<ProtocolConfigAccount | null>;
+    fetchPool(poolAddress: string): Promise<ProtocolPoolAccount | null>;
+    fetchOracleRegistryEntry(oracle: string): Promise<ProtocolOracleRegistryEntryAccount | null>;
+    fetchPoolOracleApproval(params: {
+        poolAddress: string;
+        oracle: string;
+    }): Promise<ProtocolPoolOracleApprovalAccount | null>;
+    fetchMembershipRecord(params: {
+        poolAddress: string;
+        member: string;
+    }): Promise<ProtocolMembershipRecordAccount | null>;
+    fetchCycleOutcomeAggregate(params: {
+        poolAddress: string;
+        seriesRefHashHex: string;
+        member: string;
+        cycleHashHex: string;
+        ruleHashHex: string;
+    }): Promise<ProtocolCycleOutcomeAggregateAccount | null>;
+    fetchOracleProfile(oracle: string): Promise<ProtocolOracleProfileAccount | null>;
+    fetchOracleStakePosition(params: {
+        oracle: string;
+        staker: string;
+    }): Promise<ProtocolOracleStakePositionAccount | null>;
+    fetchPoolOraclePolicy(poolAddress: string): Promise<ProtocolPoolOraclePolicyAccount | null>;
+    fetchPoolTerms(poolAddress: string): Promise<ProtocolPoolTermsAccount | null>;
+    fetchPoolAssetVault(params: {
+        poolAddress: string;
+        payoutMint: string;
+    }): Promise<ProtocolPoolAssetVaultAccount | null>;
+    fetchPoolLiquidityConfig(poolAddress: string): Promise<ProtocolPoolLiquidityConfigAccount | null>;
+    fetchPoolRiskConfig(poolAddress: string): Promise<ProtocolPoolRiskConfigAccount | null>;
+    fetchPoolCapitalClass(params: {
+        poolAddress: string;
+        shareMint: string;
+    }): Promise<ProtocolPoolCapitalClassAccount | null>;
+    fetchPoolCompliancePolicy(poolAddress: string): Promise<ProtocolPoolCompliancePolicyAccount | null>;
+    fetchPoolControlAuthority(poolAddress: string): Promise<ProtocolPoolControlAuthorityAccount | null>;
+    fetchPoolAutomationPolicy(poolAddress: string): Promise<ProtocolPoolAutomationPolicyAccount | null>;
+    fetchProtocolFeeVault(paymentMint: string): Promise<ProtocolFeeVaultAccount | null>;
+    fetchPoolOracleFeeVault(params: {
+        poolAddress: string;
+        oracle: string;
+        paymentMint: string;
+    }): Promise<ProtocolPoolOracleFeeVaultAccount | null>;
+    fetchPoolOraclePermissionSet(params: {
+        poolAddress: string;
+        oracle: string;
+    }): Promise<ProtocolPoolOraclePermissionSetAccount | null>;
+    fetchOutcomeSchema(schemaKeyHashHex: string): Promise<ProtocolOutcomeSchemaRegistryEntryAccount | null>;
+    fetchSchemaDependencyLedger(schemaKeyHashHex: string): Promise<ProtocolSchemaDependencyLedgerAccount | null>;
+    fetchPoolOutcomeRule(params: {
+        poolAddress: string;
+        seriesRefHashHex: string;
+        ruleHashHex: string;
+    }): Promise<ProtocolPoolOutcomeRuleAccount | null>;
+    fetchInviteIssuer(issuer: string): Promise<ProtocolInviteIssuerRegistryEntryAccount | null>;
+    fetchEnrollmentPermitReplay(params: {
+        poolAddress: string;
+        member: string;
+        nonceHashHex: string;
+    }): Promise<ProtocolEnrollmentPermitReplayAccount | null>;
+    fetchAttestationVote(params: {
+        poolAddress: string;
+        seriesRefHashHex: string;
+        member: string;
+        cycleHashHex: string;
+        ruleHashHex: string;
+        oracle: string;
+    }): Promise<ProtocolAttestationVoteAccount | null>;
+    fetchClaimDelegate(params: {
+        poolAddress: string;
+        member: string;
+    }): Promise<ProtocolClaimDelegateAuthorizationAccount | null>;
+    fetchClaimRecord(params: {
+        poolAddress: string;
+        seriesRefHashHex: string;
+        member: string;
+        cycleHashHex: string;
+        ruleHashHex: string;
+    }): Promise<ProtocolClaimRecordAccount | null>;
+    fetchPolicySeries(params: {
+        poolAddress: string;
+        seriesRefHashHex: string;
+    }): Promise<ProtocolPolicySeriesAccount | null>;
+    fetchPolicySeriesPaymentOption(params: {
+        poolAddress: string;
+        seriesRefHashHex: string;
+        paymentMint: string;
+    }): Promise<ProtocolPolicySeriesPaymentOptionAccount | null>;
+    fetchPolicyPosition(params: {
+        poolAddress: string;
+        seriesRefHashHex: string;
+        member: string;
+    }): Promise<ProtocolPolicyPositionAccount | null>;
+    fetchPolicyPositionNft(params: {
+        poolAddress: string;
+        seriesRefHashHex: string;
+        member: string;
+    }): Promise<ProtocolPolicyPositionNftAccount | null>;
+    fetchPremiumLedger(params: {
+        poolAddress: string;
+        seriesRefHashHex: string;
+        member: string;
+    }): Promise<ProtocolPremiumLedgerAccount | null>;
+    fetchPremiumAttestationReplay(params: {
+        poolAddress: string;
+        seriesRefHashHex: string;
+        member: string;
+        replayHashHex: string;
+    }): Promise<ProtocolPremiumAttestationReplayAccount | null>;
+    fetchMemberCycle(params: {
+        poolAddress: string;
+        seriesRefHashHex: string;
+        member: string;
+        periodIndex: bigint | number;
+    }): Promise<ProtocolMemberCycleAccount | null>;
+    fetchMemberCycleByAddress(address: string): Promise<ProtocolMemberCycleAccount | null>;
+    fetchCycleQuoteReplay(params: {
+        poolAddress: string;
+        seriesRefHashHex: string;
+        member: string;
+        nonceHashHex: string;
+    }): Promise<ProtocolCycleQuoteReplayAccount | null>;
+    fetchPoolTreasuryReserve(params: {
+        poolAddress: string;
+        paymentMint: string;
+    }): Promise<ProtocolPoolTreasuryReserveAccount | null>;
+    fetchRedemptionRequest(params: {
+        poolAddress: string;
+        redeemer: string;
+        requestHashHex: string;
+    }): Promise<ProtocolPoolRedemptionRequestAccount | null>;
+    fetchCohortSettlementRoot(params: {
+        poolAddress: string;
+        seriesRefHashHex: string;
+        cohortHashHex: string;
+    }): Promise<ProtocolCohortSettlementRootAccount | null>;
+    fetchCoverageClaimRecord(params: {
+        poolAddress: string;
+        seriesRefHashHex: string;
+        member: string;
+        intentHashHex: string;
+    }): Promise<ProtocolCoverageClaimRecordAccount | null>;
+};
+export declare function createProtocolClient(connection: Connection, programIdInput: string): ProtocolClient;
+export declare function derivePoolAddress(params: {
+    programId: string;
+    authority: string;
+    poolId: string;
+}): string;