@fogo/sessions-sdk 0.0.11 → 0.0.13

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.sendTransfer = exports.SessionResultType = exports.getDomainRecordAddress = exports.AuthorizedTokens = exports.AuthorizedProgramsType = exports.getSessionAccount = exports.reestablishSession = exports.replaceSession = exports.establishSession = exports.createSolanaWalletAdapter = exports.TransactionResultType = void 0;
+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.createSolanaWalletAdapter = 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");
@@ -15,22 +15,26 @@ 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 bs58_1 = __importDefault(require("bs58"));
 const zod_1 = require("zod");
 const adapter_js_1 = require("./adapter.js");
+const crypto_js_1 = require("./crypto.js");
 var adapter_js_2 = require("./adapter.js");
-Object.defineProperty(exports, "TransactionResultType", { enumerable: true, get: function () { return adapter_js_2.TransactionResultType; } });
 Object.defineProperty(exports, "createSolanaWalletAdapter", { enumerable: true, get: function () { return adapter_js_2.createSolanaWalletAdapter; } });
+Object.defineProperty(exports, "TransactionResultType", { enumerable: true, get: function () { return adapter_js_2.TransactionResultType; } });
 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 CURRENT_MINOR = "2";
 const CURRENT_INTENT_TRANSFER_MAJOR = "0";
 const CURRENT_INTENT_TRANSFER_MINOR = "1";
 const establishSession = async (options) => {
-    const sessionKey = await (0, kit_1.generateKeyPair)();
+    const sessionKey = options.createUnsafeExtractableSessionKey
+        ? await crypto.subtle.generateKey("Ed25519", true, ["sign", "verify"])
+        : await (0, kit_1.generateKeyPair)();
     if (options.unlimited) {
         return sendSessionEstablishTransaction(options, sessionKey, await Promise.all([
             buildIntentInstruction(options, sessionKey),
@@ -73,6 +77,24 @@ const replaceSession = async (options) => (0, exports.establishSession)({
     walletPublicKey: options.session.walletPublicKey,
 });
 exports.replaceSession = replaceSession;
+const revokeSession = async (options) => {
+    if (options.session.sessionInfo.minor >= 2) {
+        const instruction = await new sessions_idls_1.SessionManagerProgram(new anchor_1.AnchorProvider(options.adapter.connection, {}, {})).methods
+            .revokeSession()
+            .accounts({
+            sponsor: options.session.sessionInfo.sponsor,
+            session: options.session.sessionPublicKey,
+        })
+            .instruction();
+        return options.adapter.sendTransaction(options.session.sessionKey, [
+            instruction,
+        ]);
+    }
+    else {
+        return;
+    }
+};
+exports.revokeSession = revokeSession;
 const reestablishSession = async (adapter, walletPublicKey, sessionKey) => createSession(adapter, walletPublicKey, sessionKey);
 exports.reestablishSession = reestablishSession;
 const getSessionAccount = async (connection, sessionPublicKey) => {
@@ -98,49 +120,108 @@ const createSession = async (adapter, walletPublicKey, sessionKey) => {
 };
 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),
-                    })),
+    session_info: zod_1.z.union([
+        zod_1.z.object({
+            V1: zod_1.z.object({
+                "0": 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(),
+                    }),
+                    user: zod_1.z.instanceof(web3_js_1.PublicKey),
                 }),
             }),
-            zod_1.z.object({
-                All: zod_1.z.object({}),
+        }),
+        zod_1.z.object({
+            V2: zod_1.z.object({
+                "0": zod_1.z.union([
+                    zod_1.z.object({
+                        Revoked: zod_1.z.instanceof(bn_js_1.default),
+                    }),
+                    zod_1.z.object({
+                        Active: zod_1.z.object({
+                            "0": 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(),
+                                }),
+                                user: zod_1.z.instanceof(web3_js_1.PublicKey),
+                            }),
+                        }),
+                    }),
+                ]),
             }),
-        ]),
-        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),
-    }),
+    ]),
+    major: zod_1.z.number(),
+    sponsor: 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,
-}));
+    .transform(({ session_info, major, sponsor }) => {
+    let activeSessionInfo;
+    let minor;
+    if ("V1" in session_info) {
+        activeSessionInfo = session_info.V1["0"];
+        minor = 1;
+    }
+    else if ("Active" in session_info.V2["0"]) {
+        activeSessionInfo = session_info.V2["0"].Active["0"];
+        minor = 2;
+    }
+    else {
+        return;
+    }
+    return {
+        authorizedPrograms: "All" in activeSessionInfo.authorized_programs
+            ? AuthorizedPrograms.All()
+            : AuthorizedPrograms.Specific(activeSessionInfo.authorized_programs.Specific[0].map(({ program_id, signer_pda }) => ({
+                programId: program_id,
+                signerPda: signer_pda,
+            }))),
+        authorizedTokens: "All" in activeSessionInfo.authorized_tokens
+            ? AuthorizedTokens.All
+            : AuthorizedTokens.Specific,
+        expiration: new Date(Number(activeSessionInfo.expiration) * 1000),
+        extra: activeSessionInfo.extra[0],
+        major: major,
+        minor: minor,
+        user: activeSessionInfo.user,
+        sponsor,
+    };
+});
 var AuthorizedProgramsType;
 (function (AuthorizedProgramsType) {
     AuthorizedProgramsType[AuthorizedProgramsType["All"] = 0] = "All";
@@ -193,6 +274,36 @@ const getTokenInfo = async (adapter, limits) => {
         };
     }));
 };
+const serializeU16LE = (value) => {
+    const result = new ArrayBuffer(2);
+    new DataView(result).setUint16(0, value, true); // littleEndian = true
+    return new Uint8Array(result);
+};
+// Some wallets add a prefix to the messag before signing, for example Ledger through Phantom
+const addOffchainMessagePrefixToMessageIfNeeded = async (walletPublicKey, signature, message) => {
+    const publicKey = await crypto.subtle.importKey("raw", walletPublicKey.toBytes(), { name: "Ed25519" }, true, ["verify"]);
+    if (await (0, kit_1.verifySignature)(publicKey, signature, message)) {
+        return message;
+    }
+    else {
+        // Source: https://github.com/anza-xyz/solana-sdk/blob/master/offchain-message/src/lib.rs#L162
+        const messageWithOffchainMessagePrefix = Uint8Array.from([
+            // eslint-disable-next-line unicorn/number-literal-case
+            0xff,
+            ...new TextEncoder().encode("solana offchain"),
+            0,
+            1,
+            ...serializeU16LE(message.length),
+            ...message,
+        ]);
+        if (await (0, kit_1.verifySignature)(publicKey, signature, messageWithOffchainMessagePrefix)) {
+            return messageWithOffchainMessagePrefix;
+        }
+        else {
+            throw new Error("The signature provided by the browser wallet is not valid");
+        }
+    }
+};
 const buildIntentInstruction = async (options, sessionKey, tokens) => {
     const message = await buildMessage({
         chainId: options.adapter.chainId,
@@ -206,7 +317,7 @@ const buildIntentInstruction = async (options, sessionKey, tokens) => {
     return web3_js_1.Ed25519Program.createInstructionWithPublicKey({
         publicKey: options.walletPublicKey.toBytes(),
         signature: intentSignature,
-        message: message,
+        message: await addOffchainMessagePrefixToMessageIfNeeded(options.walletPublicKey, intentSignature, message),
     });
 };
 const buildMessage = async (body) => new TextEncoder().encode([
@@ -356,7 +467,7 @@ const buildTransferIntentInstruction = async (program, options, symbol) => {
     return web3_js_1.Ed25519Program.createInstructionWithPublicKey({
         publicKey: options.walletPublicKey.toBytes(),
         signature: intentSignature,
-        message: message,
+        message: await addOffchainMessagePrefixToMessageIfNeeded(options.walletPublicKey, intentSignature, message),
     });
 };
 const getNonce = async (program, walletPublicKey) => {
@@ -366,3 +477,46 @@ const getNonce = async (program, walletPublicKey) => {
     });
     return program.account.nonce.fetchNullable(noncePda);
 };
+const loginTokenPayloadSchema = zod_1.z.object({
+    iat: zod_1.z.number(),
+    sessionPublicKey: zod_1.z.string(),
+});
+/**
+ * Create a login token signed with the session key
+ * @param session - The session to create a login token for
+ * @returns The login token
+ */
+const createLogInToken = async (session) => {
+    const payload = {
+        // ...we can pass any arbitrary data we want to sign here...
+        iat: Date.now(),
+        sessionPublicKey: session.sessionPublicKey.toBase58(),
+    };
+    const message = JSON.stringify(payload);
+    // Sign the payload with the session private key
+    const signature = await (0, crypto_js_1.signMessageWithKey)(session.sessionKey, message);
+    // Return base58(message) + base58(signature)
+    return `${bs58_1.default.encode(new TextEncoder().encode(message))}.${signature}`;
+};
+exports.createLogInToken = createLogInToken;
+/**
+ * Verify a login token
+ * @param token - The login token to verify against the session public key
+ * @param connection - The connection to use to get the session account
+ * @returns The session account if the token is valid, otherwise undefined
+ */
+const verifyLogInToken = async (token, connection) => {
+    const [rawMessage, signature] = token.split(".");
+    if (!rawMessage || !signature)
+        return;
+    // Decode + parse payload
+    const messageStr = new TextDecoder().decode(bs58_1.default.decode(rawMessage));
+    const payload = loginTokenPayloadSchema.parse(JSON.parse(messageStr));
+    // Verify signature with sessionPublicKey
+    const sessionCryptoKey = await (0, crypto_js_1.importKey)(payload.sessionPublicKey);
+    const isValid = await (0, crypto_js_1.verifyMessageWithKey)(sessionCryptoKey, messageStr, signature);
+    if (!isValid)
+        return;
+    return (0, exports.getSessionAccount)(connection, new web3_js_1.PublicKey(payload.sessionPublicKey));
+};
+exports.verifyLogInToken = verifyLogInToken;

package/esm/adapter.js

@@ -71,7 +71,12 @@ const getSponsor = async (options, domain) => {
         const url = new URL("/api/sponsor_pubkey", options.paymaster ?? DEFAULT_PAYMASTER);
         url.searchParams.set("domain", domain);
         const response = await fetch(url);
-        return new PublicKey(z.string().parse(await response.text()));
+        if (response.status === 200) {
+            return new PublicKey(z.string().parse(await response.text()));
+        }
+        else {
+            throw new PaymasterResponseError(response.status, await response.text());
+        }
     }
 };
 const sponsorAndSendResponseSchema = z
@@ -83,7 +88,9 @@ const sponsorAndSendResponseSchema = z
     z.object({
         type: z.literal("failed"),
         signature: z.string(),
-        error: z.object({}),
+        error: z.object({
+            InstructionError: z.tuple([z.number(), z.unknown()]),
+        }),
     }),
 ])
     .transform((data) => {
@@ -97,7 +104,6 @@ const sendToPaymaster = async (options, transaction, domain) => {
     }
     else {
         const url = new URL("/api/sponsor_and_send", options.paymaster ?? DEFAULT_PAYMASTER);
-        url.searchParams.set("confirm", "true");
         url.searchParams.set("domain", domain);
         const response = await fetch(url, {
             method: "POST",

package/esm/crypto.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Sign a message using a CryptoKeyPair session key
+ * @param publicPrivateKeyPair - The public private key pair to sign the message with
+ * @param message - The message to sign
+ * @returns The signature of the message
+ */
+export declare const signMessageWithKey: (publicPrivateKeyPair: CryptoKeyPair, message: string) => Promise<string>;
+/**
+ * Verify a message with a CryptoKey public key
+ * @param publicKey - The public key of the session key
+ * @param message - The message to verify
+ * @param signature - The signature to verify
+ * @returns True if the message and signature are valid, false otherwise
+ */
+export declare const verifyMessageWithKey: (publicKey: CryptoKey, message: string, signature: string) => Promise<boolean>;
+/**
+ * Import a public key into a CryptoKey
+ * @param publicKey - The public key to import
+ * @returns The imported CryptoKey
+ */
+export declare const importKey: (publicKey: string) => Promise<CryptoKey>;

package/esm/crypto.js

@@ -0,0 +1,30 @@
+import bs58 from "bs58";
+/**
+ * Sign a message using a CryptoKeyPair session key
+ * @param publicPrivateKeyPair - The public private key pair to sign the message with
+ * @param message - The message to sign
+ * @returns The signature of the message
+ */
+export const signMessageWithKey = async (publicPrivateKeyPair, message) => {
+    const signature = await crypto.subtle.sign({ name: "Ed25519" }, publicPrivateKeyPair.privateKey, new TextEncoder().encode(message));
+    return bs58.encode(new Uint8Array(signature));
+};
+/**
+ * Verify a message with a CryptoKey public key
+ * @param publicKey - The public key of the session key
+ * @param message - The message to verify
+ * @param signature - The signature to verify
+ * @returns True if the message and signature are valid, false otherwise
+ */
+export const verifyMessageWithKey = async (publicKey, message, signature) => {
+    const isValid = await crypto.subtle.verify({ name: "Ed25519" }, publicKey, bs58.decode(signature), new TextEncoder().encode(message));
+    return isValid;
+};
+/**
+ * Import a public key into a CryptoKey
+ * @param publicKey - The public key to import
+ * @returns The imported CryptoKey
+ */
+export const importKey = async (publicKey) => {
+    return await crypto.subtle.importKey("raw", new Uint8Array(bs58.decode(publicKey)), { name: "Ed25519" }, false, ["verify"]);
+};