@fogo/sessions-sdk 0.1.8 → 0.1.10

package/esm/index.js

@@ -3,17 +3,18 @@ import { DomainRegistryIdl, IntentTransferIdl, IntentTransferProgram, SessionMan
 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";
-import { sha256 } from "@noble/hashes/sha2";
+import { sha256 } from "@noble/hashes/sha2.js";
 import { fromLegacyPublicKey } from "@solana/compat";
-import { generateKeyPair, getAddressFromPublicKey, getProgramDerivedAddress, } from "@solana/kit";
+import { generateKeyPair, getAddressFromPublicKey, getOffchainMessageDecoder, getProgramDerivedAddress, } from "@solana/kit";
 import { getAssociatedTokenAddressSync, getMint } from "@solana/spl-token";
-import { ComputeBudgetProgram, Ed25519Program, Keypair, PublicKey, } from "@solana/web3.js";
-import { routes, Wormhole, wormhole } from "@wormhole-foundation/sdk";
+import { ComputeBudgetProgram, Ed25519Program, Keypair, PublicKey, TransactionInstruction, } from "@solana/web3.js";
+import { Wormhole, wormhole } from "@wormhole-foundation/sdk";
 import solanaSdk from "@wormhole-foundation/sdk/solana";
 import { contracts } from "@wormhole-foundation/sdk-base";
+import * as routes from "@wormhole-foundation/sdk-connect/routes";
 import { nttExecutorRoute } from "@wormhole-foundation/sdk-route-ntt";
 import { utils } from "@wormhole-foundation/sdk-solana-core";
-import { NTT } from "@wormhole-foundation/sdk-solana-ntt";
+import { NTT, register as registerNtt, } from "@wormhole-foundation/sdk-solana-ntt";
 import BN from "bn.js";
 import bs58 from "bs58";
 import { z } from "zod";
@@ -23,6 +24,7 @@ import { importKey, signMessageWithKey, verifyMessageWithKey, } from "./crypto.j
 import { createSessionUnwrapInstruction, createSessionWrapInstructions, createSystemProgramSessionWrapInstruction, } from "./instructions.js";
 import { USDC_DECIMALS, USDC_MINT } from "./mints.js";
 import { Network } from "./network.js";
+registerNtt();
 export { createSessionConnection, TransactionResultType, } from "./connection.js";
 export { createSessionContext, } from "./context.js";
 export { createPaymasterFeeInstruction, createSessionUnwrapInstruction, createSessionWrapInstructions, createSystemProgramSessionWrapInstruction, } from "./instructions.js";
@@ -67,9 +69,9 @@ export const establishSession = async (options) => {
 };
 const sendSessionEstablishTransaction = async (options, sessionKey, instructions, sessionEstablishmentLookupTable) => {
     const result = await options.context.sendTransaction(sessionKey, instructions, options.walletPublicKey, {
-        variation: "Session Establishment",
         addressLookupTable: sessionEstablishmentLookupTable ??
             SESSION_ESTABLISHMENT_LOOKUP_TABLE_ADDRESS[options.context.network],
+        variation: "Session Establishment",
     });
     switch (result.type) {
         case TransactionResultType.Success: {
@@ -92,8 +94,8 @@ export const revokeSession = async (options) => {
         const instruction = await new SessionManagerProgram(new AnchorProvider(options.context.connection, {}, {})).methods
             .revokeSession()
             .accounts({
-            sponsor: options.session.sessionInfo.sponsor,
             session: options.session.sessionPublicKey,
+            sponsor: options.session.sessionInfo.sponsor,
         })
             .instruction();
         return options.context.sendTransaction(options.session.sessionKey, [instruction], options.session.walletPublicKey, {
@@ -143,17 +145,17 @@ const createSession = async (context, walletPublicKey, sessionKey) => {
         !authorizedProgramsMatchDomainRegistry(sessionInfo.authorizedPrograms, domainRegistryAuthorizedPrograms)
         ? undefined
         : {
-            sessionPublicKey,
-            walletPublicKey,
-            sessionKey,
-            payer: context.payer,
-            getSystemProgramSessionWrapInstruction: (amount) => createSystemProgramSessionWrapInstruction(sessionPublicKey, walletPublicKey, amount),
-            getSessionWrapInstructions: (amount) => createSessionWrapInstructions(sessionPublicKey, walletPublicKey, amount),
             getSessionUnwrapInstructions: () => [
                 createSessionUnwrapInstruction(sessionPublicKey, walletPublicKey),
             ],
+            getSessionWrapInstructions: (amount) => createSessionWrapInstructions(sessionPublicKey, walletPublicKey, amount),
+            getSystemProgramSessionWrapInstruction: (amount) => createSystemProgramSessionWrapInstruction(sessionPublicKey, walletPublicKey, amount),
+            payer: context.payer,
             sendTransaction: (instructions, extraConfig) => context.sendTransaction(sessionKey, instructions, walletPublicKey, extraConfig),
             sessionInfo,
+            sessionKey,
+            sessionPublicKey,
+            walletPublicKey,
         };
 };
 const authorizedTokensSchema = z.union([
@@ -165,9 +167,9 @@ const authorizedTokensSchema = z.union([
     z.object({ All: z.object({}) }),
 ]);
 const revokedSessionInfoSchema = z.object({
-    user: z.instanceof(PublicKey),
-    expiration: z.instanceof(BN),
     authorized_tokens_with_mints: authorizedTokensSchema,
+    expiration: z.instanceof(BN),
+    user: z.instanceof(PublicKey),
 });
 const activeSessionInfoSchema = z.object({
     authorized_programs: z.union([
@@ -199,6 +201,7 @@ const activeSessionInfoSchema = z.object({
 });
 const sessionInfoSchema = z
     .object({
+    major: z.number(),
     session_info: z.union([
         z.object({
             V1: z.object({
@@ -292,8 +295,8 @@ const sessionInfoSchema = z
                     z.object({
                         Active: z.object({
                             "0": z.object({
-                                domain_hash: z.array(z.number()).length(32),
                                 active_session_info: activeSessionInfoSchema,
+                                domain_hash: z.array(z.number()).length(32),
                             }),
                         }),
                     }),
@@ -301,7 +304,6 @@ const sessionInfoSchema = z
             }),
         }),
     ]),
-    major: z.number(),
     sponsor: z.instanceof(PublicKey),
 })
     .transform(({ session_info, major, sponsor }) => {
@@ -340,8 +342,8 @@ const sessionInfoSchema = z
         extra: activeSessionInfo.extra[0],
         major: major,
         minor: minor,
-        user: activeSessionInfo.user,
         sponsor,
+        user: activeSessionInfo.user,
     };
 });
 export var AuthorizedProgramsType;
@@ -352,8 +354,8 @@ export var AuthorizedProgramsType;
 const AuthorizedPrograms = {
     All: () => ({ type: AuthorizedProgramsType.All }),
     Specific: (programs) => ({
-        type: AuthorizedProgramsType.Specific,
         programs,
+        type: AuthorizedProgramsType.Specific,
     }),
 };
 export var AuthorizedTokens;
@@ -367,13 +369,13 @@ var SymbolOrMintType;
     SymbolOrMintType[SymbolOrMintType["Mint"] = 1] = "Mint";
 })(SymbolOrMintType || (SymbolOrMintType = {}));
 const SymbolOrMint = {
-    Symbol: (symbol) => ({
-        type: SymbolOrMintType.Symbol,
-        symbol,
-    }),
     Mint: (mint) => ({
-        type: SymbolOrMintType.Mint,
         mint,
+        type: SymbolOrMintType.Mint,
+    }),
+    Symbol: (symbol) => ({
+        symbol,
+        type: SymbolOrMintType.Symbol,
     }),
 };
 const getTokenInfo = (context, limits) => {
@@ -386,17 +388,19 @@ const getTokenInfo = (context, limits) => {
             safeFetchMetadata(umi, metadataAddress),
         ]);
         return {
+            amount,
+            decimals: mintInfo.decimals,
+            metadataAddress: new PublicKey(metadataAddress),
+            mint,
             symbolOrMint: metadata?.symbol
                 ? SymbolOrMint.Symbol(metadata.symbol)
                 : SymbolOrMint.Mint(mint),
-            metadataAddress: new PublicKey(metadataAddress),
-            amount,
-            mint,
-            decimals: mintInfo.decimals,
         };
     }));
 };
-const buildStartSessionIntentInstruction = async (options, sessionKey, tokens) => buildIntentInstruction(options, MESSAGE_HEADER, {
+const buildStartSessionIntentInstruction = async (options, sessionKey, tokens) => buildIntentInstruction(options, MESSAGE_HEADER, 
+// biome-ignore assist/source/useSortedKeys: The sort order is important here
+{
     version: `${CURRENT_MAJOR}.${CURRENT_MINOR}`,
     chain_id: options.context.chainId,
     domain: options.context.domain,
@@ -407,12 +411,80 @@ const buildStartSessionIntentInstruction = async (options, sessionKey, tokens) =
 const buildIntentInstruction = async (options, header, body, extra) => {
     const message = new TextEncoder().encode([header, serializeKV(body), extra && serializeExtra(extra)].join("\n"));
     const { signature, signedMessage } = await options.signMessage(message);
-    return Ed25519Program.createInstructionWithPublicKey({
-        publicKey: options.walletPublicKey.toBytes(),
-        signature,
-        message: signedMessage,
+    const publicKey = options.walletPublicKey.toBytes();
+    const publicKeyOffsetInMessage = getOffchainMessagePublicKeyOffset(signedMessage, options.walletPublicKey);
+    if (publicKeyOffsetInMessage !== undefined) {
+        return buildEd25519InstructionWithOffsets({
+            message: signedMessage,
+            publicKeyOffsetInMessage,
+            signature,
+        });
+    }
+    else {
+        return Ed25519Program.createInstructionWithPublicKey({
+            message: signedMessage,
+            publicKey,
+            signature,
+        });
+    }
+};
+const ED25519_HEADER_LEN = 16;
+const ED25519_PUBLIC_KEY_LEN = 32;
+const ED25519_SIGNATURE_LEN = 64;
+const ED25519_CURRENT_INSTRUCTION_INDEX = 0xff_ff;
+const buildEd25519InstructionWithOffsets = (params) => {
+    const { signature, message, publicKeyOffsetInMessage } = params;
+    if (signature.length !== ED25519_SIGNATURE_LEN) {
+        throw new Error(`Signature must be ${ED25519_SIGNATURE_LEN} bytes but received ${signature.length} bytes`);
+    }
+    if (publicKeyOffsetInMessage < 0 ||
+        publicKeyOffsetInMessage + ED25519_PUBLIC_KEY_LEN > message.length) {
+        throw new Error("Public key offset is out of bounds of signed message");
+    }
+    const signatureOffset = ED25519_HEADER_LEN;
+    const messageDataOffset = signatureOffset + signature.length;
+    const publicKeyOffsetInInstruction = messageDataOffset + publicKeyOffsetInMessage;
+    const instructionData = new Uint8Array(ED25519_HEADER_LEN + ED25519_SIGNATURE_LEN + message.length);
+    const view = new DataView(instructionData.buffer);
+    view.setUint8(0, 1); // num_signatures
+    view.setUint8(1, 0); // padding
+    view.setUint16(2, signatureOffset, true);
+    view.setUint16(4, ED25519_CURRENT_INSTRUCTION_INDEX, true);
+    view.setUint16(6, publicKeyOffsetInInstruction, true);
+    view.setUint16(8, ED25519_CURRENT_INSTRUCTION_INDEX, true);
+    view.setUint16(10, messageDataOffset, true);
+    view.setUint16(12, message.length, true);
+    view.setUint16(14, ED25519_CURRENT_INSTRUCTION_INDEX, true);
+    instructionData.set(signature, signatureOffset);
+    instructionData.set(message, messageDataOffset);
+    return new TransactionInstruction({
+        data: Buffer.from(instructionData),
+        keys: [],
+        programId: Ed25519Program.programId,
     });
 };
+const OFFCHAIN_SIGNING_DOMAIN_LEN = 16;
+const OFFCHAIN_V0_SIGNER_LIST_OFFSET = OFFCHAIN_SIGNING_DOMAIN_LEN + 1 + 32 + 1 + 1;
+const OFFCHAIN_V1_SIGNER_LIST_OFFSET = OFFCHAIN_SIGNING_DOMAIN_LEN + 1 + 1;
+const getOffchainMessagePublicKeyOffset = (signedMessage, publicKey) => {
+    const address = publicKey.toBase58();
+    try {
+        const message = getOffchainMessageDecoder().decode(signedMessage);
+        const index = message.requiredSignatories.findIndex((signer) => signer.address === address);
+        if (index !== -1) {
+            const baseOffset = message.version === 1
+                ? OFFCHAIN_V1_SIGNER_LIST_OFFSET
+                : OFFCHAIN_V0_SIGNER_LIST_OFFSET;
+            return baseOffset + index * ED25519_PUBLIC_KEY_LEN;
+        }
+        else {
+            return undefined;
+        }
+    }
+    catch {
+        return undefined;
+    }
+};
 const serializeExtra = (extra) => {
     for (const [key, value] of Object.entries(extra)) {
         if (!/^[a-z]+(_[a-z0-9]+)*$/.test(key)) {
@@ -454,7 +526,7 @@ const amountToString = (amount, decimals) => {
     ].join("");
 };
 export const getDomainRecordAddress = (domain) => {
-    const hash = sha256(domain);
+    const hash = sha256(new TextEncoder().encode(domain));
     return PublicKey.findProgramAddressSync([Buffer.from("domain-record"), hash], new PublicKey(DomainRegistryIdl.address))[0];
 };
 const BRIDGING_ADDRESS_LOOKUP_TABLE = {
@@ -471,30 +543,30 @@ const buildStartSessionInstruction = async (options, sessionKey, tokens) => {
     const instruction = new SessionManagerProgram(new AnchorProvider(options.context.connection, {}, {})).methods
         .startSession()
         .accounts({
-        sponsor: options.context.payer,
-        session: await getAddressFromPublicKey(sessionKey.publicKey),
         domainRegistry: getDomainRecordAddress(options.context.domain),
+        session: await getAddressFromPublicKey(sessionKey.publicKey),
+        sponsor: options.context.payer,
     });
     return tokens === undefined
         ? instruction.instruction()
         : instruction
             .remainingAccounts(tokens.flatMap(({ symbolOrMint, mint, metadataAddress }) => [
             {
-                pubkey: getAssociatedTokenAddressSync(mint, options.walletPublicKey),
-                isWritable: true,
                 isSigner: false,
+                isWritable: true,
+                pubkey: getAssociatedTokenAddressSync(mint, options.walletPublicKey),
             },
             {
-                pubkey: mint,
-                isWritable: false,
                 isSigner: false,
+                isWritable: false,
+                pubkey: mint,
             },
             ...(symbolOrMint.type === SymbolOrMintType.Symbol
                 ? [
                     {
-                        pubkey: metadataAddress,
-                        isWritable: false,
                         isSigner: false,
+                        isWritable: false,
+                        pubkey: metadataAddress,
                     },
                 ]
                 : []),
@@ -507,15 +579,15 @@ export var SessionResultType;
     SessionResultType[SessionResultType["Failed"] = 1] = "Failed";
 })(SessionResultType || (SessionResultType = {}));
 const EstablishSessionResult = {
-    Success: (signature, session) => ({
-        type: SessionResultType.Success,
-        signature,
-        session,
-    }),
     Failed: (signature, error) => ({
+        error,
+        signature,
         type: SessionResultType.Failed,
+    }),
+    Success: (signature, session) => ({
+        session,
         signature,
-        error,
+        type: SessionResultType.Success,
     }),
 };
 export const getTransferFee = async (context) => {
@@ -540,16 +612,16 @@ const getFee = async (context) => {
     const [feeConfigPda] = PublicKey.findProgramAddressSync([Buffer.from("fee_config"), usdcMint.toBytes()], program.programId);
     const feeConfig = await program.account.feeConfig.fetch(feeConfigPda);
     return {
+        decimals: USDC_DECIMALS,
+        fee: {
+            bridgeTransfer: BigInt(feeConfig.bridgeTransferFee.toString()),
+            intrachainTransfer: BigInt(feeConfig.intrachainTransferFee.toString()),
+        },
         metadata: findMetadataPda(umi, {
             mint: metaplexPublicKey(usdcMintAddress),
         })[0],
         mint: usdcMint,
         symbolOrMint: "USDC.s",
-        decimals: USDC_DECIMALS,
-        fee: {
-            intrachainTransfer: BigInt(feeConfig.intrachainTransferFee.toString()),
-            bridgeTransfer: BigInt(feeConfig.bridgeTransferFee.toString()),
-        },
     };
 };
 const TRANSFER_MESSAGE_HEADER = `Fogo Transfer:
@@ -572,17 +644,17 @@ export const sendTransfer = async (options) => {
             feeMetadata: options.feeConfig.metadata,
             feeMint: options.feeConfig.mint,
             feeSource: getAssociatedTokenAddressSync(options.feeConfig.mint, options.walletPublicKey),
-            mint: options.mint,
-            source: sourceAta,
-            sponsor: options.context.internalPayer,
             metadata: 
             // eslint-disable-next-line unicorn/no-null
             symbol === undefined ? null : new PublicKey(metadataAddress),
+            mint: options.mint,
+            source: sourceAta,
+            sponsor: options.context.internalPayer,
         })
             .instruction(),
     ], options.walletPublicKey, {
-        variation: "Intent Transfer",
         paymasterDomain: SESSIONS_INTERNAL_PAYMASTER_DOMAIN,
+        variation: "Intent Transfer",
     });
 };
 const buildTransferIntentInstruction = async (program, options, symbol, feeToken, feeAmount) => {
@@ -590,7 +662,9 @@ const buildTransferIntentInstruction = async (program, options, symbol, feeToken
         getNonce(program, options.walletPublicKey, NonceType.Transfer),
         getMint(options.context.connection, options.mint),
     ]);
-    return buildIntentInstruction(options, TRANSFER_MESSAGE_HEADER, {
+    return buildIntentInstruction(options, TRANSFER_MESSAGE_HEADER, 
+    // biome-ignore assist/source/useSortedKeys: The sort order is important here
+    {
         version: `${CURRENT_INTENT_TRANSFER_MAJOR}.${CURRENT_INTENT_TRANSFER_MINOR}`,
         chain_id: options.context.chainId,
         token: symbol ?? options.mint.toBase58(),
@@ -608,24 +682,26 @@ export const sendNativeTransfer = async (options) => {
         await program.methods
             .sendNative()
             .accounts({
+            destination: options.recipient,
+            feeDestination: IntentTransferIdl.address,
             feeMetadata: options.feeConfig.metadata,
             feeMint: options.feeConfig.mint,
             feeSource: getAssociatedTokenAddressSync(options.feeConfig.mint, options.walletPublicKey),
-            feeDestination: IntentTransferIdl.address,
             source: options.walletPublicKey,
-            destination: options.recipient,
             sponsor: options.context.internalPayer,
         })
             .instruction(),
     ], options.walletPublicKey, {
-        variation: "Intent Transfer",
         paymasterDomain: SESSIONS_INTERNAL_PAYMASTER_DOMAIN,
+        variation: "Intent Transfer",
     });
 };
 const FOGO_DECIMALS = 9;
 const buildNativeTransferIntentInstruction = async (program, options, feeToken, feeAmount) => {
     const nonce = await getNonce(program, options.walletPublicKey, NonceType.Transfer);
-    return buildIntentInstruction(options, TRANSFER_MESSAGE_HEADER, {
+    return buildIntentInstruction(options, TRANSFER_MESSAGE_HEADER, 
+    // biome-ignore assist/source/useSortedKeys: The sort order is important here
+    {
         version: `${CURRENT_INTENT_TRANSFER_MAJOR}.${CURRENT_INTENT_TRANSFER_MINOR}`,
         chain_id: options.context.chainId,
         token: "FOGO",
@@ -663,17 +739,17 @@ export const bridgeOut = async (options) => {
             signedQuoteBytes: [...quote.signedQuote],
         })
             .accounts({
-            sponsor: options.context.internalPayer,
-            mint: options.fromToken.mint,
+            feeMetadata: options.feeConfig.metadata,
+            feeMint: options.feeConfig.mint,
+            feeSource: getAssociatedTokenAddressSync(options.feeConfig.mint, options.walletPublicKey),
             metadata: metadata?.symbol === undefined
                 ? // eslint-disable-next-line unicorn/no-null
                     null
                 : new PublicKey(metadataAddress),
-            source: getAssociatedTokenAddressSync(options.fromToken.mint, options.walletPublicKey),
+            mint: options.fromToken.mint,
             ntt: nttPdas,
-            feeMetadata: options.feeConfig.metadata,
-            feeMint: options.feeConfig.mint,
-            feeSource: getAssociatedTokenAddressSync(options.feeConfig.mint, options.walletPublicKey),
+            source: getAssociatedTokenAddressSync(options.fromToken.mint, options.walletPublicKey),
+            sponsor: options.context.internalPayer,
         })
             .instruction(),
     ]);
@@ -681,10 +757,10 @@ export const bridgeOut = async (options) => {
         ComputeBudgetProgram.setComputeUnitLimit({ units: BRIDGE_OUT_CUS }),
         ...instructions,
     ], options.walletPublicKey, {
-        variation: "Intent NTT Bridge",
-        paymasterDomain: SESSIONS_INTERNAL_PAYMASTER_DOMAIN,
-        extraSigners: [outboxItem],
         addressLookupTable: BRIDGING_ADDRESS_LOOKUP_TABLE[options.context.network]?.[options.fromToken.mint.toBase58()],
+        extraSigners: [outboxItem],
+        paymasterDomain: SESSIONS_INTERNAL_PAYMASTER_DOMAIN,
+        variation: "Intent NTT Bridge",
     });
 };
 const getDestinationAtaExists = async (context, token, wallet) => {
@@ -726,16 +802,18 @@ const getNttPdas = async (options, wh, program, outboxItemPublicKey, quotePayeeA
         nttTokenAuthority: pdas.tokenAuthority(),
         payeeNttWithExecutor: quotePayeeAddress,
         transceiver: registeredTransceiverPda,
-        wormholeProgram: coreBridgeContract,
         wormholeBridge: wormholePdas.wormholeBridge,
         wormholeFeeCollector: wormholePdas.wormholeFeeCollector,
         wormholeMessage: transceiverPdas.wormholeMessageAccount(outboxItemPublicKey),
+        wormholeProgram: coreBridgeContract,
         wormholeSequence: wormholePdas.wormholeSequence,
     };
 };
 const buildBridgeOutIntent = async (program, options, decimals, symbol, feeToken, feeAmount) => {
     const nonce = await getNonce(program, options.walletPublicKey, NonceType.Bridge);
-    return buildIntentInstruction(options, BRIDGE_OUT_MESSAGE_HEADER, {
+    return buildIntentInstruction(options, BRIDGE_OUT_MESSAGE_HEADER, 
+    // biome-ignore assist/source/useSortedKeys: The sort order is important here
+    {
         version: `${CURRENT_BRIDGE_OUT_MAJOR}.${CURRENT_BRIDGE_OUT_MINOR}`,
         from_chain_id: options.context.chainId,
         to_chain_id: "solana",
@@ -813,9 +891,9 @@ const buildWormholeTransfer = async (options, connection) => {
     });
     const route = new Route(wh);
     const transferRequest = await routes.RouteTransferRequest.create(wh, {
+        destination: Wormhole.tokenId(options.toToken.chain, options.toToken.mint.toBase58()),
         recipient: Wormhole.chainAddress(options.toToken.chain, options.walletPublicKey.toBase58()),
         source: Wormhole.tokenId(options.fromToken.chain, options.fromToken.mint.toBase58()),
-        destination: Wormhole.tokenId(options.toToken.chain, options.toToken.mint.toBase58()),
     });
     const validated = await route.validate(transferRequest, {
         amount: amountToString(options.amount, decimals),
@@ -823,11 +901,11 @@ const buildWormholeTransfer = async (options, connection) => {
     });
     if (validated.valid) {
         return {
-            wh,
+            decimals,
             route,
-            transferRequest,
             transferParams: validated.params,
-            decimals,
+            transferRequest,
+            wh,
         };
     }
     else {

package/esm/instructions.js

@@ -1,6 +1,6 @@
 import { AnchorProvider } from "@coral-xyz/anchor";
 import { TollboothIdl, TollboothProgram } from "@fogo/sessions-idls";
-import { sha256 } from "@noble/hashes/sha2";
+import { sha256 } from "@noble/hashes/sha2.js";
 import { createAssociatedTokenAccountIdempotentInstruction, createCloseAccountInstruction, createSyncNativeInstruction, getAssociatedTokenAddressSync, NATIVE_MINT, } from "@solana/spl-token";
 import { PublicKey, SystemProgram, TransactionInstruction, } from "@solana/web3.js";
 const SESSION_WRAP_DISCRIMINATOR = 4_000_000;
@@ -17,17 +17,17 @@ export function createSystemProgramSessionWrapInstruction(sessionKey, walletPubl
     view.setUint32(0, SESSION_WRAP_DISCRIMINATOR, true);
     view.setBigUint64(4, amount, true);
     return new TransactionInstruction({
-        programId: SystemProgram.programId,
+        data: Buffer.from(data),
         keys: [
-            { pubkey: walletPublicKey, isSigner: false, isWritable: true },
+            { isSigner: false, isWritable: true, pubkey: walletPublicKey },
             {
-                pubkey: getNativeMintAssociatedTokenAddressSync(walletPublicKey),
                 isSigner: false,
                 isWritable: true,
+                pubkey: getNativeMintAssociatedTokenAddressSync(walletPublicKey),
             },
-            { pubkey: sessionKey, isSigner: true, isWritable: false },
+            { isSigner: true, isWritable: false, pubkey: sessionKey },
         ],
-        data: Buffer.from(data),
+        programId: SystemProgram.programId,
     });
 }
 /**
@@ -53,7 +53,7 @@ export function createSessionUnwrapInstruction(sessionKey, walletPublicKey) {
     return createCloseAccountInstruction(getNativeMintAssociatedTokenAddressSync(walletPublicKey), walletPublicKey, sessionKey);
 }
 const getDomainTollRecipientAddress = (domain) => {
-    const hash = sha256(domain);
+    const hash = sha256(new TextEncoder().encode(domain));
     return PublicKey.findProgramAddressSync([Buffer.from("toll_recipient"), Buffer.from([0]), hash], new PublicKey(TollboothIdl.address))[0];
 };
 /**
@@ -66,10 +66,10 @@ export const createPaymasterFeeInstruction = ({ sessionKey, walletPublicKey, dom
     return new TollboothProgram(new AnchorProvider({}, {})).methods
         .payToll(feeAmount, 0)
         .accounts({
-        session: sessionKey,
-        source: getAssociatedTokenAddressSync(feeMint, walletPublicKey),
         destination: getAssociatedTokenAddressSync(feeMint, recipient, true),
         mint: feeMint,
+        session: sessionKey,
+        source: getAssociatedTokenAddressSync(feeMint, walletPublicKey),
     })
         .instruction();
 };

package/package.json

@@ -1,54 +1,55 @@
 {
-  "name": "@fogo/sessions-sdk",
-  "version": "0.1.8",
-  "description": "A set of utilities for integrating with Fogo sessions",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/fogo-foundation/fogo-sessions",
-    "directory": "packages/sessions-sdk-ts"
+  "dependencies": {
+    "@coral-xyz/anchor": "^0.32.1",
+    "@metaplex-foundation/mpl-token-metadata": "^3.4.0",
+    "@metaplex-foundation/umi": "^1.5.1",
+    "@metaplex-foundation/umi-bundle-defaults": "^1.5.1",
+    "@noble/hashes": "^2.2.0",
+    "@solana/compat": "^6.8.0",
+    "@solana/kit": "^6.8.0",
+    "@solana/spl-token": "^0.4.14",
+    "@solana/web3.js": "^1.98.4",
+    "@wormhole-foundation/sdk": "^4.17.0",
+    "@wormhole-foundation/sdk-base": "^4.17.0",
+    "@wormhole-foundation/sdk-connect": "^4.17.0",
+    "@wormhole-foundation/sdk-route-ntt": "^4.0.17",
+    "@wormhole-foundation/sdk-solana-core": "^4.17.0",
+    "@wormhole-foundation/sdk-solana-ntt": "^4.0.17",
+    "bn.js": "^5.2.3",
+    "bs58": "^6.0.0",
+    "zod": "4.3.6",
+    "@fogo/sessions-idls": "^0.1.4"
   },
-  "keywords": [
-    "fogo",
-    "sessions",
-    "crypto",
-    "wallet"
-  ],
-  "type": "module",
-  "main": "./cjs/index.js",
-  "types": "./cjs/index.d.ts",
+  "description": "A set of utilities for integrating with Fogo sessions",
   "engines": {
     "node": ">=22"
   },
   "exports": {
     ".": {
       "import": {
-        "types": "./esm/index.d.ts",
-        "default": "./esm/index.js"
+        "default": "./esm/index.js",
+        "types": "./esm/index.d.ts"
       },
       "require": {
-        "types": "./cjs/index.d.ts",
-        "default": "./cjs/index.js"
+        "default": "./cjs/index.js",
+        "types": "./cjs/index.d.ts"
       }
     }
   },
-  "dependencies": {
-    "@coral-xyz/anchor": "^0.31.1",
-    "@metaplex-foundation/mpl-token-metadata": "^3.4.0",
-    "@metaplex-foundation/umi": "^1.2.0",
-    "@metaplex-foundation/umi-bundle-defaults": "^1.2.0",
-    "@noble/hashes": "^1.8.0",
-    "@solana/compat": "^4.0.0",
-    "@solana/kit": "^4.0.0",
-    "@solana/spl-token": "^0.4.13",
-    "@solana/web3.js": "^1.92.3",
-    "@wormhole-foundation/sdk": "^3.10.0",
-    "@wormhole-foundation/sdk-base": "^3.11.0",
-    "@wormhole-foundation/sdk-route-ntt": "^4.0.1",
-    "@wormhole-foundation/sdk-solana-core": "^3.10.0",
-    "@wormhole-foundation/sdk-solana-ntt": "^4.0.1",
-    "bn.js": "^5.1.2",
-    "bs58": "^6.0.0",
-    "zod": "3.25.67",
-    "@fogo/sessions-idls": "^0.1.2"
-  }
+  "keywords": [
+    "fogo",
+    "sessions",
+    "crypto",
+    "wallet"
+  ],
+  "main": "./cjs/index.js",
+  "name": "@fogo/sessions-sdk",
+  "repository": {
+    "directory": "packages/sessions-sdk-ts",
+    "type": "git",
+    "url": "https://github.com/fogo-foundation/fogo-sessions"
+  },
+  "type": "module",
+  "types": "./cjs/index.d.ts",
+  "version": "0.1.10"
 }