@fogo/sessions-sdk 0.0.17 → 0.0.19

package/cjs/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.verifyLogInToken = exports.createLogInToken = exports.sendTransfer = exports.SessionResultType = exports.getDomainRecordAddress = exports.AuthorizedTokens = exports.AuthorizedProgramsType = exports.getSessionAccount = exports.reestablishSession = exports.revokeSession = exports.replaceSession = exports.establishSession = exports.TransactionResultType = exports.createSessionContext = void 0;
+exports.verifyLogInToken = exports.createLogInToken = exports.bridgeIn = exports.bridgeOut = exports.sendTransfer = exports.SessionResultType = exports.getDomainRecordAddress = exports.AuthorizedTokens = exports.AuthorizedProgramsType = exports.getSessionAccount = exports.reestablishSession = exports.revokeSession = exports.replaceSession = exports.establishSession = exports.createSessionConnection = exports.TransactionResultType = exports.Network = exports.createSessionContext = void 0;
 const anchor_1 = require("@coral-xyz/anchor");
 const sessions_idls_1 = require("@fogo/sessions-idls");
 const mpl_token_metadata_1 = require("@metaplex-foundation/mpl-token-metadata");
@@ -14,14 +14,23 @@ const compat_1 = require("@solana/compat");
 const kit_1 = require("@solana/kit");
 const spl_token_1 = require("@solana/spl-token");
 const web3_js_1 = require("@solana/web3.js");
+const sdk_1 = require("@wormhole-foundation/sdk");
+const solana_1 = __importDefault(require("@wormhole-foundation/sdk/solana"));
+const sdk_base_1 = require("@wormhole-foundation/sdk-base");
+const sdk_route_ntt_1 = require("@wormhole-foundation/sdk-route-ntt");
+const sdk_solana_core_1 = require("@wormhole-foundation/sdk-solana-core");
+const sdk_solana_ntt_1 = require("@wormhole-foundation/sdk-solana-ntt");
 const bn_js_1 = __importDefault(require("bn.js"));
 const bs58_1 = __importDefault(require("bs58"));
 const zod_1 = require("zod");
-const context_js_1 = require("./context.js");
+const connection_js_1 = require("./connection.js");
 const crypto_js_1 = require("./crypto.js");
-var context_js_2 = require("./context.js");
-Object.defineProperty(exports, "createSessionContext", { enumerable: true, get: function () { return context_js_2.createSessionContext; } });
-Object.defineProperty(exports, "TransactionResultType", { enumerable: true, get: function () { return context_js_2.TransactionResultType; } });
+var context_js_1 = require("./context.js");
+Object.defineProperty(exports, "createSessionContext", { enumerable: true, get: function () { return context_js_1.createSessionContext; } });
+var connection_js_2 = require("./connection.js");
+Object.defineProperty(exports, "Network", { enumerable: true, get: function () { return connection_js_2.Network; } });
+Object.defineProperty(exports, "TransactionResultType", { enumerable: true, get: function () { return connection_js_2.TransactionResultType; } });
+Object.defineProperty(exports, "createSessionConnection", { enumerable: true, get: function () { return connection_js_2.createSessionConnection; } });
 const MESSAGE_HEADER = `Fogo Sessions:
 Signing this intent will allow this app to interact with your on-chain balances. Please make sure you trust this app and the domain in the message matches the domain of the current web application.
 `;
@@ -31,6 +40,12 @@ const CURRENT_MAJOR = "0";
 const CURRENT_MINOR = "3";
 const CURRENT_INTENT_TRANSFER_MAJOR = "0";
 const CURRENT_INTENT_TRANSFER_MINOR = "1";
+const CURRENT_BRIDGE_OUT_MAJOR = "0";
+const CURRENT_BRIDGE_OUT_MINOR = "1";
+const SESSION_ESTABLISHMENT_LOOKUP_TABLE_ADDRESS = {
+    [connection_js_1.Network.Testnet]: "B8cUjJMqaWWTNNSTXBmeptjWswwCH1gTSCRYv4nu7kJW",
+    [connection_js_1.Network.Mainnet]: undefined,
+};
 const establishSession = async (options) => {
     const sessionKey = options.createUnsafeExtractableSessionKey
         ? await crypto.subtle.generateKey("Ed25519", true, ["sign", "verify"])
@@ -39,7 +54,7 @@ const establishSession = async (options) => {
         return sendSessionEstablishTransaction(options, sessionKey, await Promise.all([
             buildIntentInstruction(options, sessionKey),
             buildStartSessionInstruction(options, sessionKey),
-        ]));
+        ]), options.sessionEstablishmentLookupTable);
     }
     else {
         const filteredLimits = new Map(options.limits?.entries().filter(([, amount]) => amount > 0n));
@@ -54,20 +69,23 @@ const establishSession = async (options) => {
             ...buildCreateAssociatedTokenAccountInstructions(options, tokenInfo),
             intentInstruction,
             startSessionInstruction,
-        ]);
+        ], options.sessionEstablishmentLookupTable);
     }
 };
 exports.establishSession = establishSession;
-const sendSessionEstablishTransaction = async (options, sessionKey, instructions) => {
-    const result = await options.context.sendTransaction(sessionKey, instructions);
+const sendSessionEstablishTransaction = async (options, sessionKey, instructions, sessionEstablishmentLookupTable) => {
+    const result = await options.context.sendTransaction(sessionKey, instructions, {
+        addressLookupTable: sessionEstablishmentLookupTable ??
+            SESSION_ESTABLISHMENT_LOOKUP_TABLE_ADDRESS[options.context.network],
+    });
     switch (result.type) {
-        case context_js_1.TransactionResultType.Success: {
+        case connection_js_1.TransactionResultType.Success: {
             const session = await createSession(options.context, options.walletPublicKey, sessionKey);
             return session
                 ? EstablishSessionResult.Success(result.signature, session)
                 : EstablishSessionResult.Failed(result.signature, new Error("Transaction succeeded, but the session was not created"));
         }
-        case context_js_1.TransactionResultType.Failed: {
+        case connection_js_1.TransactionResultType.Failed: {
             return EstablishSessionResult.Failed(result.signature, result.error);
         }
     }
@@ -423,6 +441,13 @@ const getDomainRecordAddress = (domain) => {
     return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("domain-record"), hash], new web3_js_1.PublicKey(sessions_idls_1.DomainRegistryIdl.address))[0];
 };
 exports.getDomainRecordAddress = getDomainRecordAddress;
+const BRIDGING_ADDRESS_LOOKUP_TABLE = {
+    [connection_js_1.Network.Testnet]: {
+        // USDC
+        ELNbJ1RtERV2fjtuZjbTscDekWhVzkQ1LjmiPsxp5uND: "4FCi6LptexBdZtaePsoCMeb1XpCijxnWu96g5LsSb6WP",
+    },
+    [connection_js_1.Network.Mainnet]: undefined,
+};
 const buildStartSessionInstruction = async (options, sessionKey, tokens) => {
     const instruction = new sessions_idls_1.SessionManagerProgram(new anchor_1.AnchorProvider(options.context.connection, {}, {})).methods
         .startSession()
@@ -505,7 +530,7 @@ const sendTransfer = async (options) => {
 exports.sendTransfer = sendTransfer;
 const buildTransferIntentInstruction = async (program, options, symbol) => {
     const [nonce, { decimals }] = await Promise.all([
-        getNonce(program, options.walletPublicKey),
+        getNonce(program, options.walletPublicKey, NonceType.Transfer),
         (0, spl_token_1.getMint)(options.context.connection, options.mint),
     ]);
     const message = new TextEncoder().encode([
@@ -526,13 +551,208 @@ const buildTransferIntentInstruction = async (program, options, symbol) => {
         message: await addOffchainMessagePrefixToMessageIfNeeded(options.walletPublicKey, intentSignature, message),
     });
 };
-const getNonce = async (program, walletPublicKey) => {
+const BRIDGE_OUT_MESSAGE_HEADER = `Fogo Bridge Transfer:
+Signing this intent will bridge out the tokens as described below.
+`;
+const bridgeOut = async (options) => {
+    const { wh, route, transferRequest, transferParams, decimals } = await buildWormholeTransfer(options, options.context.connection);
+    // @ts-expect-error the wormhole client types are incorrect and do not
+    // properly represent the runtime representation.
+    const quote = await route.fetchExecutorQuote(transferRequest, transferParams);
+    const program = new sessions_idls_1.IntentTransferProgram(new anchor_1.AnchorProvider(options.context.connection, {}, {}));
+    const umi = (0, umi_bundle_defaults_1.createUmi)(options.context.connection.rpcEndpoint);
+    const metaplexMint = (0, umi_1.publicKey)(options.fromToken.mint.toBase58());
+    const metadataAddress = (0, mpl_token_metadata_1.findMetadataPda)(umi, { mint: metaplexMint })[0];
+    const outboxItem = web3_js_1.Keypair.generate();
+    const [metadata, nttPdas] = await Promise.all([
+        (0, mpl_token_metadata_1.safeFetchMetadata)(umi, metadataAddress),
+        getNttPdas(options, wh, program, outboxItem.publicKey, new web3_js_1.PublicKey(quote.payeeAddress)),
+    ]);
+    const bridgeInstruction = await program.methods
+        .bridgeNttTokens({
+        execAmount: new bn_js_1.default(quote.estimatedCost.toString()),
+        relayInstructions: Buffer.from(quote.relayInstructions),
+        signedQuoteBytes: Buffer.from(quote.signedQuote),
+    })
+        .accounts({
+        sponsor: options.context.payer,
+        mint: options.fromToken.mint,
+        metadata: 
+        // eslint-disable-next-line unicorn/no-null
+        metadata?.symbol === undefined ? null : new web3_js_1.PublicKey(metadataAddress),
+        source: (0, spl_token_1.getAssociatedTokenAddressSync)(options.fromToken.mint, options.walletPublicKey),
+        ntt: nttPdas,
+    })
+        .instruction();
+    return options.context.sendTransaction(options.sessionKey, [
+        await buildBridgeOutIntent(program, options, decimals, metadata?.symbol),
+        bridgeInstruction,
+    ], {
+        extraSigners: [outboxItem],
+        addressLookupTable: BRIDGING_ADDRESS_LOOKUP_TABLE[options.context.network]?.[options.fromToken.mint.toBase58()],
+    });
+};
+exports.bridgeOut = bridgeOut;
+// Here we use the Wormhole SDKs to produce the wormhole pdas that are needed
+// for the bridge out transaction.  Currently this is using wormhole SDK apis
+// that are _technically_ public but it seems likely these are not considered to
+// be truly public.  It might be better to extract the pdas by using the sdk to
+// generate (but not send) a transaction, and taking the pdas from that.  That
+// may be something to revisit in the future if we find that the wormhole sdk
+// upgrades in ways that break these calls.
+const getNttPdas = async (options, wh, program, outboxItemPublicKey, quotePayeeAddress) => {
+    const pdas = sdk_solana_ntt_1.NTT.pdas(options.fromToken.manager);
+    const solana = wh.getChain("Solana");
+    const coreBridgeContract = sdk_base_1.contracts.coreBridge.get(wh.network, "Fogo");
+    if (coreBridgeContract === undefined) {
+        throw new Error("Core bridge contract address not returned by wormhole!");
+    }
+    const transceiverPdas = sdk_solana_ntt_1.NTT.transceiverPdas(options.fromToken.manager);
+    const [intentTransferSetterPda] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("intent_transfer")], program.programId);
+    const wormholePdas = sdk_solana_core_1.utils.getWormholeDerivedAccounts(options.fromToken.manager, coreBridgeContract);
+    return {
+        emitter: transceiverPdas.emitterAccount(),
+        nttConfig: pdas.configAccount(),
+        nttCustody: await sdk_solana_ntt_1.NTT.custodyAccountAddress(pdas, options.fromToken.mint),
+        nttInboxRateLimit: pdas.inboxRateLimitAccount(solana.chain),
+        nttManager: options.fromToken.manager,
+        nttOutboxItem: outboxItemPublicKey,
+        nttOutboxRateLimit: pdas.outboxRateLimitAccount(),
+        nttPeer: pdas.peerAccount(solana.chain),
+        nttSessionAuthority: pdas.sessionAuthority(intentTransferSetterPda, sdk_solana_ntt_1.NTT.transferArgs(options.amount, sdk_1.Wormhole.chainAddress("Solana", options.walletPublicKey.toBase58()), false)),
+        nttTokenAuthority: pdas.tokenAuthority(),
+        payeeNttWithExecutor: quotePayeeAddress,
+        transceiver: options.fromToken.transceiver,
+        wormholeBridge: wormholePdas.wormholeBridge,
+        wormholeFeeCollector: wormholePdas.wormholeFeeCollector,
+        wormholeMessage: transceiverPdas.wormholeMessageAccount(outboxItemPublicKey),
+        wormholeSequence: wormholePdas.wormholeSequence,
+    };
+};
+const buildBridgeOutIntent = async (program, options, decimals, symbol) => {
+    const nonce = await getNonce(program, options.walletPublicKey, NonceType.Bridge);
+    const message = new TextEncoder().encode([
+        BRIDGE_OUT_MESSAGE_HEADER,
+        serializeKV({
+            version: `${CURRENT_BRIDGE_OUT_MAJOR}.${CURRENT_BRIDGE_OUT_MINOR}`,
+            from_chain_id: options.context.chainId,
+            to_chain_id: "solana",
+            token: symbol ?? options.fromToken.mint.toBase58(),
+            amount: amountToString(options.amount, decimals),
+            recipient_address: options.walletPublicKey.toBase58(),
+            nonce: nonce === null ? "1" : nonce.nonce.add(new bn_js_1.default(1)).toString(),
+        }),
+    ].join("\n"));
+    const intentSignature = (0, kit_1.signatureBytes)(await options.solanaWallet.signMessage(message));
+    return web3_js_1.Ed25519Program.createInstructionWithPublicKey({
+        publicKey: options.walletPublicKey.toBytes(),
+        signature: intentSignature,
+        message: await addOffchainMessagePrefixToMessageIfNeeded(options.walletPublicKey, intentSignature, message),
+    });
+};
+const bridgeIn = async (options) => {
+    const solanaConnection = await options.context.getSolanaConnection();
+    const { route, transferRequest, transferParams } = await buildWormholeTransfer(options, solanaConnection);
+    // @ts-expect-error the wormhole client types are incorrect and do not
+    // properly represent the runtime representation.
+    const quote = await route.quote(transferRequest, transferParams);
+    if (quote.success) {
+        return await sdk_1.routes.checkAndCompleteTransfer(route, await route.initiate(transferRequest, {
+            address: () => options.walletPublicKey.toBase58(),
+            chain: () => "Solana",
+            signAndSend: (transactions) => Promise.all(transactions.map(({ transaction }) => options.solanaWallet.sendTransaction(
+            // Hooray for Wormhole's incomplete typing eh?
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-unsafe-member-access
+            transaction.transaction, solanaConnection, 
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+            { signers: transaction.signers, skipPreflight: true }))),
+        }, quote, sdk_1.Wormhole.chainAddress("Fogo", options.walletPublicKey.toBase58())));
+    }
+    else {
+        throw quote.error;
+    }
+};
+exports.bridgeIn = bridgeIn;
+const buildWormholeTransfer = async (options, connection) => {
+    const [wh, { decimals }] = await Promise.all([
+        (0, sdk_1.wormhole)(NETWORK_TO_WORMHOLE_NETWORK[options.context.network], [solana_1.default]),
+        (0, spl_token_1.getMint)(connection, options.fromToken.mint),
+    ]);
+    const Route = (0, sdk_route_ntt_1.nttExecutorRoute)({
+        ntt: {
+            tokens: {
+                USDC: [
+                    {
+                        chain: options.fromToken.chain,
+                        manager: options.fromToken.manager.toBase58(),
+                        token: options.fromToken.mint.toBase58(),
+                        transceiver: [
+                            {
+                                address: options.fromToken.transceiver.toBase58(),
+                                type: "wormhole",
+                            },
+                        ],
+                    },
+                    {
+                        chain: options.toToken.chain,
+                        manager: options.toToken.manager.toBase58(),
+                        token: options.toToken.mint.toBase58(),
+                        transceiver: [
+                            {
+                                address: options.toToken.transceiver.toBase58(),
+                                type: "wormhole",
+                            },
+                        ],
+                    },
+                ],
+            },
+        },
+    });
+    const route = new Route(wh);
+    const transferRequest = await sdk_1.routes.RouteTransferRequest.create(wh, {
+        source: sdk_1.Wormhole.tokenId(options.fromToken.chain, options.fromToken.mint.toBase58()),
+        destination: sdk_1.Wormhole.tokenId(options.toToken.chain, options.toToken.mint.toBase58()),
+    });
+    const validated = await route.validate(transferRequest, {
+        amount: amountToString(options.amount, decimals),
+        options: route.getDefaultOptions(),
+    });
+    if (validated.valid) {
+        return {
+            wh,
+            route,
+            transferRequest,
+            transferParams: validated.params,
+            decimals,
+        };
+    }
+    else {
+        throw validated.error;
+    }
+};
+const NETWORK_TO_WORMHOLE_NETWORK = {
+    [connection_js_1.Network.Mainnet]: "Mainnet",
+    [connection_js_1.Network.Testnet]: "Testnet",
+};
+const getNonce = async (program, walletPublicKey, nonceType) => {
     const [noncePda] = await (0, kit_1.getProgramDerivedAddress)({
         programAddress: (0, compat_1.fromLegacyPublicKey)(program.programId),
-        seeds: [Buffer.from("nonce"), walletPublicKey.toBuffer()],
+        seeds: [
+            Buffer.from(NONCE_TYPE_TO_SEED[nonceType]),
+            walletPublicKey.toBuffer(),
+        ],
     });
     return program.account.nonce.fetchNullable(noncePda);
 };
+var NonceType;
+(function (NonceType) {
+    NonceType[NonceType["Transfer"] = 0] = "Transfer";
+    NonceType[NonceType["Bridge"] = 1] = "Bridge";
+})(NonceType || (NonceType = {}));
+const NONCE_TYPE_TO_SEED = {
+    [NonceType.Transfer]: "nonce",
+    [NonceType.Bridge]: "bridge_ntt_nonce",
+};
 const loginTokenPayloadSchema = zod_1.z.object({
     iat: zod_1.z.number(),
     sessionPublicKey: zod_1.z.string(),

package/esm/connection.d.ts

@@ -0,0 +1,47 @@
+import type { Transaction, Instruction, TransactionWithLifetime } from "@solana/kit";
+import type { TransactionError } from "@solana/web3.js";
+import { Keypair, Connection as Web3Connection, TransactionInstruction, VersionedTransaction, PublicKey } from "@solana/web3.js";
+export declare enum Network {
+    Testnet = 0,
+    Mainnet = 1
+}
+export declare enum TransactionResultType {
+    Success = 0,
+    Failed = 1
+}
+declare const TransactionResult: {
+    Success: (signature: string) => {
+        type: TransactionResultType.Success;
+        signature: string;
+    };
+    Failed: (signature: string, error: TransactionError) => {
+        type: TransactionResultType.Failed;
+        signature: string;
+        error: TransactionError;
+    };
+};
+export type TransactionResult = ReturnType<(typeof TransactionResult)[keyof typeof TransactionResult]>;
+export declare const createSessionConnection: (options: {
+    network: Network;
+    rpc?: string | URL | undefined;
+} & ({
+    paymaster?: string | URL | undefined;
+    sendToPaymaster?: undefined;
+    sponsor?: undefined;
+} | {
+    paymaster?: undefined;
+    sendToPaymaster: (transaction: Transaction) => Promise<TransactionResult>;
+    sponsor: PublicKey;
+})) => {
+    rpc: import("@solana/kit").Rpc<import("@solana/kit").RequestAirdropApi & import("@solana/kit").GetAccountInfoApi & import("@solana/kit").GetBalanceApi & import("@solana/kit").GetBlockApi & import("@solana/kit").GetBlockCommitmentApi & import("@solana/kit").GetBlockHeightApi & import("@solana/kit").GetBlockProductionApi & import("@solana/kit").GetBlocksApi & import("@solana/kit").GetBlocksWithLimitApi & import("@solana/kit").GetBlockTimeApi & import("@solana/kit").GetClusterNodesApi & import("@solana/kit").GetEpochInfoApi & import("@solana/kit").GetEpochScheduleApi & import("@solana/kit").GetFeeForMessageApi & import("@solana/kit").GetFirstAvailableBlockApi & import("@solana/kit").GetGenesisHashApi & import("@solana/kit").GetHealthApi & import("@solana/kit").GetHighestSnapshotSlotApi & import("@solana/kit").GetIdentityApi & import("@solana/kit").GetInflationGovernorApi & import("@solana/kit").GetInflationRateApi & import("@solana/kit").GetInflationRewardApi & import("@solana/kit").GetLargestAccountsApi & import("@solana/kit").GetLatestBlockhashApi & import("@solana/kit").GetLeaderScheduleApi & import("@solana/kit").GetMaxRetransmitSlotApi & import("@solana/kit").GetMaxShredInsertSlotApi & import("@solana/kit").GetMinimumBalanceForRentExemptionApi & import("@solana/kit").GetMultipleAccountsApi & import("@solana/kit").GetProgramAccountsApi & import("@solana/kit").GetRecentPerformanceSamplesApi & import("@solana/kit").GetRecentPrioritizationFeesApi & import("@solana/kit").GetSignaturesForAddressApi & import("@solana/kit").GetSignatureStatusesApi & import("@solana/kit").GetSlotApi & import("@solana/kit").GetSlotLeaderApi & import("@solana/kit").GetSlotLeadersApi & import("@solana/kit").GetStakeMinimumDelegationApi & import("@solana/kit").GetSupplyApi & import("@solana/kit").GetTokenAccountBalanceApi & import("@solana/kit").GetTokenAccountsByDelegateApi & import("@solana/kit").GetTokenAccountsByOwnerApi & import("@solana/kit").GetTokenLargestAccountsApi & import("@solana/kit").GetTokenSupplyApi & import("@solana/kit").GetTransactionApi & import("@solana/kit").GetTransactionCountApi & import("@solana/kit").GetVersionApi & import("@solana/kit").GetVoteAccountsApi & import("@solana/kit").IsBlockhashValidApi & import("@solana/kit").MinimumLedgerSlotApi & import("@solana/kit").SendTransactionApi & import("@solana/kit").SimulateTransactionApi>;
+    connection: Web3Connection;
+    network: Network;
+    getSolanaConnection: () => Promise<Web3Connection>;
+    sendToPaymaster: (domain: string, sponsor: PublicKey, sessionKey: CryptoKeyPair | undefined, instructions: (TransactionInstruction | Instruction)[] | VersionedTransaction | (Transaction & TransactionWithLifetime), extraConfig?: {
+        addressLookupTable?: string | undefined;
+        extraSigners?: (CryptoKeyPair | Keypair)[] | undefined;
+    }) => Promise<TransactionResult>;
+    getSponsor: (domain: string) => Promise<PublicKey>;
+};
+export type Connection = ReturnType<typeof createSessionConnection>;
+export {};

package/esm/connection.js

@@ -0,0 +1,187 @@
+import { fromLegacyKeypair, fromLegacyPublicKey, fromLegacyTransactionInstruction, fromVersionedTransaction, } from "@solana/compat";
+import { createSolanaRpc, getBase64EncodedWireTransaction, createTransactionMessage, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, partiallySignTransactionMessageWithSigners, pipe, addSignersToTransactionMessage, compressTransactionMessageUsingAddressLookupTables, createSignerFromKeyPair, partiallySignTransaction, } from "@solana/kit";
+import { Keypair, Connection as Web3Connection, TransactionInstruction, VersionedTransaction, PublicKey, } from "@solana/web3.js";
+import { z } from "zod";
+export var Network;
+(function (Network) {
+    Network[Network["Testnet"] = 0] = "Testnet";
+    Network[Network["Mainnet"] = 1] = "Mainnet";
+})(Network || (Network = {}));
+const DEFAULT_RPC = {
+    [Network.Testnet]: "https://testnet.fogo.io",
+    [Network.Mainnet]: "https://mainnet.fogo.io",
+};
+const DEFAULT_PAYMASTER = {
+    [Network.Testnet]: "https://paymaster.fogo.io",
+    [Network.Mainnet]: "https://paymaster.dourolabs.app",
+};
+export var TransactionResultType;
+(function (TransactionResultType) {
+    TransactionResultType[TransactionResultType["Success"] = 0] = "Success";
+    TransactionResultType[TransactionResultType["Failed"] = 1] = "Failed";
+})(TransactionResultType || (TransactionResultType = {}));
+const TransactionResult = {
+    Success: (signature) => ({
+        type: TransactionResultType.Success,
+        signature,
+    }),
+    Failed: (signature, error) => ({
+        type: TransactionResultType.Failed,
+        signature,
+        error,
+    }),
+};
+export const createSessionConnection = (options) => {
+    const rpcUrl = (options.rpc ?? DEFAULT_RPC[options.network]).toString();
+    const rpc = createSolanaRpc(rpcUrl);
+    const connection = new Web3Connection(rpcUrl, "confirmed");
+    const addressLookupTableCache = new Map();
+    return {
+        rpc,
+        connection,
+        network: options.network,
+        getSolanaConnection: createSolanaConnectionGetter(options.network),
+        sendToPaymaster: async (domain, sponsor, sessionKey, instructions, extraConfig) => {
+            const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+            const transaction = await buildTransaction(connection, latestBlockhash, sessionKey, sponsor, instructions, addressLookupTableCache, extraConfig);
+            return sendToPaymaster(options, domain, transaction);
+        },
+        getSponsor: (domain) => getSponsor(options, domain),
+    };
+};
+const createSolanaConnectionGetter = (network) => {
+    let connection;
+    return async () => {
+        if (connection === undefined) {
+            const url = new URL("https://api.fogo.io/api/solana-rpc");
+            url.searchParams.set("network", NETWORK_TO_QUERY_PARAM[network]);
+            const rpcUrlRes = await fetch(url);
+            if (rpcUrlRes.status === 200) {
+                const rpcUrl = await rpcUrlRes.text();
+                connection = new Web3Connection(rpcUrl);
+            }
+            else {
+                throw new Error("Failed to resolve Solana RPC url");
+            }
+        }
+        return connection;
+    };
+};
+const NETWORK_TO_QUERY_PARAM = {
+    [Network.Mainnet]: "mainnet",
+    [Network.Testnet]: "testnet",
+};
+const sendToPaymaster = async (options, domain, transaction) => {
+    if (options.sendToPaymaster === undefined) {
+        const url = new URL("/api/sponsor_and_send", options.paymaster ?? DEFAULT_PAYMASTER[options.network]);
+        url.searchParams.set("domain", domain);
+        const response = await fetch(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                transaction: getBase64EncodedWireTransaction(transaction),
+            }),
+        });
+        if (response.status === 200) {
+            return sponsorAndSendResponseSchema.parse(await response.json());
+        }
+        else {
+            throw new PaymasterResponseError(response.status, await response.text());
+        }
+    }
+    else {
+        return options.sendToPaymaster(transaction);
+    }
+};
+const buildTransaction = async (connection, latestBlockhash, sessionKey, sponsor, instructions, addressLookupTableCache, extraConfig) => {
+    const [signerKeys, addressLookupTable] = await Promise.all([
+        getSignerKeys(sessionKey, extraConfig?.extraSigners),
+        extraConfig?.addressLookupTable === undefined
+            ? Promise.resolve(undefined)
+            : getAddressLookupTable(connection, addressLookupTableCache, extraConfig.addressLookupTable),
+    ]);
+    if (Array.isArray(instructions)) {
+        const signers = await Promise.all(signerKeys.map((signer) => createSignerFromKeyPair(signer)));
+        return partiallySignTransactionMessageWithSigners(pipe(createTransactionMessage({ version: 0 }), (tx) => setTransactionMessageFeePayer(fromLegacyPublicKey(sponsor), tx), (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx), (tx) => appendTransactionMessageInstructions(instructions.map((instruction) => instruction instanceof TransactionInstruction
+            ? fromLegacyTransactionInstruction(instruction)
+            : instruction), tx), (tx) => addressLookupTable === undefined
+            ? tx
+            : compressTransactionMessageUsingAddressLookupTables(tx, {
+                [fromLegacyPublicKey(addressLookupTable.key)]: addressLookupTable.state.addresses.map((address) => fromLegacyPublicKey(address)),
+            }), (tx) => addSignersToTransactionMessage(signers, tx)));
+    }
+    else {
+        const tx = instructions instanceof VersionedTransaction
+            ? fromVersionedTransaction(instructions) // VersionedTransaction has a lifetime so it's fine to cast it so we can call partiallySignTransaction
+            : instructions;
+        return partiallySignTransaction(signerKeys, tx);
+    }
+};
+const getSignerKeys = async (sessionKey, extraSigners) => {
+    const extraSignerKeys = extraSigners === undefined
+        ? []
+        : await Promise.all(extraSigners.map((signer) => signer instanceof Keypair ? fromLegacyKeypair(signer) : signer));
+    return [
+        ...extraSignerKeys,
+        ...(sessionKey === undefined ? [] : [sessionKey]),
+    ];
+};
+const sponsorAndSendResponseSchema = z
+    .discriminatedUnion("type", [
+    z.object({
+        type: z.literal("success"),
+        signature: z.string(),
+    }),
+    z.object({
+        type: z.literal("failed"),
+        signature: z.string(),
+        error: z.object({
+            InstructionError: z.tuple([z.number(), z.unknown()]),
+        }),
+    }),
+])
+    .transform((data) => {
+    return data.type === "success"
+        ? TransactionResult.Success(data.signature)
+        : TransactionResult.Failed(data.signature, data.error);
+});
+const getSponsor = async (options, domain) => {
+    if (options.sponsor === undefined) {
+        const url = new URL("/api/sponsor_pubkey", options.paymaster ?? DEFAULT_PAYMASTER[options.network]);
+        url.searchParams.set("domain", domain);
+        const response = await fetch(url);
+        if (response.status === 200) {
+            return new PublicKey(z.string().parse(await response.text()));
+        }
+        else {
+            throw new PaymasterResponseError(response.status, await response.text());
+        }
+    }
+    else {
+        return options.sponsor;
+    }
+};
+const getAddressLookupTable = async (connection, addressLookupTableCache, addressLookupTableAddress) => {
+    const value = addressLookupTableCache.get(addressLookupTableAddress);
+    if (value === undefined) {
+        const result = await connection.getAddressLookupTable(new PublicKey(addressLookupTableAddress));
+        if (result.value === null) {
+            return;
+        }
+        else {
+            addressLookupTableCache.set(addressLookupTableAddress, result.value);
+            return result.value;
+        }
+    }
+    else {
+        return value;
+    }
+};
+class PaymasterResponseError extends Error {
+    constructor(statusCode, message) {
+        super(`Paymaster sent a ${statusCode.toString()} response: ${message}`);
+        this.name = "PaymasterResponseError";
+    }
+}

package/esm/context.d.ts

@@ -1,40 +1,17 @@
-import type { Transaction, Instruction, TransactionWithLifetime } from "@solana/kit";
-import type { Connection, TransactionError } from "@solana/web3.js";
-import { PublicKey, TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
-export type SessionContext = {
-    chainId: string;
-    connection: Connection;
-    payer: PublicKey;
-    domain: string;
-    sendTransaction: (sessionKey: CryptoKeyPair | undefined, instructions: (TransactionInstruction | Instruction)[] | VersionedTransaction | (Transaction & TransactionWithLifetime)) => Promise<TransactionResult>;
-};
-export declare enum TransactionResultType {
-    Success = 0,
-    Failed = 1
-}
-declare const TransactionResult: {
-    Success: (signature: string) => {
-        type: TransactionResultType.Success;
-        signature: string;
-    };
-    Failed: (signature: string, error: TransactionError) => {
-        type: TransactionResultType.Failed;
-        signature: string;
-        error: TransactionError;
-    };
-};
-export type TransactionResult = ReturnType<(typeof TransactionResult)[keyof typeof TransactionResult]>;
+import { Connection as Web3Connection } from "@solana/web3.js";
+import type { Connection } from "./connection.js";
 export declare const createSessionContext: (options: {
     connection: Connection;
-    addressLookupTableAddress?: string | undefined;
+    defaultAddressLookupTableAddress?: string | undefined;
     domain?: string | undefined;
-} & ({
-    paymaster?: string | URL | undefined;
-    sendToPaymaster?: undefined;
-    sponsor?: undefined;
-} | {
-    paymaster?: undefined;
-    sendToPaymaster: (transaction: Transaction) => Promise<TransactionResult>;
-    sponsor: PublicKey;
-})) => Promise<SessionContext>;
-export {};
+}) => Promise<{
+    chainId: string;
+    domain: string;
+    payer: import("@solana/web3.js").PublicKey;
+    getSolanaConnection: () => Promise<Web3Connection>;
+    connection: Web3Connection;
+    rpc: import("@solana/kit").Rpc<import("@solana/kit").RequestAirdropApi & import("@solana/kit").GetAccountInfoApi & import("@solana/kit").GetBalanceApi & import("@solana/kit").GetBlockApi & import("@solana/kit").GetBlockCommitmentApi & import("@solana/kit").GetBlockHeightApi & import("@solana/kit").GetBlockProductionApi & import("@solana/kit").GetBlocksApi & import("@solana/kit").GetBlocksWithLimitApi & import("@solana/kit").GetBlockTimeApi & import("@solana/kit").GetClusterNodesApi & import("@solana/kit").GetEpochInfoApi & import("@solana/kit").GetEpochScheduleApi & import("@solana/kit").GetFeeForMessageApi & import("@solana/kit").GetFirstAvailableBlockApi & import("@solana/kit").GetGenesisHashApi & import("@solana/kit").GetHealthApi & import("@solana/kit").GetHighestSnapshotSlotApi & import("@solana/kit").GetIdentityApi & import("@solana/kit").GetInflationGovernorApi & import("@solana/kit").GetInflationRateApi & import("@solana/kit").GetInflationRewardApi & import("@solana/kit").GetLargestAccountsApi & import("@solana/kit").GetLatestBlockhashApi & import("@solana/kit").GetLeaderScheduleApi & import("@solana/kit").GetMaxRetransmitSlotApi & import("@solana/kit").GetMaxShredInsertSlotApi & import("@solana/kit").GetMinimumBalanceForRentExemptionApi & import("@solana/kit").GetMultipleAccountsApi & import("@solana/kit").GetProgramAccountsApi & import("@solana/kit").GetRecentPerformanceSamplesApi & import("@solana/kit").GetRecentPrioritizationFeesApi & import("@solana/kit").GetSignaturesForAddressApi & import("@solana/kit").GetSignatureStatusesApi & import("@solana/kit").GetSlotApi & import("@solana/kit").GetSlotLeaderApi & import("@solana/kit").GetSlotLeadersApi & import("@solana/kit").GetStakeMinimumDelegationApi & import("@solana/kit").GetSupplyApi & import("@solana/kit").GetTokenAccountBalanceApi & import("@solana/kit").GetTokenAccountsByDelegateApi & import("@solana/kit").GetTokenAccountsByOwnerApi & import("@solana/kit").GetTokenLargestAccountsApi & import("@solana/kit").GetTokenSupplyApi & import("@solana/kit").GetTransactionApi & import("@solana/kit").GetTransactionCountApi & import("@solana/kit").GetVersionApi & import("@solana/kit").GetVoteAccountsApi & import("@solana/kit").IsBlockhashValidApi & import("@solana/kit").MinimumLedgerSlotApi & import("@solana/kit").SendTransactionApi & import("@solana/kit").SimulateTransactionApi>;
+    network: import("./connection.js").Network;
+    sendTransaction: (sessionKey: CryptoKeyPair | undefined, instructions: Parameters<typeof options.connection.sendToPaymaster>[3], extraConfig?: Parameters<typeof options.connection.sendToPaymaster>[4]) => Promise<import("./connection.js").TransactionResult>;
+}>;
+export type SessionContext = Awaited<ReturnType<typeof createSessionContext>>;