@fogo/sessions-sdk 0.0.6 → 0.0.8

package/esm/index.d.ts

@@ -1,5 +1,7 @@
-import type { TransactionError } from "@solana/web3.js";
+import type { TransactionError, Connection } from "@solana/web3.js";
 import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import { z } from "zod";
 import type { SessionAdapter, TransactionResult } from "./adapter.js";
 export { type SessionAdapter, type TransactionResult, TransactionResultType, createSolanaWalletAdapter, } from "./adapter.js";
 type EstablishSessionOptions = {
@@ -7,19 +9,261 @@ type EstablishSessionOptions = {
     walletPublicKey: PublicKey;
     signMessage: (message: Uint8Array) => Promise<Uint8Array>;
     expires: Date;
-    limits: Map<PublicKey, bigint>;
     extra?: string | undefined;
-};
+} & ({
+    limits?: Map<PublicKey, bigint>;
+    unlimited?: false;
+} | {
+    unlimited: true;
+});
 export declare const establishSession: (options: EstablishSessionOptions) => Promise<EstablishSessionResult>;
 export declare const replaceSession: (options: {
     adapter: SessionAdapter;
     session: Session;
     signMessage: (message: Uint8Array) => Promise<Uint8Array>;
     expires: Date;
-    limits: Map<PublicKey, bigint>;
     extra?: string | undefined;
-}) => Promise<EstablishSessionResult>;
-export declare const reestablishSession: (adapter: SessionAdapter, walletPublicKey: PublicKey, sessionKey: CryptoKeyPair) => Promise<Session>;
+} & ({
+    limits?: Map<PublicKey, bigint>;
+    unlimited?: false;
+} | {
+    unlimited: true;
+})) => Promise<EstablishSessionResult>;
+export declare const reestablishSession: (adapter: SessionAdapter, walletPublicKey: PublicKey, sessionKey: CryptoKeyPair) => Promise<Session | undefined>;
+export declare const getSessionAccount: (connection: Connection, sessionPublicKey: PublicKey) => Promise<{
+    authorizedPrograms: {
+        type: AuthorizedProgramsType.All;
+    } | {
+        type: AuthorizedProgramsType.Specific;
+        programs: {
+            programId: PublicKey;
+            signerPda: PublicKey;
+        }[];
+    };
+    authorizedTokens: AuthorizedTokens;
+    expiration: Date;
+    extra: unknown;
+    major: number;
+    minor: number;
+    user: PublicKey;
+} | undefined>;
+declare const sessionInfoSchema: z.ZodEffects<z.ZodObject<{
+    session_info: z.ZodObject<{
+        authorized_programs: z.ZodUnion<[z.ZodObject<{
+            Specific: z.ZodObject<{
+                0: z.ZodArray<z.ZodObject<{
+                    program_id: z.ZodType<PublicKey, z.ZodTypeDef, PublicKey>;
+                    signer_pda: z.ZodType<PublicKey, z.ZodTypeDef, PublicKey>;
+                }, "strip", z.ZodTypeAny, {
+                    program_id: PublicKey;
+                    signer_pda: PublicKey;
+                }, {
+                    program_id: PublicKey;
+                    signer_pda: PublicKey;
+                }>, "many">;
+            }, "strip", z.ZodTypeAny, {
+                0: {
+                    program_id: PublicKey;
+                    signer_pda: PublicKey;
+                }[];
+            }, {
+                0: {
+                    program_id: PublicKey;
+                    signer_pda: PublicKey;
+                }[];
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            Specific: {
+                0: {
+                    program_id: PublicKey;
+                    signer_pda: PublicKey;
+                }[];
+            };
+        }, {
+            Specific: {
+                0: {
+                    program_id: PublicKey;
+                    signer_pda: PublicKey;
+                }[];
+            };
+        }>, z.ZodObject<{
+            All: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        }, "strip", z.ZodTypeAny, {
+            All: {};
+        }, {
+            All: {};
+        }>]>;
+        authorized_tokens: z.ZodUnion<[z.ZodObject<{
+            Specific: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        }, "strip", z.ZodTypeAny, {
+            Specific: {};
+        }, {
+            Specific: {};
+        }>, z.ZodObject<{
+            All: z.ZodObject<{}, "strip", z.ZodTypeAny, {}, {}>;
+        }, "strip", z.ZodTypeAny, {
+            All: {};
+        }, {
+            All: {};
+        }>]>;
+        expiration: z.ZodType<BN, z.ZodTypeDef, BN>;
+        extra: z.ZodObject<{
+            0: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            0?: unknown;
+        }, {
+            0?: unknown;
+        }>;
+        major: z.ZodNumber;
+        minor: z.ZodNumber;
+        user: z.ZodType<PublicKey, z.ZodTypeDef, PublicKey>;
+    }, "strip", z.ZodTypeAny, {
+        authorized_programs: {
+            Specific: {
+                0: {
+                    program_id: PublicKey;
+                    signer_pda: PublicKey;
+                }[];
+            };
+        } | {
+            All: {};
+        };
+        authorized_tokens: {
+            Specific: {};
+        } | {
+            All: {};
+        };
+        expiration: BN;
+        extra: {
+            0?: unknown;
+        };
+        major: number;
+        minor: number;
+        user: PublicKey;
+    }, {
+        authorized_programs: {
+            Specific: {
+                0: {
+                    program_id: PublicKey;
+                    signer_pda: PublicKey;
+                }[];
+            };
+        } | {
+            All: {};
+        };
+        authorized_tokens: {
+            Specific: {};
+        } | {
+            All: {};
+        };
+        expiration: BN;
+        extra: {
+            0?: unknown;
+        };
+        major: number;
+        minor: number;
+        user: PublicKey;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    session_info: {
+        authorized_programs: {
+            Specific: {
+                0: {
+                    program_id: PublicKey;
+                    signer_pda: PublicKey;
+                }[];
+            };
+        } | {
+            All: {};
+        };
+        authorized_tokens: {
+            Specific: {};
+        } | {
+            All: {};
+        };
+        expiration: BN;
+        extra: {
+            0?: unknown;
+        };
+        major: number;
+        minor: number;
+        user: PublicKey;
+    };
+}, {
+    session_info: {
+        authorized_programs: {
+            Specific: {
+                0: {
+                    program_id: PublicKey;
+                    signer_pda: PublicKey;
+                }[];
+            };
+        } | {
+            All: {};
+        };
+        authorized_tokens: {
+            Specific: {};
+        } | {
+            All: {};
+        };
+        expiration: BN;
+        extra: {
+            0?: unknown;
+        };
+        major: number;
+        minor: number;
+        user: PublicKey;
+    };
+}>, {
+    authorizedPrograms: {
+        type: AuthorizedProgramsType.All;
+    } | {
+        type: AuthorizedProgramsType.Specific;
+        programs: {
+            programId: PublicKey;
+            signerPda: PublicKey;
+        }[];
+    };
+    authorizedTokens: AuthorizedTokens;
+    expiration: Date;
+    extra: unknown;
+    major: number;
+    minor: number;
+    user: PublicKey;
+}, {
+    session_info: {
+        authorized_programs: {
+            Specific: {
+                0: {
+                    program_id: PublicKey;
+                    signer_pda: PublicKey;
+                }[];
+            };
+        } | {
+            All: {};
+        };
+        authorized_tokens: {
+            Specific: {};
+        } | {
+            All: {};
+        };
+        expiration: BN;
+        extra: {
+            0?: unknown;
+        };
+        major: number;
+        minor: number;
+        user: PublicKey;
+    };
+}>;
+export declare enum AuthorizedProgramsType {
+    All = 0,
+    Specific = 1
+}
+export declare enum AuthorizedTokens {
+    All = 0,
+    Specific = 1
+}
 export declare const getDomainRecordAddress: (domain: string) => PublicKey;
 export declare enum SessionResultType {
     Success = 0,
@@ -44,4 +288,5 @@ export type Session = {
     walletPublicKey: PublicKey;
     payer: PublicKey;
     sendTransaction: (instructions: Parameters<SessionAdapter["sendTransaction"]>[1]) => Promise<TransactionResult>;
+    sessionInfo: z.infer<typeof sessionInfoSchema>;
 };

package/esm/index.js

@@ -1,5 +1,5 @@
-import { AnchorProvider } from "@coral-xyz/anchor";
-import { DomainRegistryIdl, SessionManagerProgram } from "@fogo/sessions-idls";
+import { AnchorProvider, BorshAccountsCoder } from "@coral-xyz/anchor";
+import { DomainRegistryIdl, SessionManagerProgram, SessionManagerIdl, } from "@fogo/sessions-idls";
 import { findMetadataPda, safeFetchMetadata, } from "@metaplex-foundation/mpl-token-metadata";
 import { publicKey as metaplexPublicKey } from "@metaplex-foundation/umi";
 import { createUmi } from "@metaplex-foundation/umi-bundle-defaults";
@@ -7,28 +7,49 @@ import { sha256 } from "@noble/hashes/sha2";
 import { generateKeyPair, getAddressFromPublicKey } from "@solana/kit";
 import { createAssociatedTokenAccountIdempotentInstruction, getAssociatedTokenAddressSync, getMint, } from "@solana/spl-token";
 import { Ed25519Program, PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import { z } from "zod";
 import { TransactionResultType } from "./adapter.js";
 export { TransactionResultType, createSolanaWalletAdapter, } from "./adapter.js";
 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";
 export const establishSession = async (options) => {
     const sessionKey = await 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,
+        ]);
+    }
+};
+const sendSessionEstablishTransaction = async (options, sessionKey, instructions) => {
+    const result = await options.adapter.sendTransaction(sessionKey, instructions);
     switch (result.type) {
         case 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 TransactionResultType.Failed: {
             return EstablishSessionResult.Failed(result.signature, result.error);
@@ -39,15 +60,89 @@ export const replaceSession = async (options) => establishSession({
     ...options,
     walletPublicKey: options.session.walletPublicKey,
 });
-// TODO we really should check to ensure the session is still valid...
 export const reestablishSession = async (adapter, walletPublicKey, sessionKey) => createSession(adapter, walletPublicKey, sessionKey);
-const createSession = async (adapter, walletPublicKey, sessionKey) => ({
-    sessionPublicKey: new PublicKey(await getAddressFromPublicKey(sessionKey.publicKey)),
-    walletPublicKey,
-    sessionKey,
-    payer: adapter.payer,
-    sendTransaction: (instructions) => adapter.sendTransaction(sessionKey, instructions),
-});
+export const getSessionAccount = async (connection, sessionPublicKey) => {
+    const result = await connection.getAccountInfo(sessionPublicKey);
+    return result === null
+        ? undefined
+        : sessionInfoSchema.parse(new BorshAccountsCoder(SessionManagerIdl).decode("Session", result.data));
+};
+const createSession = async (adapter, walletPublicKey, sessionKey) => {
+    const sessionPublicKey = new PublicKey(await getAddressFromPublicKey(sessionKey.publicKey));
+    const sessionInfo = await getSessionAccount(adapter.connection, sessionPublicKey);
+    return sessionInfo === undefined
+        ? undefined
+        : {
+            sessionPublicKey,
+            walletPublicKey,
+            sessionKey,
+            payer: adapter.payer,
+            sendTransaction: (instructions) => adapter.sendTransaction(sessionKey, instructions),
+            sessionInfo,
+        };
+};
+const sessionInfoSchema = z
+    .object({
+    session_info: z.object({
+        authorized_programs: z.union([
+            z.object({
+                Specific: z.object({
+                    0: z.array(z.object({
+                        program_id: z.instanceof(PublicKey),
+                        signer_pda: z.instanceof(PublicKey),
+                    })),
+                }),
+            }),
+            z.object({
+                All: z.object({}),
+            }),
+        ]),
+        authorized_tokens: z.union([
+            z.object({ Specific: z.object({}) }),
+            z.object({ All: z.object({}) }),
+        ]),
+        expiration: z.instanceof(BN),
+        extra: z.object({
+            0: z.unknown(),
+        }),
+        major: z.number(),
+        minor: z.number(),
+        user: z.instanceof(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,
+}));
+export var AuthorizedProgramsType;
+(function (AuthorizedProgramsType) {
+    AuthorizedProgramsType[AuthorizedProgramsType["All"] = 0] = "All";
+    AuthorizedProgramsType[AuthorizedProgramsType["Specific"] = 1] = "Specific";
+})(AuthorizedProgramsType || (AuthorizedProgramsType = {}));
+const AuthorizedPrograms = {
+    All: () => ({ type: AuthorizedProgramsType.All }),
+    Specific: (programs) => ({
+        type: AuthorizedProgramsType.Specific,
+        programs,
+    }),
+};
+export var AuthorizedTokens;
+(function (AuthorizedTokens) {
+    AuthorizedTokens[AuthorizedTokens["All"] = 0] = "All";
+    AuthorizedTokens[AuthorizedTokens["Specific"] = 1] = "Specific";
+})(AuthorizedTokens || (AuthorizedTokens = {}));
 const SymbolOrMintType = {
     Symbol: "Symbol",
     Mint: "Mint",
@@ -62,13 +157,13 @@ const SymbolOrMint = {
         mint,
     }),
 };
-const getTokenInfo = async (options) => {
-    const umi = createUmi(options.adapter.connection.rpcEndpoint);
-    return Promise.all(options.limits.entries().map(async ([mint, amount]) => {
+const getTokenInfo = async (adapter, limits) => {
+    const umi = createUmi(adapter.connection.rpcEndpoint);
+    return Promise.all(limits.entries().map(async ([mint, amount]) => {
         const metaplexMint = metaplexPublicKey(mint.toBase58());
         const metadataAddress = findMetadataPda(umi, { mint: metaplexMint })[0];
         const [mintInfo, metadata] = await Promise.all([
-            getMint(options.adapter.connection, mint),
+            getMint(adapter.connection, mint),
             safeFetchMetadata(umi, metadataAddress),
         ]);
         return {
@@ -113,14 +208,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";
@@ -137,35 +239,40 @@ export const getDomainRecordAddress = (domain) => {
     const hash = sha256(domain);
     return PublicKey.findProgramAddressSync([Buffer.from("domain-record"), hash], new PublicKey(DomainRegistryIdl.address))[0];
 };
-const buildStartSessionInstruction = async (options, sessionKey, tokens) => new SessionManagerProgram(new AnchorProvider(options.adapter.connection, {}, {})).methods
-    .startSession()
-    .accounts({
-    sponsor: options.adapter.payer,
-    session: await getAddressFromPublicKey(sessionKey.publicKey),
-    domainRegistry: getDomainRecordAddress(options.adapter.domain),
-})
-    .remainingAccounts(tokens.flatMap(({ symbolOrMint, mint, metadataAddress }) => [
-    {
-        pubkey: 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 SessionManagerProgram(new AnchorProvider(options.adapter.connection, {}, {})).methods
+        .startSession()
+        .accounts({
+        sponsor: options.adapter.payer,
+        session: await getAddressFromPublicKey(sessionKey.publicKey),
+        domainRegistry: getDomainRecordAddress(options.adapter.domain),
+    });
+    return tokens === undefined
+        ? instruction.instruction()
+        : instruction
+            .remainingAccounts(tokens.flatMap(({ symbolOrMint, mint, metadataAddress }) => [
             {
-                pubkey: metadataAddress,
+                pubkey: getAssociatedTokenAddressSync(mint, options.walletPublicKey),
+                isWritable: true,
+                isSigner: false,
+            },
+            {
+                pubkey: mint,
                 isWritable: false,
                 isSigner: false,
             },
-        ]
-        : []),
-]))
-    .instruction();
+            ...(symbolOrMint.type === SymbolOrMintType.Symbol
+                ? [
+                    {
+                        pubkey: metadataAddress,
+                        isWritable: false,
+                        isSigner: false,
+                    },
+                ]
+                : []),
+        ]))
+            .instruction();
+};
 export var SessionResultType;
 (function (SessionResultType) {
     SessionResultType[SessionResultType["Success"] = 0] = "Success";

package/esm/paymaster.js

@@ -1,17 +1,13 @@
 import { fromLegacyKeypair } from "@solana/compat";
-import { signTransaction, createSolanaRpc, getBase64EncodedWireTransaction, getTransactionDecoder, getBase64Encoder, getSignatureFromTransaction, } from "@solana/kit";
+import { signTransaction, createSolanaRpc, getBase64EncodedWireTransaction, getTransactionDecoder, getBase64Encoder, } from "@solana/kit";
 import { Keypair } from "@solana/web3.js";
 import { z } from "zod";
-export const sponsorAndSend = async (rpc, sponsor, transaction) => {
-    const signedTransaction = await signTransaction([sponsor], transaction);
-    await rpc
-        .sendTransaction(getBase64EncodedWireTransaction(signedTransaction), {
-        encoding: "base64",
-        skipPreflight: true,
-    })
-        .send();
-    return getSignatureFromTransaction(signedTransaction);
-};
+export const sponsorAndSend = async (rpc, sponsor, transaction) => rpc
+    .sendTransaction(getBase64EncodedWireTransaction(await signTransaction([sponsor], transaction)), {
+    encoding: "base64",
+    skipPreflight: true,
+})
+    .send();
 export const createPaymasterEndpoint = async (options) => {
     const rpc = createSolanaRpc(options.rpc);
     const sponsor = await fromLegacyKeypair(options.sponsor);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fogo/sessions-sdk",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "A set of utilities for integrating with Fogo sessions",
   "keywords": [
     "fogo",
@@ -45,8 +45,9 @@
     "@solana/kit": "^2.1.1",
     "@solana/spl-token": "^0.4.13",
     "@solana/web3.js": "^1.92.3",
+    "bn.js": "^5.1.2",
     "bs58": "^6.0.0",
     "zod": "^3.25.62",
-    "@fogo/sessions-idls": "^0.0.2"
+    "@fogo/sessions-idls": "^0.0.3"
   }
 }