@omegax/protocol-sdk 0.4.3 → 0.4.4

package/dist/claims.js

@@ -1,7 +1,7 @@
-import bs58 from 'bs58';
 import nacl from 'tweetnacl';
 import { PublicKey, SystemProgram, Transaction, TransactionInstruction, } from '@solana/web3.js';
 import { anchorDiscriminator, encodeU64Le, fromHex, hashStringTo32, } from './utils.js';
+import { decodeSolanaTransaction, solanaTransactionFirstSignature, solanaTransactionMessageBytes, solanaTransactionRequiredSigner, solanaTransactionSignerSignature, } from './transactions.js';
 import { deriveClaimDelegatePda, deriveClaimPda, deriveClaimV2Pda, deriveConfigV2Pda, deriveOutcomeAggregatePda, derivePoolOraclePolicyPda, derivePoolTermsPda, deriveCycleWindowPda, deriveCycleOutcomePda, deriveMembershipPda, } from './protocol_seeds.js';
 const SUBMIT_CLAIM_DISCRIMINATOR = anchorDiscriminator('global', 'submit_claim');
 const SUBMIT_REWARD_CLAIM_DISCRIMINATOR = anchorDiscriminator('global', 'submit_reward_claim');
@@ -207,18 +207,10 @@ export function buildUnsignedRewardClaimTx(params) {
         requiredSigner: claimant.toBase58(),
     };
 }
-function firstSignatureBase58(tx) {
-    if (tx.signatures.length === 0)
-        return null;
-    const first = tx.signatures[0];
-    if (!first?.signature)
-        return null;
-    return bs58.encode(first.signature);
-}
 export function validateSignedClaimTx(params) {
     let tx;
     try {
-        tx = Transaction.from(Buffer.from(params.signedTxBase64, 'base64'));
+        tx = decodeSolanaTransaction(params.signedTxBase64);
     }
     catch {
         return {
@@ -230,30 +222,30 @@ export function validateSignedClaimTx(params) {
     }
     if (typeof params.expectedUnsignedTxBase64 === 'string' && params.expectedUnsignedTxBase64.length > 0) {
         try {
-            const expectedUnsignedTx = Transaction.from(Buffer.from(params.expectedUnsignedTxBase64, 'base64'));
-            const signedMessageBytes = tx.serializeMessage();
-            const expectedMessageBytes = expectedUnsignedTx.serializeMessage();
+            const expectedUnsignedTx = decodeSolanaTransaction(params.expectedUnsignedTxBase64);
+            const signedMessageBytes = solanaTransactionMessageBytes(tx);
+            const expectedMessageBytes = solanaTransactionMessageBytes(expectedUnsignedTx);
             if (signedMessageBytes.length !== expectedMessageBytes.length
                 || !signedMessageBytes.every((value, index) => value === expectedMessageBytes[index])) {
                 return {
                     valid: false,
-                    txSignature: firstSignatureBase58(tx),
+                    txSignature: solanaTransactionFirstSignature(tx),
                     reason: 'intent_message_mismatch',
-                    signer: tx.feePayer?.toBase58() ?? null,
+                    signer: solanaTransactionRequiredSigner(tx),
                 };
             }
         }
         catch {
             return {
                 valid: false,
-                txSignature: firstSignatureBase58(tx),
+                txSignature: solanaTransactionFirstSignature(tx),
                 reason: 'intent_message_mismatch',
-                signer: tx.feePayer?.toBase58() ?? null,
+                signer: solanaTransactionRequiredSigner(tx),
             };
         }
     }
     const expectedSigner = params.requiredSigner.trim();
-    const signer = tx.feePayer?.toBase58() ?? null;
+    const signer = solanaTransactionRequiredSigner(tx);
     if (!signer) {
         return {
             valid: false,
@@ -265,32 +257,32 @@ export function validateSignedClaimTx(params) {
     if (signer !== expectedSigner) {
         return {
             valid: false,
-            txSignature: firstSignatureBase58(tx),
+            txSignature: solanaTransactionFirstSignature(tx),
             reason: 'required_signer_mismatch',
             signer,
         };
     }
-    const expectedPubkey = tx.signatures.find((s) => s.publicKey.toBase58() === expectedSigner);
-    if (!expectedPubkey || !expectedPubkey.signature) {
+    const requiredSignature = solanaTransactionSignerSignature(tx, expectedSigner);
+    if (!requiredSignature) {
         return {
             valid: false,
-            txSignature: firstSignatureBase58(tx),
+            txSignature: solanaTransactionFirstSignature(tx),
             reason: 'missing_required_signature',
             signer,
         };
     }
-    const ok = nacl.sign.detached.verify(tx.serializeMessage(), expectedPubkey.signature, new PublicKey(expectedSigner).toBytes());
+    const ok = nacl.sign.detached.verify(solanaTransactionMessageBytes(tx), requiredSignature, new PublicKey(expectedSigner).toBytes());
     if (!ok) {
         return {
             valid: false,
-            txSignature: firstSignatureBase58(tx),
+            txSignature: solanaTransactionFirstSignature(tx),
             reason: 'invalid_required_signature',
             signer,
         };
     }
     return {
         valid: true,
-        txSignature: firstSignatureBase58(tx),
+        txSignature: solanaTransactionFirstSignature(tx),
         reason: null,
         signer,
     };

package/dist/index.d.ts

@@ -3,5 +3,6 @@ export * from './utils.js';
 export * from './oracle.js';
 export * from './claims.js';
 export * from './rpc.js';
+export * from './transactions.js';
 export * from './protocol_seeds.js';
 export * from './protocol.js';

package/dist/index.js

@@ -3,5 +3,6 @@ export * from './utils.js';
 export * from './oracle.js';
 export * from './claims.js';
 export * from './rpc.js';
+export * from './transactions.js';
 export * from './protocol_seeds.js';
 export * from './protocol.js';

package/dist/protocol.d.ts

@@ -1,7 +1,10 @@
-import { Connection } from '@solana/web3.js';
+import { AddressLookupTableAccount, Connection, Transaction, VersionedTransaction } from '@solana/web3.js';
 import type { ProtocolClient, ProtocolCycleQuoteFields } 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 createProtocolClient(connection: Connection, programIdInput: string): ProtocolClient;
 export declare function derivePoolAddress(params: {
     programId: string;

package/dist/protocol.js

@@ -1,6 +1,7 @@
-import { Ed25519Program, PublicKey, SYSVAR_INSTRUCTIONS_PUBKEY, SystemProgram, Transaction, TransactionInstruction, } from '@solana/web3.js';
+import { ComputeBudgetProgram, Ed25519Program, PublicKey, SYSVAR_INSTRUCTIONS_PUBKEY, SystemProgram, Transaction, TransactionMessage, TransactionInstruction, VersionedTransaction, } from '@solana/web3.js';
+import { blake3 } from '@noble/hashes/blake3.js';
 import { anchorDiscriminator, encodeI64Le, encodeString, encodeU16Le, encodeU64Le, fromHex, hashStringTo32, readI64Le, readString, readU16Le, readU64Le, toHex, } from './utils.js';
-import { asPubkey, deriveClaimPda, deriveClaimDelegatePda, deriveClaimV2Pda, deriveConfigPda, deriveConfigV2Pda, deriveCoverageClaimPda, deriveCoverageProductPda, deriveCoverageNftPda, deriveCoveragePolicyPda, deriveCycleOutcomePda, deriveCycleWindowPda, deriveEnrollmentReplayPda, deriveAttestationVotePda, deriveCycleQuoteReplayPda, deriveInviteIssuerPda, deriveMemberCyclePda, deriveMembershipPda, deriveOracleStakePda, deriveOracleProfilePda, deriveOutcomeAggregatePda, deriveOraclePda, derivePoolAssetVaultPda, derivePoolOraclePermissionSetPda, derivePoolOracleFeeVaultPda, derivePoolTermsPda, derivePoolOraclePolicyPda, derivePoolOraclePda, derivePoolPda, derivePoolRulePda, deriveProtocolFeeVaultPda, derivePremiumLedgerPda, derivePremiumReplayPda, derivePoolTreasuryReservePda, deriveReplayPda, deriveSchemaPda, ZERO_PUBKEY, } from './protocol_seeds.js';
+import { asPubkey, deriveClaimPda, deriveClaimDelegatePda, deriveClaimV2Pda, deriveConfigPda, deriveConfigV2Pda, deriveCoverageClaimPda, deriveCoverageProductPda, deriveCoverageProductPaymentOptionPda, deriveCoverageNftPda, deriveCoveragePolicyPda, deriveCycleOutcomePda, deriveCycleWindowPda, deriveEnrollmentReplayPda, deriveAttestationVotePda, deriveCycleQuoteReplayPda, deriveInviteIssuerPda, deriveMemberCyclePda, deriveMembershipPda, deriveOracleStakePda, deriveOracleProfilePda, deriveOutcomeAggregatePda, deriveOraclePda, derivePoolAssetVaultPda, derivePoolOraclePermissionSetPda, derivePoolOracleFeeVaultPda, derivePoolTermsPda, derivePoolOraclePolicyPda, derivePoolOraclePda, derivePoolPda, derivePoolRulePda, deriveProtocolFeeVaultPda, derivePremiumLedgerPda, derivePremiumReplayPda, derivePoolTreasuryReservePda, deriveReplayPda, deriveSchemaPda, ZERO_PUBKEY, } from './protocol_seeds.js';
 const MAX_POOL_ID_SEED_BYTES = 32;
 const MAX_ORACLE_SUPPORTED_SCHEMAS = 16;
 export const PROTOCOL_PROGRAM_ID = 'Bn6eixac1QEEVErGBvBjxAd6pgB9e2q4XHvAkinQ5y1B';
@@ -31,6 +32,7 @@ const IX_FINALIZE_UNSTAKE = anchorDiscriminator('global', 'finalize_unstake');
 const IX_SLASH_ORACLE = anchorDiscriminator('global', 'slash_oracle');
 const IX_CREATE_POOL_V2 = anchorDiscriminator('global', 'create_pool_v2');
 const IX_SET_POOL_ORACLE_POLICY = anchorDiscriminator('global', 'set_pool_oracle_policy');
+const IX_SET_POOL_ORACLE_PERMISSIONS = anchorDiscriminator('global', 'set_pool_oracle_permissions');
 const IX_SET_POOL_COVERAGE_RESERVE_FLOOR = anchorDiscriminator('global', 'set_pool_coverage_reserve_floor');
 const IX_SET_POOL_TERMS_HASH = anchorDiscriminator('global', 'set_pool_terms_hash');
 const IX_REGISTER_OUTCOME_SCHEMA = anchorDiscriminator('global', 'register_outcome_schema');
@@ -45,6 +47,7 @@ const IX_FUND_POOL_SOL = anchorDiscriminator('global', 'fund_pool_sol');
 const IX_FUND_POOL_SPL = anchorDiscriminator('global', 'fund_pool_spl');
 const IX_SUBMIT_REWARD_CLAIM = anchorDiscriminator('global', 'submit_reward_claim');
 const IX_REGISTER_COVERAGE_PRODUCT_V2 = anchorDiscriminator('global', 'register_coverage_product_v2');
+const IX_UPSERT_COVERAGE_PRODUCT_PAYMENT_OPTION = anchorDiscriminator('global', 'upsert_coverage_product_payment_option');
 const IX_UPDATE_COVERAGE_PRODUCT_V2 = anchorDiscriminator('global', 'update_coverage_product_v2');
 const IX_SUBSCRIBE_COVERAGE_PRODUCT_V2 = anchorDiscriminator('global', 'subscribe_coverage_product_v2');
 const IX_ISSUE_COVERAGE_POLICY_FROM_PRODUCT_V2 = anchorDiscriminator('global', 'issue_coverage_policy_from_product_v2');
@@ -91,6 +94,7 @@ const ACCOUNT_CLAIM_RECORD_V2 = anchorDiscriminator('account', 'ClaimRecordV2');
 const ACCOUNT_COVERAGE_CLAIM_RECORD = anchorDiscriminator('account', 'CoverageClaimRecord');
 const ACCOUNT_COVERAGE_POLICY_POSITION_NFT = anchorDiscriminator('account', 'CoveragePolicyPositionNft');
 const ACCOUNT_COVERAGE_PRODUCT = anchorDiscriminator('account', 'CoverageProduct');
+const ACCOUNT_COVERAGE_PRODUCT_PAYMENT_OPTION = anchorDiscriminator('account', 'CoverageProductPaymentOption');
 const ACCOUNT_ENROLLMENT_PERMIT_REPLAY = anchorDiscriminator('account', 'EnrollmentPermitReplay');
 const ACCOUNT_ATTESTATION_VOTE = anchorDiscriminator('account', 'AttestationVote');
 const ACCOUNT_COVERAGE_POLICY = anchorDiscriminator('account', 'CoveragePolicy');
@@ -179,6 +183,35 @@ export function buildCycleQuoteMessage(fields) {
         Buffer.from(fromHex(fields.quoteMetaHashHex, 32)),
     ]);
 }
+function asCycleQuoteMessage(input) {
+    if (input instanceof Uint8Array) {
+        return Buffer.from(input);
+    }
+    return buildCycleQuoteMessage(input);
+}
+export function buildCycleQuoteHash(input) {
+    return Buffer.from(blake3(asCycleQuoteMessage(input)));
+}
+export function buildCycleQuoteSignatureMessage(input) {
+    return Buffer.concat([
+        Buffer.from('omegax:cycle_quote_sig:v1', 'utf8'),
+        buildCycleQuoteHash(input),
+    ]);
+}
+export function compileTransactionToV0(transaction, lookupTableAccounts) {
+    if (!transaction.feePayer) {
+        throw new Error('transaction fee payer is required to compile a v0 transaction');
+    }
+    if (!transaction.recentBlockhash) {
+        throw new Error('transaction recentBlockhash is required to compile a v0 transaction');
+    }
+    const message = new TransactionMessage({
+        payerKey: transaction.feePayer,
+        recentBlockhash: transaction.recentBlockhash,
+        instructions: transaction.instructions,
+    }).compileToV0Message(lookupTableAccounts);
+    return new VersionedTransaction(message);
+}
 function hasDiscriminator(data, discriminator) {
     if (data.length < 8)
         return false;
@@ -1198,6 +1231,32 @@ function decodeCoverageProductAccount(address, data) {
         bump,
     };
 }
+function decodeCoverageProductPaymentOptionAccount(address, data) {
+    if (!hasDiscriminator(data, ACCOUNT_COVERAGE_PRODUCT_PAYMENT_OPTION)) {
+        throw new Error('account discriminator mismatch for CoverageProductPaymentOption');
+    }
+    let offset = 8;
+    const pool = pubkeyFromData(data, offset);
+    offset += 32;
+    const productIdHash = data.subarray(offset, offset + 32);
+    offset += 32;
+    const paymentMint = pubkeyFromData(data, offset);
+    offset += 32;
+    const paymentAmount = readU64Le(data, offset);
+    offset += 8;
+    const active = data.readUInt8(offset) === 1;
+    offset += 1;
+    const bump = data.readUInt8(offset);
+    return {
+        address,
+        pool,
+        productIdHashHex: toHex(productIdHash),
+        paymentMint,
+        paymentAmount,
+        active,
+        bump,
+    };
+}
 function decodeCoveragePolicyPositionNftAccount(address, data) {
     if (!hasDiscriminator(data, ACCOUNT_COVERAGE_POLICY_POSITION_NFT)) {
         throw new Error('account discriminator mismatch for CoveragePolicyPositionNft');
@@ -1541,6 +1600,12 @@ function encodeSetPoolOraclePolicyData(params) {
         Buffer.from([params.allowDelegateClaim ? 1 : 0]),
     ]);
 }
+function encodeSetPoolOraclePermissionsData(params) {
+    const permissions = params.permissions >>> 0;
+    const out = Buffer.alloc(4);
+    out.writeUInt32LE(permissions, 0);
+    return Buffer.concat([IX_SET_POOL_ORACLE_PERMISSIONS, out]);
+}
 function encodeSetPoolCoverageReserveFloorData(params) {
     return Buffer.concat([
         IX_SET_POOL_COVERAGE_RESERVE_FLOOR,
@@ -1661,6 +1726,14 @@ function encodeRegisterCoverageProductV2Data(params) {
         Buffer.from([params.active ? 1 : 0]),
     ]);
 }
+function encodeUpsertCoverageProductPaymentOptionData(params) {
+    return Buffer.concat([
+        IX_UPSERT_COVERAGE_PRODUCT_PAYMENT_OPTION,
+        asPubkey(params.paymentMint).toBuffer(),
+        encodeU64Le(params.paymentAmount),
+        Buffer.from([params.active ? 1 : 0]),
+    ]);
+}
 function encodeUpdateCoverageProductV2Data(params) {
     return Buffer.concat([
         IX_UPDATE_COVERAGE_PRODUCT_V2,
@@ -1749,17 +1822,6 @@ function encodeMigratePoolV1ToV2Data(params) {
         encodeString(params.metadataUri),
     ]);
 }
-function deriveCoverageProductPaymentOptionPda(params) {
-    const program = asPubkey(params.programId);
-    const pool = asPubkey(params.poolAddress);
-    const paymentMint = asPubkey(params.paymentMint);
-    return PublicKey.findProgramAddressSync([
-        Buffer.from('coverage_product_payment_option'),
-        pool.toBuffer(),
-        Buffer.from(fromHex(params.productIdHashHex, 32)),
-        paymentMint.toBuffer(),
-    ], program);
-}
 function buildActivateCycleWithQuoteSolTransaction(params) {
     const programId = asPubkey(params.programId);
     const payer = asPubkey(params.payer);
@@ -1788,7 +1850,7 @@ function buildActivateCycleWithQuoteSolTransaction(params) {
     const [coverageProductPaymentOption] = deriveCoverageProductPaymentOptionPda({
         programId,
         poolAddress,
-        productIdHashHex: params.productIdHashHex,
+        productIdHash: fromHex(params.productIdHashHex, 32),
         paymentMint: zeroPubkey,
     });
     const [coveragePolicy] = deriveCoveragePolicyPda({ programId, poolAddress, member });
@@ -1823,7 +1885,7 @@ function buildActivateCycleWithQuoteSolTransaction(params) {
     });
     const ed25519Instruction = Ed25519Program.createInstructionWithPrivateKey({
         privateKey: params.oracleSecretKey,
-        message: params.quoteMessage,
+        message: buildCycleQuoteSignatureMessage(params.quoteMessage),
     });
     const instruction = new TransactionInstruction({
         programId,
@@ -1855,6 +1917,7 @@ function buildActivateCycleWithQuoteSolTransaction(params) {
             IX_ACTIVATE_CYCLE_WITH_QUOTE_SOL,
             Buffer.from(fromHex(params.productIdHashHex, 32)),
             encodeU64Le(params.periodIndex),
+            Buffer.from(fromHex(params.nonceHashHex, 32)),
             encodeU64Le(params.premiumAmountRaw),
             encodeU64Le(params.canonicalPremiumAmount),
             Buffer.from([params.commitmentEnabled ? 1 : 0]),
@@ -1867,14 +1930,19 @@ function buildActivateCycleWithQuoteSolTransaction(params) {
             Buffer.from([params.includedShieldCount]),
             encodeU16Le(params.thresholdBps),
             encodeI64Le(params.expiresAtTs),
-            Buffer.from(fromHex(params.nonceHashHex, 32)),
             Buffer.from(fromHex(params.quoteMetaHashHex, 32)),
         ]),
     });
-    return new Transaction({
+    const transaction = new Transaction({
         feePayer: payer,
         recentBlockhash: params.recentBlockhash,
-    }).add(ed25519Instruction, instruction);
+    });
+    if (typeof params.computeUnitLimit === 'number') {
+        transaction.add(ComputeBudgetProgram.setComputeUnitLimit({
+            units: params.computeUnitLimit,
+        }));
+    }
+    return transaction.add(ed25519Instruction, instruction);
 }
 function buildActivateCycleWithQuoteSplTransaction(params) {
     const programId = asPubkey(params.programId);
@@ -1904,7 +1972,7 @@ function buildActivateCycleWithQuoteSplTransaction(params) {
     const [coverageProductPaymentOption] = deriveCoverageProductPaymentOptionPda({
         programId,
         poolAddress,
-        productIdHashHex: params.productIdHashHex,
+        productIdHash: fromHex(params.productIdHashHex, 32),
         paymentMint,
     });
     const [coveragePolicy] = deriveCoveragePolicyPda({ programId, poolAddress, member });
@@ -1962,7 +2030,7 @@ function buildActivateCycleWithQuoteSplTransaction(params) {
     });
     const ed25519Instruction = Ed25519Program.createInstructionWithPrivateKey({
         privateKey: params.oracleSecretKey,
-        message: params.quoteMessage,
+        message: buildCycleQuoteSignatureMessage(params.quoteMessage),
     });
     const instruction = new TransactionInstruction({
         programId,
@@ -2002,6 +2070,7 @@ function buildActivateCycleWithQuoteSplTransaction(params) {
             IX_ACTIVATE_CYCLE_WITH_QUOTE_SPL,
             Buffer.from(fromHex(params.productIdHashHex, 32)),
             encodeU64Le(params.periodIndex),
+            Buffer.from(fromHex(params.nonceHashHex, 32)),
             encodeU64Le(params.premiumAmountRaw),
             encodeU64Le(params.canonicalPremiumAmount),
             Buffer.from([params.commitmentEnabled ? 1 : 0]),
@@ -2014,14 +2083,15 @@ function buildActivateCycleWithQuoteSplTransaction(params) {
             Buffer.from([params.includedShieldCount]),
             encodeU16Le(params.thresholdBps),
             encodeI64Le(params.expiresAtTs),
-            Buffer.from(fromHex(params.nonceHashHex, 32)),
             Buffer.from(fromHex(params.quoteMetaHashHex, 32)),
         ]),
     });
     return new Transaction({
         feePayer: payer,
         recentBlockhash: params.recentBlockhash,
-    }).add(ed25519Instruction, instruction);
+    }).add(ComputeBudgetProgram.setComputeUnitLimit({
+        units: params.computeUnitLimit ?? 400_000,
+    }), ed25519Instruction, instruction);
 }
 function buildSettleCycleCommitmentTransaction(params) {
     const programId = asPubkey(params.programId);
@@ -3128,6 +3198,42 @@ export function createProtocolClient(connection, programIdInput) {
                 recentBlockhash: params.recentBlockhash,
             }).add(instruction);
         },
+        buildSetPoolOraclePermissionsTx(params) {
+            const authority = new PublicKey(params.authority);
+            const poolAddress = new PublicKey(params.poolAddress);
+            const oracle = new PublicKey(params.oracle);
+            const [oracleEntryPda] = deriveOraclePda({
+                programId,
+                oracle,
+            });
+            const [poolOraclePda] = derivePoolOraclePda({
+                programId,
+                poolAddress,
+                oracle,
+            });
+            const [poolOraclePermissionsPda] = derivePoolOraclePermissionSetPda({
+                programId,
+                poolAddress,
+                oracle,
+            });
+            const instruction = new TransactionInstruction({
+                programId,
+                keys: [
+                    { pubkey: authority, isSigner: true, isWritable: true },
+                    { pubkey: poolAddress, isSigner: false, isWritable: false },
+                    { pubkey: oracle, isSigner: false, isWritable: false },
+                    { pubkey: oracleEntryPda, isSigner: false, isWritable: false },
+                    { pubkey: poolOraclePda, isSigner: false, isWritable: false },
+                    { pubkey: poolOraclePermissionsPda, isSigner: false, isWritable: true },
+                    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+                ],
+                data: encodeSetPoolOraclePermissionsData(params),
+            });
+            return new Transaction({
+                feePayer: authority,
+                recentBlockhash: params.recentBlockhash,
+            }).add(instruction);
+        },
         buildSetPoolCoverageReserveFloorTx(params) {
             const authority = new PublicKey(params.authority);
             const poolAddress = new PublicKey(params.poolAddress);
@@ -3542,6 +3648,41 @@ export function createProtocolClient(connection, programIdInput) {
                 recentBlockhash: params.recentBlockhash,
             }).add(instruction);
         },
+        buildUpsertCoverageProductPaymentOptionTx(params) {
+            const authority = new PublicKey(params.authority);
+            const poolAddress = new PublicKey(params.poolAddress);
+            const paymentMint = new PublicKey(params.paymentMint);
+            const productIdHash = fromHex(params.productIdHashHex, 32);
+            const [configV2Pda] = deriveConfigV2Pda(programId);
+            const [coverageProductPda] = deriveCoverageProductPda({
+                programId,
+                poolAddress,
+                productIdHash,
+            });
+            const [coverageProductPaymentOptionPda] = deriveCoverageProductPaymentOptionPda({
+                programId,
+                poolAddress,
+                productIdHash,
+                paymentMint,
+            });
+            const instruction = new TransactionInstruction({
+                programId,
+                keys: [
+                    { pubkey: authority, isSigner: true, isWritable: true },
+                    { pubkey: configV2Pda, isSigner: false, isWritable: false },
+                    { pubkey: poolAddress, isSigner: false, isWritable: false },
+                    { pubkey: coverageProductPda, isSigner: false, isWritable: true },
+                    { pubkey: paymentMint, isSigner: false, isWritable: false },
+                    { pubkey: coverageProductPaymentOptionPda, isSigner: false, isWritable: true },
+                    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+                ],
+                data: encodeUpsertCoverageProductPaymentOptionData(params),
+            });
+            return new Transaction({
+                feePayer: authority,
+                recentBlockhash: params.recentBlockhash,
+            }).add(instruction);
+        },
         buildUpdateCoverageProductV2Tx(params) {
             const authority = new PublicKey(params.authority);
             const poolAddress = new PublicKey(params.poolAddress);
@@ -4275,6 +4416,18 @@ export function createProtocolClient(connection, programIdInput) {
                 return null;
             return decodeCoverageProductAccount(pda.toBase58(), account.data);
         },
+        async fetchCoverageProductPaymentOption(params) {
+            const [pda] = deriveCoverageProductPaymentOptionPda({
+                programId,
+                poolAddress: params.poolAddress,
+                productIdHash: fromHex(params.productIdHashHex, 32),
+                paymentMint: params.paymentMint,
+            });
+            const account = await connection.getAccountInfo(pda, 'confirmed');
+            if (!account)
+                return null;
+            return decodeCoverageProductPaymentOptionAccount(pda.toBase58(), account.data);
+        },
         async fetchCoveragePolicy(params) {
             const [pda] = deriveCoveragePolicyPda({
                 programId,

package/dist/protocol_seeds.d.ts

@@ -31,6 +31,7 @@ export declare const SEED_CLAIM_V2 = "claim_v2";
 export declare const SEED_COVERAGE_POLICY = "coverage_policy";
 export declare const SEED_COVERAGE_NFT = "coverage_nft";
 export declare const SEED_COVERAGE_PRODUCT = "coverage_product";
+export declare const SEED_COVERAGE_PRODUCT_PAYMENT_OPTION = "coverage_product_payment_option";
 export declare const SEED_PREMIUM_LEDGER = "premium_ledger";
 export declare const SEED_PREMIUM_REPLAY = "premium_replay";
 export declare const SEED_COVERAGE_CLAIM = "coverage_claim";
@@ -101,6 +102,12 @@ export declare function derivePoolAssetVaultPda(params: {
     poolAddress: string | PublicKey;
     payoutMint: string | PublicKey;
 }): [PublicKey, number];
+export declare function deriveCoverageProductPaymentOptionPda(params: {
+    programId: string | PublicKey;
+    poolAddress: string | PublicKey;
+    productIdHash: Uint8Array;
+    paymentMint: string | PublicKey;
+}): [PublicKey, number];
 export declare function derivePoolOraclePermissionSetPda(params: {
     programId: string | PublicKey;
     poolAddress: string | PublicKey;

package/dist/protocol_seeds.js

@@ -31,6 +31,7 @@ export const SEED_CLAIM_V2 = 'claim_v2';
 export const SEED_COVERAGE_POLICY = 'coverage_policy';
 export const SEED_COVERAGE_NFT = 'coverage_nft';
 export const SEED_COVERAGE_PRODUCT = 'coverage_product';
+export const SEED_COVERAGE_PRODUCT_PAYMENT_OPTION = 'coverage_product_payment_option';
 export const SEED_PREMIUM_LEDGER = 'premium_ledger';
 export const SEED_PREMIUM_REPLAY = 'premium_replay';
 export const SEED_COVERAGE_CLAIM = 'coverage_claim';
@@ -136,6 +137,17 @@ export function derivePoolAssetVaultPda(params) {
     const mint = asPubkey(params.payoutMint);
     return PublicKey.findProgramAddressSync([Buffer.from(SEED_POOL_ASSET_VAULT), pool.toBuffer(), mint.toBuffer()], program);
 }
+export function deriveCoverageProductPaymentOptionPda(params) {
+    const program = asPubkey(params.programId);
+    const pool = asPubkey(params.poolAddress);
+    const mint = asPubkey(params.paymentMint);
+    return PublicKey.findProgramAddressSync([
+        Buffer.from(SEED_COVERAGE_PRODUCT_PAYMENT_OPTION),
+        pool.toBuffer(),
+        Buffer.from(params.productIdHash),
+        mint.toBuffer(),
+    ], program);
+}
 function encodeU64Seed(value) {
     const out = Buffer.alloc(8);
     out.writeBigUInt64LE(typeof value === 'bigint' ? value : BigInt(value));

package/dist/rpc.js

@@ -1,5 +1,6 @@
-import { Connection, Transaction, } from '@solana/web3.js';
+import { Connection, } from '@solana/web3.js';
 import { normalizeClaimSimulationFailure } from './claims.js';
+import { decodeSolanaTransaction, } from './transactions.js';
 export const OMEGAX_NETWORKS = {
     devnet: {
         network: 'devnet',
@@ -73,7 +74,7 @@ export function createRpcClient(connection) {
         async simulateSignedTx(params) {
             let tx;
             try {
-                tx = Transaction.from(Buffer.from(params.signedTxBase64, 'base64'));
+                tx = decodeSolanaTransaction(params.signedTxBase64);
             }
             catch (error) {
                 return {

package/dist/transactions.d.ts

@@ -0,0 +1,10 @@
+import { Transaction, VersionedTransaction } from '@solana/web3.js';
+export type SolanaTransaction = Transaction | VersionedTransaction;
+export declare function decodeSolanaTransaction(input: string | Uint8Array | Buffer): SolanaTransaction;
+export declare function serializeSolanaTransaction(transaction: SolanaTransaction): Buffer;
+export declare function serializeSolanaTransactionBase64(transaction: SolanaTransaction): string;
+export declare function solanaTransactionMessageBytes(transaction: SolanaTransaction): Uint8Array;
+export declare function solanaTransactionMessageBase64(input: SolanaTransaction | string | Uint8Array | Buffer): string;
+export declare function solanaTransactionRequiredSigner(transaction: SolanaTransaction): string | null;
+export declare function solanaTransactionFirstSignature(transaction: SolanaTransaction): string | null;
+export declare function solanaTransactionSignerSignature(transaction: SolanaTransaction, signer: string): Uint8Array | null;

package/dist/transactions.js

@@ -0,0 +1,104 @@
+import bs58 from 'bs58';
+import { Transaction, VersionedTransaction, } from '@solana/web3.js';
+function decodeShortVecLength(bytes, offset = 0) {
+    let length = 0;
+    let size = 0;
+    let cursor = offset;
+    while (cursor < bytes.length) {
+        const value = bytes[cursor] ?? 0;
+        length |= (value & 0x7f) << (size * 7);
+        size += 1;
+        cursor += 1;
+        if ((value & 0x80) === 0) {
+            return { length, bytesRead: size };
+        }
+    }
+    throw new Error('invalid shortvec length');
+}
+function versionedStaticAccountKeys(transaction) {
+    const message = transaction.message;
+    return (message?.staticAccountKeys ??
+        message?.getAccountKeys?.().staticAccountKeys ??
+        []);
+}
+function signatureIsPresent(signature) {
+    if (!signature || signature.length === 0)
+        return false;
+    return signature.some((value) => value !== 0);
+}
+export function decodeSolanaTransaction(input) {
+    const bytes = typeof input === 'string' ? Buffer.from(input, 'base64') : Buffer.from(input);
+    const { length: signatureCount, bytesRead } = decodeShortVecLength(bytes);
+    const messageOffset = bytesRead + signatureCount * 64;
+    if (messageOffset >= bytes.length) {
+        throw new Error('invalid serialized transaction');
+    }
+    const messagePrefix = bytes[messageOffset] ?? 0;
+    if ((messagePrefix & 0x80) !== 0) {
+        return VersionedTransaction.deserialize(bytes);
+    }
+    return Transaction.from(bytes);
+}
+export function serializeSolanaTransaction(transaction) {
+    if (transaction instanceof Transaction) {
+        return transaction.serialize({
+            requireAllSignatures: false,
+            verifySignatures: false,
+        });
+    }
+    return Buffer.from(transaction.serialize());
+}
+export function serializeSolanaTransactionBase64(transaction) {
+    return serializeSolanaTransaction(transaction).toString('base64');
+}
+export function solanaTransactionMessageBytes(transaction) {
+    if (transaction instanceof Transaction) {
+        return transaction.serializeMessage();
+    }
+    return transaction.message.serialize();
+}
+export function solanaTransactionMessageBase64(input) {
+    const transaction = typeof input === 'string' || input instanceof Uint8Array || Buffer.isBuffer(input)
+        ? decodeSolanaTransaction(input)
+        : input;
+    return Buffer.from(solanaTransactionMessageBytes(transaction)).toString('base64');
+}
+export function solanaTransactionRequiredSigner(transaction) {
+    if (transaction instanceof Transaction) {
+        return transaction.feePayer?.toBase58() ?? null;
+    }
+    const accountKeys = versionedStaticAccountKeys(transaction);
+    return accountKeys[0]?.toBase58() ?? null;
+}
+export function solanaTransactionFirstSignature(transaction) {
+    if (transaction instanceof Transaction) {
+        if (transaction.signatures.length === 0)
+            return null;
+        const first = transaction.signatures[0];
+        if (!signatureIsPresent(first?.signature))
+            return null;
+        return bs58.encode(first.signature);
+    }
+    const first = transaction.signatures[0];
+    if (!signatureIsPresent(first))
+        return null;
+    return bs58.encode(first);
+}
+export function solanaTransactionSignerSignature(transaction, signer) {
+    if (transaction instanceof Transaction) {
+        const entry = transaction.signatures.find((candidate) => candidate.publicKey.toBase58() === signer);
+        return signatureIsPresent(entry?.signature) ? entry?.signature : null;
+    }
+    const accountKeys = versionedStaticAccountKeys(transaction);
+    const signerIndex = accountKeys.findIndex((candidate) => candidate.toBase58() === signer);
+    if (signerIndex < 0)
+        return null;
+    const header = transaction.message
+        .header;
+    const requiredSignerCount = header?.numRequiredSignatures ?? 0;
+    if (signerIndex >= requiredSignerCount) {
+        return null;
+    }
+    const signature = transaction.signatures[signerIndex];
+    return signatureIsPresent(signature) ? signature : null;
+}

package/dist/types.d.ts

@@ -394,6 +394,7 @@ export interface BuildActivateCycleWithQuoteSolTxParams {
     quoteMetaHashHex: string;
     quoteMessage: Uint8Array;
     oracleSecretKey: Uint8Array;
+    computeUnitLimit?: number;
     recentBlockhash: string;
     programId: string;
 }
@@ -421,6 +422,7 @@ export interface BuildActivateCycleWithQuoteSplTxParams {
     quoteMetaHashHex: string;
     quoteMessage: Uint8Array;
     oracleSecretKey: Uint8Array;
+    computeUnitLimit?: number;
     recentBlockhash: string;
     programId: string;
 }
@@ -572,6 +574,7 @@ export interface ProtocolClient {
     buildSlashOracleTx?: (params: BuildSlashOracleTxParams) => Transaction;
     buildCreatePoolV2Tx?: (params: BuildCreatePoolV2TxParams) => Transaction;
     buildSetPoolOraclePolicyTx?: (params: BuildSetPoolOraclePolicyTxParams) => Transaction;
+    buildSetPoolOraclePermissionsTx?: (params: BuildSetPoolOraclePermissionsTxParams) => Transaction;
     buildSetPoolTermsHashTx?: (params: BuildSetPoolTermsHashTxParams) => Transaction;
     buildRegisterOutcomeSchemaTx?: (params: BuildRegisterOutcomeSchemaTxParams) => Transaction;
     buildVerifyOutcomeSchemaTx?: (params: BuildVerifyOutcomeSchemaTxParams) => Transaction;
@@ -588,6 +591,7 @@ export interface ProtocolClient {
     buildSubmitRewardClaimTx?: (params: BuildSubmitRewardClaimTxParams) => Transaction;
     buildRegisterCoverageProductV2Tx?: (params: BuildRegisterCoverageProductV2TxParams) => Transaction;
     buildUpdateCoverageProductV2Tx?: (params: BuildUpdateCoverageProductV2TxParams) => Transaction;
+    buildUpsertCoverageProductPaymentOptionTx?: (params: BuildUpsertCoverageProductPaymentOptionTxParams) => Transaction;
     buildSubscribeCoverageProductV2Tx?: (params: BuildSubscribeCoverageProductV2TxParams) => Transaction;
     buildIssueCoveragePolicyFromProductV2Tx?: (params: BuildIssueCoveragePolicyFromProductV2TxParams) => Transaction;
     buildCreateCoveragePolicyTx?: (params: BuildCreateCoveragePolicyTxParams) => Transaction;
@@ -658,6 +662,11 @@ export interface ProtocolClient {
         poolAddress: string;
         productIdHashHex: string;
     }) => Promise<ProtocolCoverageProductAccount | null>;
+    fetchCoverageProductPaymentOption?: (params: {
+        poolAddress: string;
+        productIdHashHex: string;
+        paymentMint: string;
+    }) => Promise<ProtocolCoverageProductPaymentOptionAccount | null>;
     fetchCoveragePolicy?: (params: {
         poolAddress: string;
         member: string;
@@ -951,6 +960,15 @@ export interface ProtocolCoverageProductAccount {
     updatedAtTs: number;
     bump: number;
 }
+export interface ProtocolCoverageProductPaymentOptionAccount {
+    address: string;
+    pool: string;
+    productIdHashHex: string;
+    paymentMint: string;
+    paymentAmount: bigint;
+    active: boolean;
+    bump: number;
+}
 export interface ProtocolCoveragePolicyPositionNftAccount {
     address: string;
     pool: string;
@@ -1111,6 +1129,14 @@ export interface BuildSetPoolOraclePolicyTxParams {
     recentBlockhash: string;
     programId: string;
 }
+export interface BuildSetPoolOraclePermissionsTxParams {
+    authority: string;
+    poolAddress: string;
+    oracle: string;
+    permissions: number;
+    recentBlockhash: string;
+    programId: string;
+}
 export interface BuildSetPoolTermsHashTxParams {
     authority: string;
     poolAddress: string;
@@ -1336,6 +1362,16 @@ export interface BuildRegisterCoverageProductV2TxParams {
     recentBlockhash: string;
     programId: string;
 }
+export interface BuildUpsertCoverageProductPaymentOptionTxParams {
+    authority: string;
+    poolAddress: string;
+    productIdHashHex: string;
+    paymentMint: string;
+    paymentAmount: bigint;
+    active: boolean;
+    recentBlockhash: string;
+    programId: string;
+}
 export interface BuildUpdateCoverageProductV2TxParams {
     authority: string;
     poolAddress: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omegax/protocol-sdk",
-  "version": "0.4.3",
+  "version": "0.4.4",
   "description": "TypeScript SDK for OmegaX protocol integrations on Solana devnet beta (mainnet coming soon).",
   "keywords": [
     "omegax",
@@ -79,6 +79,7 @@
     "dev": "tsx watch src/index.ts"
   },
   "dependencies": {
+    "@noble/hashes": "^1.8.0",
     "@solana/web3.js": "^1.98.4",
     "bs58": "^6.0.0",
     "tweetnacl": "^1.0.3"