@faremeter/payment-solana 0.10.1 → 0.10.2

package/dist/src/exact/client.d.ts

@@ -0,0 +1,11 @@
+import type { PaymentHandler } from "@faremeter/types/client";
+import { Connection, PublicKey, TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
+export type Wallet = {
+    network: string;
+    publicKey: PublicKey;
+    buildTransaction?: (instructions: TransactionInstruction[], recentBlockHash: string) => Promise<VersionedTransaction>;
+    updateTransaction?: (tx: VersionedTransaction) => Promise<VersionedTransaction>;
+    sendTransaction?: (tx: VersionedTransaction) => Promise<string>;
+};
+export declare function createPaymentHandler(wallet: Wallet, mint: PublicKey, connection?: Connection): PaymentHandler;
+//# sourceMappingURL=client.d.ts.map

package/dist/src/exact/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../src/exact/client.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,cAAc,EAEf,MAAM,yBAAyB,CAAC;AAWjC,OAAO,EAEL,UAAU,EACV,SAAS,EACT,sBAAsB,EAEtB,oBAAoB,EACrB,MAAM,iBAAiB,CAAC;AAIzB,MAAM,MAAM,MAAM,GAAG;IACnB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,SAAS,CAAC;IACrB,gBAAgB,CAAC,EAAE,CACjB,YAAY,EAAE,sBAAsB,EAAE,EACtC,eAAe,EAAE,MAAM,KACpB,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACnC,iBAAiB,CAAC,EAAE,CAClB,EAAE,EAAE,oBAAoB,KACrB,OAAO,CAAC,oBAAoB,CAAC,CAAC;IACnC,eAAe,CAAC,EAAE,CAAC,EAAE,EAAE,oBAAoB,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;CACjE,CAAC;AAEF,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,SAAS,EACf,UAAU,CAAC,EAAE,UAAU,GACtB,cAAc,CAwHhB"}

package/dist/src/exact/client.js

@@ -0,0 +1,86 @@
+import { isValidationError, throwValidationError } from "@faremeter/types";
+import { createTransferCheckedInstruction, getAssociatedTokenAddressSync, getMint, } from "@solana/spl-token";
+import { getBase64EncodedWireTransaction, } from "@solana/transactions";
+import { ComputeBudgetProgram, Connection, PublicKey, TransactionInstruction, TransactionMessage, VersionedTransaction, } from "@solana/web3.js";
+import { PaymentRequirementsExtra } from "./facilitator.js";
+import { generateMatcher } from "./common.js";
+export function createPaymentHandler(wallet, mint, connection) {
+    const { matchTupleAndAsset } = generateMatcher(wallet.network, mint ? mint.toBase58() : "sol");
+    return async (context, accepts) => {
+        const res = accepts
+            .filter((r) => !isValidationError(matchTupleAndAsset(r)))
+            .map((requirements) => {
+            const extra = PaymentRequirementsExtra(requirements.extra);
+            if (isValidationError(extra)) {
+                throwValidationError("couldn't validate requirements extra field", extra);
+            }
+            const exec = async () => {
+                let recentBlockhash;
+                if (extra.recentBlockhash !== undefined) {
+                    recentBlockhash = extra.recentBlockhash;
+                }
+                else if (connection !== undefined) {
+                    recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+                }
+                else {
+                    throw new Error("couldn't get the latest Solana network block hash");
+                }
+                let decimals;
+                if (extra.decimals !== undefined) {
+                    decimals = extra.decimals;
+                }
+                else if (connection !== undefined) {
+                    const mintInfo = await getMint(connection, mint);
+                    decimals = mintInfo.decimals;
+                }
+                else {
+                    throw new Error("couldn't get the decimal information for the mint");
+                }
+                const paymentRequirements = {
+                    ...extra,
+                    amount: Number(requirements.maxAmountRequired),
+                    receiver: new PublicKey(requirements.payTo),
+                };
+                const sourceAccount = getAssociatedTokenAddressSync(mint, wallet.publicKey);
+                const receiverAccount = getAssociatedTokenAddressSync(mint, paymentRequirements.receiver);
+                const instructions = [
+                    ComputeBudgetProgram.setComputeUnitLimit({
+                        units: 50_000,
+                    }),
+                    ComputeBudgetProgram.setComputeUnitPrice({
+                        microLamports: 1,
+                    }),
+                    createTransferCheckedInstruction(sourceAccount, mint, receiverAccount, wallet.publicKey, paymentRequirements.amount, decimals),
+                ];
+                let tx;
+                if (wallet.buildTransaction) {
+                    tx = await wallet.buildTransaction(instructions, recentBlockhash);
+                }
+                else {
+                    const message = new TransactionMessage({
+                        instructions,
+                        payerKey: new PublicKey(paymentRequirements.feePayer),
+                        recentBlockhash,
+                    }).compileToV0Message();
+                    tx = new VersionedTransaction(message);
+                }
+                if (wallet.updateTransaction) {
+                    tx = await wallet.updateTransaction(tx);
+                }
+                const base64EncodedWireTransaction = getBase64EncodedWireTransaction({
+                    messageBytes: tx.message.serialize(),
+                    signatures: tx.signatures,
+                });
+                const payload = {
+                    transaction: base64EncodedWireTransaction,
+                };
+                return { payload };
+            };
+            return {
+                exec,
+                requirements,
+            };
+        });
+        return res;
+    };
+}

package/dist/src/exact/common.d.ts

@@ -0,0 +1,13 @@
+export declare const x402Scheme = "exact";
+export declare function generateMatcher(network: string, asset: string): {
+    matchTuple: import("arktype/internal/methods/object.ts").ObjectType<{
+        scheme: (In: string) => import("arktype/internal/attributes.ts").To<"exact">;
+        network: (In: string) => import("arktype/internal/attributes.ts").To<Lowercase<string>>;
+    }, {}>;
+    matchTupleAndAsset: import("arktype/internal/methods/object.ts").ObjectType<{
+        scheme: (In: string) => import("arktype/internal/attributes.ts").To<"exact">;
+        network: (In: string) => import("arktype/internal/attributes.ts").To<Lowercase<string>>;
+        asset: (In: string) => import("arktype/internal/attributes.ts").To<Lowercase<string>>;
+    }, {}>;
+};
+//# sourceMappingURL=common.d.ts.map

package/dist/src/exact/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/exact/common.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,UAAU,UAAU,CAAC;AAElC,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;;;;;;;EAa7D"}

package/dist/src/exact/common.js

@@ -0,0 +1,17 @@
+import { type } from "arktype";
+import { caseInsensitiveLiteral } from "@faremeter/types";
+import { lookupX402Network } from "@faremeter/info/solana";
+export const x402Scheme = "exact";
+export function generateMatcher(network, asset) {
+    const matchTuple = type({
+        scheme: caseInsensitiveLiteral(x402Scheme),
+        network: caseInsensitiveLiteral(...lookupX402Network(network)),
+    });
+    const matchTupleAndAsset = matchTuple.and({
+        asset: caseInsensitiveLiteral(asset),
+    });
+    return {
+        matchTuple,
+        matchTupleAndAsset,
+    };
+}

package/dist/src/exact/common.test.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env pnpm tsx
+export {};
+//# sourceMappingURL=common.test.d.ts.map

package/dist/src/exact/common.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.test.d.ts","sourceRoot":"","sources":["../../../src/exact/common.test.ts"],"names":[],"mappings":""}

package/dist/src/exact/common.test.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env pnpm tsx
+import t from "tap";
+import { isValidationError as iVE } from "@faremeter/types";
+import { lookupKnownSPLToken } from "@faremeter/info/solana";
+import { generateMatcher } from "./common.js";
+await t.test("testBasicMatching", async (t) => {
+    {
+        const tokenInfo = lookupKnownSPLToken("mainnet-beta", "USDC");
+        if (tokenInfo === undefined) {
+            t.bailout("couldn't find SPL token");
+            return;
+        }
+        const { matchTuple, matchTupleAndAsset } = generateMatcher("mainnet-beta", tokenInfo.address);
+        const req = {
+            network: "solana-mainnet-beta",
+            scheme: "exact",
+            asset: tokenInfo.address,
+        };
+        t.ok(!iVE(matchTuple(req)));
+        t.ok(!iVE(matchTupleAndAsset(req)));
+        t.ok(!iVE(matchTupleAndAsset({
+            ...req,
+            network: "solana",
+        })));
+        t.ok(iVE(matchTuple({
+            ...req,
+            network: "foobar",
+        })));
+        t.ok(iVE(matchTuple({
+            ...req,
+            scheme: "fner",
+        })));
+    }
+    t.end();
+});

package/dist/src/exact/facilitator.d.ts

@@ -0,0 +1,24 @@
+import type { FacilitatorHandler } from "@faremeter/types/facilitator";
+import { type Rpc, type SolanaRpcApi } from "@solana/kit";
+import type { TransactionError } from "@solana/rpc-types";
+import { Keypair, type PublicKey } from "@solana/web3.js";
+export declare const PaymentRequirementsExtra: import("arktype/internal/methods/object.ts").ObjectType<{
+    feePayer: string;
+    decimals?: number;
+    recentBlockhash?: string;
+}, {}>;
+interface FacilitatorOptions {
+    maxRetries?: number;
+    retryDelayMs?: number;
+    maxPriorityFee?: number;
+}
+export declare const PaymentPayload: import("arktype/internal/methods/object.ts").ObjectType<{
+    transaction: (In: string) => import("arktype").Out<Readonly<{
+        messageBytes: import("@solana/transactions").TransactionMessageBytes;
+        signatures: import("@solana/transactions").SignaturesMap;
+    }>>;
+}, {}>;
+export declare function transactionErrorToString(t: TransactionError): string;
+export declare const createFacilitatorHandler: (network: string, rpc: Rpc<SolanaRpcApi>, feePayerKeypair: Keypair, mint: PublicKey, config?: FacilitatorOptions) => FacilitatorHandler;
+export {};
+//# sourceMappingURL=facilitator.d.ts.map

package/dist/src/exact/facilitator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"facilitator.d.ts","sourceRoot":"","sources":["../../../src/exact/facilitator.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAGvE,OAAO,EAML,KAAK,GAAG,EACR,KAAK,YAAY,EAClB,MAAM,aAAa,CAAC;AAOrB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAC1D,OAAO,EAAE,OAAO,EAAE,KAAK,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAM1D,eAAO,MAAM,wBAAwB;;;;MAInC,CAAC;AAEH,UAAU,kBAAkB;IAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,MAAM,CAAC;IAGtB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAmBD,eAAO,MAAM,cAAc;;;;;MAEzB,CAAC;AAEH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,gBAAgB,UAY3D;AAiDD,eAAO,MAAM,wBAAwB,GACnC,SAAS,MAAM,EACf,KAAK,GAAG,CAAC,YAAY,CAAC,EACtB,iBAAiB,OAAO,EACxB,MAAM,SAAS,EACf,SAAS,kBAAkB,KAC1B,kBA+HF,CAAC"}

package/dist/src/exact/facilitator.js

@@ -0,0 +1,162 @@
+import { isValidationError } from "@faremeter/types";
+import { lookupX402Network } from "@faremeter/info/solana";
+import { fetchMint } from "@solana-program/token";
+import { address, createKeyPairSignerFromBytes, decompileTransactionMessage, getBase64Encoder, getCompiledTransactionMessageDecoder, } from "@solana/kit";
+import { getBase64EncodedWireTransaction, getTransactionDecoder, partiallySignTransaction, } from "@solana/transactions";
+import { Keypair } from "@solana/web3.js";
+import { type } from "arktype";
+import { isValidTransaction } from "./verify.js";
+import { logger } from "./logger.js";
+import { x402Scheme, generateMatcher } from "./common.js";
+export const PaymentRequirementsExtra = type({
+    feePayer: "string",
+    decimals: "number?",
+    recentBlockhash: "string?",
+});
+function errorResponse(msg) {
+    logger.error(msg);
+    return {
+        success: false,
+        error: msg,
+        txHash: null,
+        networkId: null,
+    };
+}
+const TransactionString = type("string").pipe.try((tx) => {
+    const decoder = getTransactionDecoder();
+    const base64Encoder = getBase64Encoder();
+    const transactionBytes = base64Encoder.encode(tx);
+    return decoder.decode(transactionBytes);
+});
+export const PaymentPayload = type({
+    transaction: TransactionString,
+});
+export function transactionErrorToString(t) {
+    if (typeof t == "string") {
+        return t;
+    }
+    if (typeof t == "object") {
+        return JSON.stringify(t, (_, v) => typeof v === "bigint" ? v.toString() : v);
+    }
+    return String(t);
+}
+const sendTransaction = async (rpc, signedTransaction, maxRetries, retryDelayMs) => {
+    const base64EncodedTransaction = getBase64EncodedWireTransaction(signedTransaction);
+    const simResult = await rpc
+        .simulateTransaction(base64EncodedTransaction, {
+        encoding: "base64",
+    })
+        .send();
+    if (simResult.value.err) {
+        logger.error("transaction simulation failed: {*}", simResult.value);
+        return { success: false, error: "Transaction simulation failed" };
+    }
+    const signature = await rpc
+        .sendTransaction(base64EncodedTransaction, {
+        encoding: "base64",
+    })
+        .send();
+    for (let i = 0; i < maxRetries; i++) {
+        const status = await rpc.getSignatureStatuses([signature]).send();
+        if (status.value[0]?.err) {
+            return {
+                success: false,
+                error: `Transaction failed: ${transactionErrorToString(status.value[0].err)}`,
+            };
+        }
+        if (status.value[0]?.confirmationStatus === "confirmed" ||
+            status.value[0]?.confirmationStatus === "finalized") {
+            return { success: true, signature };
+        }
+        await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+    }
+    return { success: false, error: "Transaction confirmation timeout" };
+};
+export const createFacilitatorHandler = (network, rpc, feePayerKeypair, mint, config) => {
+    const { matchTuple, matchTupleAndAsset } = generateMatcher(network, mint.toBase58());
+    const { maxRetries = 30, retryDelayMs = 1000, maxPriorityFee = 100_000, } = config ?? {};
+    const getSupported = () => {
+        return lookupX402Network(network).map((network) => Promise.resolve({
+            x402Version: 1,
+            scheme: x402Scheme,
+            network,
+            extra: {
+                feePayer: feePayerKeypair.publicKey.toString(),
+            },
+        }));
+    };
+    const getRequirements = async (req) => {
+        const recentBlockhash = (await rpc.getLatestBlockhash().send()).value
+            .blockhash;
+        const mintInfo = await fetchMint(rpc, address(mint.toBase58()));
+        return req
+            .filter((x) => !isValidationError(matchTupleAndAsset(x)))
+            .map((x) => {
+            return {
+                ...x,
+                asset: mint.toBase58(),
+                extra: {
+                    feePayer: feePayerKeypair.publicKey.toString(),
+                    decimals: mintInfo.data.decimals,
+                    recentBlockhash,
+                },
+            };
+        });
+    };
+    const handleSettle = async (requirements, payment) => {
+        if (isValidationError(matchTuple(payment))) {
+            return null;
+        }
+        const paymentPayload = PaymentPayload(payment.payload);
+        if (isValidationError(paymentPayload)) {
+            return errorResponse(paymentPayload.summary);
+        }
+        let transactionMessage, transaction;
+        try {
+            transaction = paymentPayload.transaction;
+            const compiledTransactionMessage = getCompiledTransactionMessageDecoder().decode(transaction.messageBytes);
+            transactionMessage = decompileTransactionMessage(compiledTransactionMessage);
+        }
+        catch (cause) {
+            throw new Error("Failed to get compiled transaction message", { cause });
+        }
+        try {
+            if (!(await isValidTransaction(transactionMessage, requirements, feePayerKeypair.publicKey, maxPriorityFee))) {
+                logger.error("Invalid transaction");
+                return errorResponse("Invalid transaction");
+            }
+        }
+        catch (cause) {
+            throw new Error("Failed to validate transaction", { cause });
+        }
+        let signedTransaction;
+        try {
+            const kitKeypair = await createKeyPairSignerFromBytes(feePayerKeypair.secretKey);
+            signedTransaction = await partiallySignTransaction([kitKeypair.keyPair], transaction);
+        }
+        catch (cause) {
+            throw new Error("Failed to partially sign transaction", { cause });
+        }
+        let result;
+        try {
+            result = await sendTransaction(rpc, signedTransaction, maxRetries, retryDelayMs);
+        }
+        catch (cause) {
+            throw new Error("Failed to send transaction", { cause });
+        }
+        if (!result.success) {
+            return errorResponse(result.error);
+        }
+        return {
+            success: true,
+            error: null,
+            txHash: result.signature,
+            networkId: payment.network,
+        };
+    };
+    return {
+        getSupported,
+        getRequirements,
+        handleSettle,
+    };
+};

package/dist/src/exact/facilitator.test.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env pnpm tsx
+export {};
+//# sourceMappingURL=facilitator.test.d.ts.map

package/dist/src/exact/facilitator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"facilitator.test.d.ts","sourceRoot":"","sources":["../../../src/exact/facilitator.test.ts"],"names":[],"mappings":""}

package/dist/src/exact/facilitator.test.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env pnpm tsx
+import t from "tap";
+import { transactionErrorToString } from "./facilitator.js";
+class MyBigCrazyError {
+    someBigInt = 32n;
+    someString = "a string";
+    DuplicateInstruction = 42;
+}
+await t.test("transactionErrorToString", async (t) => {
+    {
+        const err = "AccountBorrowOutstanding";
+        t.matchOnly(transactionErrorToString(err), "AccountBorrowOutstanding");
+    }
+    {
+        const err = { DuplicateInstruction: 42 };
+        t.matchOnly(transactionErrorToString(err), '{"DuplicateInstruction":42}');
+    }
+    {
+        const err = {
+            InstructionError: [32, "AccountBorrowFailed"],
+        };
+        t.matchOnly(transactionErrorToString(err), '{"InstructionError":[32,"AccountBorrowFailed"]}');
+    }
+    {
+        const err = {
+            SomeResultThatShouldNeverHappen: 1337n,
+        };
+        t.matchOnly(transactionErrorToString(err), '{"SomeResultThatShouldNeverHappen":"1337"}');
+    }
+    {
+        const err = 42;
+        t.matchOnly(transactionErrorToString(err), "42");
+    }
+    {
+        const err = new MyBigCrazyError();
+        t.matchOnly(transactionErrorToString(err), '{"someBigInt":"32","someString":"a string","DuplicateInstruction":42}');
+    }
+    t.end();
+});

package/dist/src/exact/index.d.ts

@@ -0,0 +1,3 @@
+export { createPaymentHandler } from "./client.js";
+export { createFacilitatorHandler } from "./facilitator.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/exact/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exact/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,wBAAwB,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/src/exact/index.js

@@ -0,0 +1,2 @@
+export { createPaymentHandler } from "./client.js";
+export { createFacilitatorHandler } from "./facilitator.js";

package/dist/src/exact/logger.d.ts

@@ -0,0 +1,2 @@
+export declare const logger: import("@logtape/logtape").Logger;
+//# sourceMappingURL=logger.d.ts.map

package/dist/src/exact/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/exact/logger.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,mCAAmD,CAAC"}

package/dist/src/exact/logger.js

@@ -0,0 +1,2 @@
+import { getLogger } from "@logtape/logtape";
+export const logger = getLogger(["faremeter", "payment-solana-exact"]);

package/dist/src/exact/verify.d.ts

@@ -0,0 +1,5 @@
+import type { x402PaymentRequirements } from "@faremeter/types/x402";
+import { type CompilableTransactionMessage } from "@solana/kit";
+import type { PublicKey } from "@solana/web3.js";
+export declare function isValidTransaction(transactionMessage: CompilableTransactionMessage, paymentRequirements: x402PaymentRequirements, facilitatorAddress: PublicKey, maxPriorityFee?: number): Promise<boolean>;
+//# sourceMappingURL=verify.d.ts.map

package/dist/src/exact/verify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify.d.ts","sourceRoot":"","sources":["../../../src/exact/verify.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,uBAAuB,CAAC;AAYrE,OAAO,EAEL,KAAK,4BAA4B,EAElC,MAAM,aAAa,CAAC;AAGrB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AA2GjD,wBAAsB,kBAAkB,CACtC,kBAAkB,EAAE,4BAA4B,EAChD,mBAAmB,EAAE,uBAAuB,EAC5C,kBAAkB,EAAE,SAAS,EAC7B,cAAc,CAAC,EAAE,MAAM,GACtB,OAAO,CAAC,OAAO,CAAC,CAiGlB"}

package/dist/src/exact/verify.js

@@ -0,0 +1,147 @@
+import { isValidationError } from "@faremeter/types";
+import { parseSetComputeUnitLimitInstruction, parseSetComputeUnitPriceInstruction, } from "@solana-program/compute-budget";
+import { findAssociatedTokenPda, parseCreateAssociatedTokenInstruction, parseTransferCheckedInstruction, TOKEN_PROGRAM_ADDRESS, } from "@solana-program/token";
+import { address, } from "@solana/kit";
+import { PaymentRequirementsExtra } from "./facilitator.js";
+import { logger } from "./logger.js";
+function verifyComputeUnitLimitInstruction(instruction) {
+    if (!instruction.data) {
+        return { valid: false };
+    }
+    try {
+        const parsed = parseSetComputeUnitLimitInstruction({
+            programAddress: instruction.programAddress,
+            data: new Uint8Array(instruction.data),
+        });
+        return { valid: true, units: parsed.data.units };
+    }
+    catch {
+        return { valid: false };
+    }
+}
+function verifyComputeUnitPriceInstruction(instruction) {
+    if (!instruction.data) {
+        return { valid: false };
+    }
+    try {
+        const parsed = parseSetComputeUnitPriceInstruction({
+            programAddress: instruction.programAddress,
+            data: new Uint8Array(instruction.data),
+        });
+        return { valid: true, microLamports: parsed.data.microLamports };
+    }
+    catch {
+        return { valid: false };
+    }
+}
+function calculatePriorityFee(units, microLamports) {
+    return (units * Number(microLamports)) / 1_000_000;
+}
+async function verifyTransferInstruction(instruction, paymentRequirements, destination, facilitatorAddress) {
+    if (!instruction.data || !instruction.accounts) {
+        return false;
+    }
+    let transfer;
+    try {
+        transfer = parseTransferCheckedInstruction({
+            accounts: instruction.accounts,
+            programAddress: instruction.programAddress,
+            data: new Uint8Array(instruction.data),
+        });
+    }
+    catch {
+        return false;
+    }
+    if (transfer.accounts.authority.address === facilitatorAddress) {
+        logger.error("Dropping transfer where the transfer authority is the facilitator");
+        return false;
+    }
+    const [facilitatorATA] = await findAssociatedTokenPda({
+        mint: address(paymentRequirements.asset),
+        owner: address(facilitatorAddress),
+        tokenProgram: TOKEN_PROGRAM_ADDRESS,
+    });
+    if (transfer.accounts.source.address === facilitatorATA) {
+        logger.error("Dropping transfer where the source is the facilitator");
+        return false;
+    }
+    return (transfer.data.amount === BigInt(paymentRequirements.maxAmountRequired) &&
+        transfer.accounts.mint.address === paymentRequirements.asset &&
+        transfer.accounts.destination.address === destination);
+}
+function verifyCreateATAInstruction(instruction) {
+    if (!instruction.data || !instruction.accounts) {
+        return false;
+    }
+    try {
+        parseCreateAssociatedTokenInstruction({
+            accounts: instruction.accounts,
+            programAddress: instruction.programAddress,
+            data: new Uint8Array(instruction.data),
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function isValidTransaction(transactionMessage, paymentRequirements, facilitatorAddress, maxPriorityFee) {
+    const extra = PaymentRequirementsExtra(paymentRequirements.extra);
+    if (isValidationError(extra)) {
+        throw new Error("feePayer is required");
+    }
+    if (transactionMessage.feePayer.address !== extra.feePayer) {
+        return false;
+    }
+    const [destination] = await findAssociatedTokenPda({
+        mint: address(paymentRequirements.asset),
+        owner: address(paymentRequirements.payTo),
+        tokenProgram: TOKEN_PROGRAM_ADDRESS,
+    });
+    const instructions = transactionMessage.instructions;
+    if (instructions.length === 3) {
+        // Make typescript happy...
+        const [ix0, ix1, ix2] = instructions;
+        if (!ix0 || !ix1 || !ix2) {
+            return false;
+        }
+        const limitResult = verifyComputeUnitLimitInstruction(ix0);
+        const priceResult = verifyComputeUnitPriceInstruction(ix1);
+        if (!limitResult.valid || !priceResult.valid) {
+            return false;
+        }
+        if (maxPriorityFee !== undefined &&
+            limitResult.units !== undefined &&
+            priceResult.microLamports !== undefined) {
+            const priorityFee = calculatePriorityFee(limitResult.units, priceResult.microLamports);
+            if (priorityFee > maxPriorityFee) {
+                logger.error(`Priority fee ${priorityFee} exceeds maximum ${maxPriorityFee}`);
+                return false;
+            }
+        }
+        return await verifyTransferInstruction(ix2, paymentRequirements, destination, facilitatorAddress.toBase58());
+    }
+    else if (instructions.length === 4) {
+        const [ix0, ix1, ix2, ix3] = instructions;
+        if (!ix0 || !ix1 || !ix2 || !ix3) {
+            return false;
+        }
+        const limitResult = verifyComputeUnitLimitInstruction(ix0);
+        const priceResult = verifyComputeUnitPriceInstruction(ix1);
+        if (!limitResult.valid || !priceResult.valid) {
+            return false;
+        }
+        if (maxPriorityFee !== undefined &&
+            limitResult.units !== undefined &&
+            priceResult.microLamports !== undefined) {
+            const priorityFee = calculatePriorityFee(limitResult.units, priceResult.microLamports);
+            if (priorityFee > maxPriorityFee) {
+                logger.error(`Priority fee ${priorityFee} exceeds maximum ${maxPriorityFee}`);
+                return false;
+            }
+        }
+        return (verifyCreateATAInstruction(ix2) &&
+            (await verifyTransferInstruction(ix3, paymentRequirements, destination, facilitatorAddress.toBase58())));
+    }
+    return false;
+}

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+export * as exact from "./exact/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC"}

package/dist/src/index.js

@@ -0,0 +1 @@
+export * as exact from "./exact/index.js";