@fogo/sessions-sdk 0.0.6 → 0.0.8

package/cjs/index.js

@@ -1,6 +1,9 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SessionResultType = exports.getDomainRecordAddress = exports.reestablishSession = exports.replaceSession = exports.establishSession = exports.createSolanaWalletAdapter = exports.TransactionResultType = void 0;
+exports.SessionResultType = exports.getDomainRecordAddress = exports.AuthorizedTokens = exports.AuthorizedProgramsType = exports.getSessionAccount = exports.reestablishSession = exports.replaceSession = exports.establishSession = exports.createSolanaWalletAdapter = exports.TransactionResultType = 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");
@@ -10,6 +13,8 @@ const sha2_1 = require("@noble/hashes/sha2");
 const kit_1 = require("@solana/kit");
 const spl_token_1 = require("@solana/spl-token");
 const web3_js_1 = require("@solana/web3.js");
+const bn_js_1 = __importDefault(require("bn.js"));
+const zod_1 = require("zod");
 const adapter_js_1 = require("./adapter.js");
 var adapter_js_2 = require("./adapter.js");
 Object.defineProperty(exports, "TransactionResultType", { enumerable: true, get: function () { return adapter_js_2.TransactionResultType; } });
@@ -17,45 +22,139 @@ Object.defineProperty(exports, "createSolanaWalletAdapter", { enumerable: true,
 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.
 `;
+const UNLIMITED_TOKEN_PERMISSIONS_VALUE = "this app may spend any amount of any token";
+const TOKENLESS_PERMISSIONS_VALUE = "this app may not spend any tokens";
 const CURRENT_MAJOR = "0";
 const CURRENT_MINOR = "1";
 const establishSession = async (options) => {
     const sessionKey = await (0, kit_1.generateKeyPair)();
-    const tokenInfo = await getTokenInfo(options);
-    const [intentInstruction, startSessionInstruction] = await Promise.all([
-        buildIntentInstruction(options, sessionKey, tokenInfo),
-        buildStartSessionInstruction(options, sessionKey, tokenInfo),
-    ]);
-    const result = await options.adapter.sendTransaction(sessionKey, [
-        ...buildCreateAssociatedTokenAccountInstructions(options, tokenInfo),
-        intentInstruction,
-        startSessionInstruction,
-    ]);
+    if (options.unlimited) {
+        return sendSessionEstablishTransaction(options, sessionKey, await Promise.all([
+            buildIntentInstruction(options, sessionKey),
+            buildStartSessionInstruction(options, sessionKey),
+        ]));
+    }
+    else {
+        const filteredLimits = new Map(options.limits?.entries().filter(([, amount]) => amount > 0n));
+        const tokenInfo = filteredLimits.size > 0
+            ? await getTokenInfo(options.adapter, filteredLimits)
+            : [];
+        const [intentInstruction, startSessionInstruction] = await Promise.all([
+            buildIntentInstruction(options, sessionKey, tokenInfo),
+            buildStartSessionInstruction(options, sessionKey, tokenInfo),
+        ]);
+        return sendSessionEstablishTransaction(options, sessionKey, [
+            ...buildCreateAssociatedTokenAccountInstructions(options, tokenInfo),
+            intentInstruction,
+            startSessionInstruction,
+        ]);
+    }
+};
+exports.establishSession = establishSession;
+const sendSessionEstablishTransaction = async (options, sessionKey, instructions) => {
+    const result = await options.adapter.sendTransaction(sessionKey, instructions);
     switch (result.type) {
         case adapter_js_1.TransactionResultType.Success: {
-            return EstablishSessionResult.Success(result.signature, await createSession(options.adapter, options.walletPublicKey, sessionKey));
+            const session = await createSession(options.adapter, 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 adapter_js_1.TransactionResultType.Failed: {
             return EstablishSessionResult.Failed(result.signature, result.error);
         }
     }
 };
-exports.establishSession = establishSession;
 const replaceSession = async (options) => (0, exports.establishSession)({
     ...options,
     walletPublicKey: options.session.walletPublicKey,
 });
 exports.replaceSession = replaceSession;
-// TODO we really should check to ensure the session is still valid...
 const reestablishSession = async (adapter, walletPublicKey, sessionKey) => createSession(adapter, walletPublicKey, sessionKey);
 exports.reestablishSession = reestablishSession;
-const createSession = async (adapter, walletPublicKey, sessionKey) => ({
-    sessionPublicKey: new web3_js_1.PublicKey(await (0, kit_1.getAddressFromPublicKey)(sessionKey.publicKey)),
-    walletPublicKey,
-    sessionKey,
-    payer: adapter.payer,
-    sendTransaction: (instructions) => adapter.sendTransaction(sessionKey, instructions),
-});
+const getSessionAccount = async (connection, sessionPublicKey) => {
+    const result = await connection.getAccountInfo(sessionPublicKey);
+    return result === null
+        ? undefined
+        : sessionInfoSchema.parse(new anchor_1.BorshAccountsCoder(sessions_idls_1.SessionManagerIdl).decode("Session", result.data));
+};
+exports.getSessionAccount = getSessionAccount;
+const createSession = async (adapter, walletPublicKey, sessionKey) => {
+    const sessionPublicKey = new web3_js_1.PublicKey(await (0, kit_1.getAddressFromPublicKey)(sessionKey.publicKey));
+    const sessionInfo = await (0, exports.getSessionAccount)(adapter.connection, sessionPublicKey);
+    return sessionInfo === undefined
+        ? undefined
+        : {
+            sessionPublicKey,
+            walletPublicKey,
+            sessionKey,
+            payer: adapter.payer,
+            sendTransaction: (instructions) => adapter.sendTransaction(sessionKey, instructions),
+            sessionInfo,
+        };
+};
+const sessionInfoSchema = zod_1.z
+    .object({
+    session_info: zod_1.z.object({
+        authorized_programs: zod_1.z.union([
+            zod_1.z.object({
+                Specific: zod_1.z.object({
+                    0: zod_1.z.array(zod_1.z.object({
+                        program_id: zod_1.z.instanceof(web3_js_1.PublicKey),
+                        signer_pda: zod_1.z.instanceof(web3_js_1.PublicKey),
+                    })),
+                }),
+            }),
+            zod_1.z.object({
+                All: zod_1.z.object({}),
+            }),
+        ]),
+        authorized_tokens: zod_1.z.union([
+            zod_1.z.object({ Specific: zod_1.z.object({}) }),
+            zod_1.z.object({ All: zod_1.z.object({}) }),
+        ]),
+        expiration: zod_1.z.instanceof(bn_js_1.default),
+        extra: zod_1.z.object({
+            0: zod_1.z.unknown(),
+        }),
+        major: zod_1.z.number(),
+        minor: zod_1.z.number(),
+        user: zod_1.z.instanceof(web3_js_1.PublicKey),
+    }),
+})
+    .transform(({ session_info }) => ({
+    authorizedPrograms: "All" in session_info.authorized_programs
+        ? AuthorizedPrograms.All()
+        : AuthorizedPrograms.Specific(session_info.authorized_programs.Specific[0].map(({ program_id, signer_pda }) => ({
+            programId: program_id,
+            signerPda: signer_pda,
+        }))),
+    authorizedTokens: "All" in session_info.authorized_tokens
+        ? AuthorizedTokens.All
+        : AuthorizedTokens.Specific,
+    expiration: new Date(Number(session_info.expiration) * 1000),
+    extra: session_info.extra[0],
+    major: session_info.major,
+    minor: session_info.minor,
+    user: session_info.user,
+}));
+var AuthorizedProgramsType;
+(function (AuthorizedProgramsType) {
+    AuthorizedProgramsType[AuthorizedProgramsType["All"] = 0] = "All";
+    AuthorizedProgramsType[AuthorizedProgramsType["Specific"] = 1] = "Specific";
+})(AuthorizedProgramsType || (exports.AuthorizedProgramsType = AuthorizedProgramsType = {}));
+const AuthorizedPrograms = {
+    All: () => ({ type: AuthorizedProgramsType.All }),
+    Specific: (programs) => ({
+        type: AuthorizedProgramsType.Specific,
+        programs,
+    }),
+};
+var AuthorizedTokens;
+(function (AuthorizedTokens) {
+    AuthorizedTokens[AuthorizedTokens["All"] = 0] = "All";
+    AuthorizedTokens[AuthorizedTokens["Specific"] = 1] = "Specific";
+})(AuthorizedTokens || (exports.AuthorizedTokens = AuthorizedTokens = {}));
 const SymbolOrMintType = {
     Symbol: "Symbol",
     Mint: "Mint",
@@ -70,13 +169,13 @@ const SymbolOrMint = {
         mint,
     }),
 };
-const getTokenInfo = async (options) => {
-    const umi = (0, umi_bundle_defaults_1.createUmi)(options.adapter.connection.rpcEndpoint);
-    return Promise.all(options.limits.entries().map(async ([mint, amount]) => {
+const getTokenInfo = async (adapter, limits) => {
+    const umi = (0, umi_bundle_defaults_1.createUmi)(adapter.connection.rpcEndpoint);
+    return Promise.all(limits.entries().map(async ([mint, amount]) => {
         const metaplexMint = (0, umi_1.publicKey)(mint.toBase58());
         const metadataAddress = (0, mpl_token_metadata_1.findMetadataPda)(umi, { mint: metaplexMint })[0];
         const [mintInfo, metadata] = await Promise.all([
-            (0, spl_token_1.getMint)(options.adapter.connection, mint),
+            (0, spl_token_1.getMint)(adapter.connection, mint),
             (0, mpl_token_metadata_1.safeFetchMetadata)(umi, metadataAddress),
         ]);
         return {
@@ -121,14 +220,21 @@ const buildMessage = async (body) => new TextEncoder().encode([
 const serializeKV = (data) => Object.entries(data)
     .map(([key, value]) => [key, ":", value.startsWith("\n") ? "" : " ", value].join(""))
     .join("\n");
-const serializeTokenList = (tokens) => tokens.length === 0
-    ? "\n"
-    : tokens
-        .values()
-        .filter(({ amount }) => amount > 0n)
-        .map(({ symbolOrMint, amount, decimals }) => `\n-${symbolOrMint.type === SymbolOrMintType.Symbol ? symbolOrMint.symbol : symbolOrMint.mint.toBase58()}: ${amountToString(amount, decimals)}`)
-        .toArray()
-        .join("");
+const serializeTokenList = (tokens) => {
+    if (tokens === undefined) {
+        return UNLIMITED_TOKEN_PERMISSIONS_VALUE;
+    }
+    else if (tokens.length === 0) {
+        return TOKENLESS_PERMISSIONS_VALUE;
+    }
+    else {
+        return tokens
+            .values()
+            .map(({ symbolOrMint, amount, decimals }) => `\n-${symbolOrMint.type === SymbolOrMintType.Symbol ? symbolOrMint.symbol : symbolOrMint.mint.toBase58()}: ${amountToString(amount, decimals)}`)
+            .toArray()
+            .join("");
+    }
+};
 const amountToString = (amount, decimals) => {
     const asStr = amount.toString();
     const whole = asStr.length > decimals ? asStr.slice(0, asStr.length - decimals) : "0";
@@ -146,35 +252,40 @@ 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 buildStartSessionInstruction = async (options, sessionKey, tokens) => new sessions_idls_1.SessionManagerProgram(new anchor_1.AnchorProvider(options.adapter.connection, {}, {})).methods
-    .startSession()
-    .accounts({
-    sponsor: options.adapter.payer,
-    session: await (0, kit_1.getAddressFromPublicKey)(sessionKey.publicKey),
-    domainRegistry: (0, exports.getDomainRecordAddress)(options.adapter.domain),
-})
-    .remainingAccounts(tokens.flatMap(({ symbolOrMint, mint, metadataAddress }) => [
-    {
-        pubkey: (0, spl_token_1.getAssociatedTokenAddressSync)(mint, options.walletPublicKey),
-        isWritable: true,
-        isSigner: false,
-    },
-    {
-        pubkey: mint,
-        isWritable: false,
-        isSigner: false,
-    },
-    ...(symbolOrMint.type === SymbolOrMintType.Symbol
-        ? [
+const buildStartSessionInstruction = async (options, sessionKey, tokens) => {
+    const instruction = new sessions_idls_1.SessionManagerProgram(new anchor_1.AnchorProvider(options.adapter.connection, {}, {})).methods
+        .startSession()
+        .accounts({
+        sponsor: options.adapter.payer,
+        session: await (0, kit_1.getAddressFromPublicKey)(sessionKey.publicKey),
+        domainRegistry: (0, exports.getDomainRecordAddress)(options.adapter.domain),
+    });
+    return tokens === undefined
+        ? instruction.instruction()
+        : instruction
+            .remainingAccounts(tokens.flatMap(({ symbolOrMint, mint, metadataAddress }) => [
+            {
+                pubkey: (0, spl_token_1.getAssociatedTokenAddressSync)(mint, options.walletPublicKey),
+                isWritable: true,
+                isSigner: false,
+            },
             {
-                pubkey: metadataAddress,
+                pubkey: mint,
                 isWritable: false,
                 isSigner: false,
             },
-        ]
-        : []),
-]))
-    .instruction();
+            ...(symbolOrMint.type === SymbolOrMintType.Symbol
+                ? [
+                    {
+                        pubkey: metadataAddress,
+                        isWritable: false,
+                        isSigner: false,
+                    },
+                ]
+                : []),
+        ]))
+            .instruction();
+};
 var SessionResultType;
 (function (SessionResultType) {
     SessionResultType[SessionResultType["Success"] = 0] = "Success";

package/cjs/paymaster.js

@@ -4,16 +4,12 @@ exports.createPaymasterEndpoint = exports.sponsorAndSend = void 0;
 const compat_1 = require("@solana/compat");
 const kit_1 = require("@solana/kit");
 const zod_1 = require("zod");
-const sponsorAndSend = async (rpc, sponsor, transaction) => {
-    const signedTransaction = await (0, kit_1.signTransaction)([sponsor], transaction);
-    await rpc
-        .sendTransaction((0, kit_1.getBase64EncodedWireTransaction)(signedTransaction), {
-        encoding: "base64",
-        skipPreflight: true,
-    })
-        .send();
-    return (0, kit_1.getSignatureFromTransaction)(signedTransaction);
-};
+const sponsorAndSend = async (rpc, sponsor, transaction) => rpc
+    .sendTransaction((0, kit_1.getBase64EncodedWireTransaction)(await (0, kit_1.signTransaction)([sponsor], transaction)), {
+    encoding: "base64",
+    skipPreflight: true,
+})
+    .send();
 exports.sponsorAndSend = sponsorAndSend;
 const createPaymasterEndpoint = async (options) => {
     const rpc = (0, kit_1.createSolanaRpc)(options.rpc);

package/esm/adapter.d.ts

@@ -26,12 +26,12 @@ declare const TransactionResult: {
 export type TransactionResult = ReturnType<(typeof TransactionResult)[keyof typeof TransactionResult]>;
 export declare const createSolanaWalletAdapter: (options: {
     connection: Connection;
-    sponsor: PublicKey;
     addressLookupTableAddress?: string | undefined;
     domain?: string | undefined;
 } & ({
-    paymasterUrl: string;
+    paymaster?: string | URL | undefined;
 } | {
     sendToPaymaster: (transaction: Transaction) => Promise<string>;
+    sponsor: PublicKey;
 })) => Promise<SessionAdapter>;
 export {};

package/esm/adapter.js

@@ -3,8 +3,11 @@ import { ChainIdProgram } from "@fogo/sessions-idls";
 import { fromLegacyPublicKey, fromLegacyTransactionInstruction, fromVersionedTransaction, } from "@solana/compat";
 import { createTransactionMessage, setTransactionMessageFeePayer, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstructions, getBase64EncodedWireTransaction, partiallySignTransactionMessageWithSigners, pipe, createSolanaRpc, addSignersToTransactionMessage, compressTransactionMessageUsingAddressLookupTables, createSignerFromKeyPair, partiallySignTransaction, } from "@solana/kit";
 import { PublicKey, Keypair, TransactionInstruction, VersionedTransaction, } from "@solana/web3.js";
+import { z } from "zod";
 // eslint-disable-next-line unicorn/no-typeof-undefined
 const IS_BROWSER = typeof globalThis.window !== "undefined";
+const DEFAULT_PAYMASTER = "https://paymaster.fogo.io";
+const DEFAULT_ADDRESS_LOOKUP_TABLE_ADDRESS = "B8cUjJMqaWWTNNSTXBmeptjWswwCH1gTSCRYv4nu7kJW";
 export var TransactionResultType;
 (function (TransactionResultType) {
     TransactionResultType[TransactionResultType["Success"] = 0] = "Success";
@@ -23,9 +26,10 @@ const TransactionResult = {
 };
 export const createSolanaWalletAdapter = async (options) => {
     const addressLookupTables = await getAddressLookupTables(options.connection, options.addressLookupTableAddress);
+    const sponsor = await getSponsor(options);
     return {
         connection: options.connection,
-        payer: options.sponsor,
+        payer: sponsor,
         chainId: await fetchChainId(options.connection),
         domain: getDomain(options.domain),
         sendTransaction: async (sessionKey, instructions) => {
@@ -33,7 +37,7 @@ export const createSolanaWalletAdapter = async (options) => {
             const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
             const sessionKeySigner = await createSignerFromKeyPair(sessionKey);
             const transaction = Array.isArray(instructions)
-                ? await partiallySignTransactionMessageWithSigners(pipe(createTransactionMessage({ version: 0 }), (tx) => setTransactionMessageFeePayer(fromLegacyPublicKey(options.sponsor), tx), (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx), (tx) => appendTransactionMessageInstructions(instructions.map((instruction) => instruction instanceof TransactionInstruction
+                ? await 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) => compressTransactionMessageUsingAddressLookupTables(tx, Object.fromEntries(addressLookupTables?.map((table) => [
                     fromLegacyPublicKey(table.key),
@@ -42,9 +46,7 @@ export const createSolanaWalletAdapter = async (options) => {
                 : await partiallySignTransaction([sessionKey], instructions instanceof VersionedTransaction
                     ? fromVersionedTransaction(instructions)
                     : instructions);
-            const signature = "sendToPaymaster" in options
-                ? await options.sendToPaymaster(transaction)
-                : await sendToPaymaster(options.paymasterUrl, transaction);
+            const signature = await sendToPaymaster(options, transaction);
             const lastValidBlockHeight = await rpc.getSlot().send();
             const confirmationResult = await options.connection.confirmTransaction({
                 signature,
@@ -57,34 +59,43 @@ export const createSolanaWalletAdapter = async (options) => {
         },
     };
 };
-const sendToPaymaster = async (paymasterUrl, transaction) => {
-    const response = await fetch(paymasterUrl, {
-        method: "POST",
-        headers: {
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify({
-            transaction: getBase64EncodedWireTransaction(transaction),
-        }),
-    });
-    if (response.status === 200) {
-        return response.text();
+const getSponsor = async (options) => {
+    if ("sponsor" in options) {
+        return options.sponsor;
     }
     else {
-        throw new PaymasterResponseError(response.status, await response.text());
+        const response = await fetch(new URL("/api/sponsor_pubkey", options.paymaster ?? DEFAULT_PAYMASTER));
+        return new PublicKey(z.string().parse(await response.text()));
     }
 };
-const getAddressLookupTables = async (connection, addressLookupTableAddress) => {
-    if (addressLookupTableAddress === undefined) {
-        return [];
+const sendToPaymaster = async (options, transaction) => {
+    if ("sendToPaymaster" in options) {
+        return options.sendToPaymaster(transaction);
     }
     else {
-        const addressLookupTableResult = await connection.getAddressLookupTable(new PublicKey(addressLookupTableAddress));
-        return addressLookupTableResult.value
-            ? [addressLookupTableResult.value]
-            : undefined;
+        const response = await fetch(new URL("/api/sponsor_and_send", options.paymaster ?? DEFAULT_PAYMASTER), {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify({
+                transaction: getBase64EncodedWireTransaction(transaction),
+            }),
+        });
+        if (response.status === 200) {
+            return response.text();
+        }
+        else {
+            throw new PaymasterResponseError(response.status, await response.text());
+        }
     }
 };
+const getAddressLookupTables = async (connection, addressLookupTableAddress = DEFAULT_ADDRESS_LOOKUP_TABLE_ADDRESS) => {
+    const addressLookupTableResult = await connection.getAddressLookupTable(new PublicKey(addressLookupTableAddress));
+    return addressLookupTableResult.value
+        ? [addressLookupTableResult.value]
+        : undefined;
+};
 const fetchChainId = async (connection) => {
     const chainIdProgram = new ChainIdProgram(new AnchorProvider(connection, { publicKey: new Keypair().publicKey }, {})); // We mock the wallet because we don't need to sign anything
     const { chainIdAccount: chainIdAddress } = await chainIdProgram.methods