@campnetwork/origin 1.2.1 → 1.2.3

package/dist/react/index.esm.js

@@ -1,6 +1,6 @@
 'use client';
 import React, { createContext, useState, useContext, useEffect, useLayoutEffect, useRef, useSyncExternalStore } from 'react';
-import { custom, createWalletClient, createPublicClient, http, erc20Abi, getAbiItem, zeroAddress, formatEther, formatUnits, encodeFunctionData, checksumAddress, parseEther } from 'viem';
+import { custom, createWalletClient, createPublicClient, http, encodeFunctionData, checksumAddress, zeroAddress, keccak256, toBytes, erc20Abi, getAbiItem, formatEther, formatUnits, parseEther } from 'viem';
 import { toAccount } from 'viem/accounts';
 import { createSiweMessage } from 'viem/siwe';
 import axios from 'axios';
@@ -3457,28 +3457,270 @@ function subscriptionExpiry(tokenId, user) {
 }
 
 /**
- * Approves a spender to spend a specified amount of tokens on behalf of the owner.
- * If the current allowance is less than the specified amount, it will perform the approval.
- * @param {ApproveParams} params - The parameters for the approval.
+ * Adapter for viem WalletClient
  */
-function approveIfNeeded(_a) {
-    return __awaiter(this, arguments, void 0, function* ({ walletClient, publicClient, tokenAddress, owner, spender, amount, }) {
-        const allowance = yield publicClient.readContract({
-            address: tokenAddress,
-            abi: erc20Abi,
-            functionName: "allowance",
-            args: [owner, spender],
+class ViemSignerAdapter {
+    constructor(signer) {
+        this.type = "viem";
+        this.signer = signer;
+    }
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.signer.account) {
+                return this.signer.account.address;
+            }
+            const accounts = yield this.signer.request({
+                method: "eth_requestAccounts",
+                params: [],
+            });
+            if (!accounts || accounts.length === 0) {
+                throw new Error("No accounts found in viem wallet client");
+            }
+            return accounts[0];
         });
-        if (allowance < amount) {
-            yield walletClient.writeContract({
-                address: tokenAddress,
-                account: owner,
-                abi: erc20Abi,
-                functionName: "approve",
-                args: [spender, amount],
-                chain: testnet,
+    }
+    signMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const address = yield this.getAddress();
+            return yield this.signer.signMessage({
+                account: address,
+                message,
+            });
+        });
+    }
+    signTypedData(domain, types, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("Viem WalletClient does not support signTypedData");
+        });
+    }
+    getChainId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            return ((_a = this.signer.chain) === null || _a === void 0 ? void 0 : _a.id) || 1;
+        });
+    }
+}
+/**
+ * Adapter for ethers Signer (v5 and v6)
+ */
+class EthersSignerAdapter {
+    constructor(signer) {
+        this.type = "ethers";
+        this.signer = signer;
+    }
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Works for both ethers v5 and v6
+            if (typeof this.signer.getAddress === "function") {
+                return yield this.signer.getAddress();
+            }
+            if (this.signer.address) {
+                return this.signer.address;
+            }
+            throw new Error("Unable to get address from ethers signer");
+        });
+    }
+    signMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof this.signer.signMessage !== "function") {
+                throw new Error("Signer does not support signMessage");
+            }
+            return yield this.signer.signMessage(message);
+        });
+    }
+    signTypedData(domain, types, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof this.signer._signTypedData === "function") {
+                return yield this.signer._signTypedData(domain, types, value);
+            }
+            if (typeof this.signer.signTypedData !== "function") {
+                throw new Error("Signer does not support signTypedData or _signTypedData");
+            }
+            return yield this.signer.signTypedData(domain, types, value);
+        });
+    }
+    getChainId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Try ethers v6 first
+            if (this.signer.provider &&
+                typeof this.signer.provider.getNetwork === "function") {
+                const network = yield this.signer.provider.getNetwork();
+                // ethers v6 returns bigint, v5 returns number
+                return typeof network.chainId === "bigint"
+                    ? Number(network.chainId)
+                    : network.chainId;
+            }
+            // Fallback for ethers v5
+            if (typeof this.signer.getChainId === "function") {
+                return yield this.signer.getChainId();
+            }
+            // Default to mainnet if we can't determine
+            return 484;
+        });
+    }
+}
+/**
+ * Adapter for custom signer implementations
+ */
+class CustomSignerAdapter {
+    constructor(signer) {
+        this.type = "custom";
+        this.signer = signer;
+    }
+    getAddress() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof this.signer.getAddress === "function") {
+                return yield this.signer.getAddress();
+            }
+            if (this.signer.address) {
+                return this.signer.address;
+            }
+            throw new Error("Custom signer must implement getAddress() or have address property");
+        });
+    }
+    signMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof this.signer.signMessage !== "function") {
+                throw new Error("Custom signer must implement signMessage()");
+            }
+            return yield this.signer.signMessage(message);
+        });
+    }
+    signTypedData(domain, types, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof this.signer.signTypedData !== "function") {
+                throw new Error("Custom signer must implement signTypedData()");
+            }
+            return yield this.signer.signTypedData(domain, types, value);
+        });
+    }
+    getChainId() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (typeof this.signer.getChainId === "function") {
+                const chainId = yield this.signer.getChainId();
+                return typeof chainId === "bigint" ? Number(chainId) : chainId;
+            }
+            if (this.signer.chainId !== undefined) {
+                return typeof this.signer.chainId === "bigint"
+                    ? Number(this.signer.chainId)
+                    : this.signer.chainId;
+            }
+            // Default to mainnet
+            return 484;
+        });
+    }
+}
+/**
+ * Factory function to create appropriate adapter based on signer type
+ */
+function createSignerAdapter(signer) {
+    // Check for viem WalletClient
+    if (signer.transport &&
+        signer.chain &&
+        typeof signer.signMessage === "function") {
+        return new ViemSignerAdapter(signer);
+    }
+    // Check for ethers signer (v5 or v6)
+    if (signer._isSigner ||
+        (signer.provider && typeof signer.signMessage === "function")) {
+        return new EthersSignerAdapter(signer);
+    }
+    // Try custom adapter
+    return new CustomSignerAdapter(signer);
+}
+
+/**
+ * Settles an X402 payment response by purchasing access if needed.
+ * This method checks if the user already has access to the item, and if not,
+ * it calls buyAccess with the parameters from the X402 response.
+ * Supports viem WalletClient, ethers Signer, and custom signer implementations.
+ *
+ * @param x402Response - The response from getDataWithX402 containing payment details.
+ * @param signer - Optional signer object used to interact with the blockchain. If not provided, uses the connected wallet client.
+ * @returns A promise that resolves with the transaction hash and receipt, or null if access already exists.
+ * @throws {Error} If the response doesn't contain marketplace action or if the method is not buyAccess.
+ */
+function settleX402(x402Response, signer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!x402Response.marketplaceAction) {
+            throw new Error("No marketplace action found in X402 response");
+        }
+        const { marketplaceAction } = x402Response;
+        if (marketplaceAction.method !== "buyAccess") {
+            throw new Error(`Unsupported marketplace action method: ${marketplaceAction.method}`);
+        }
+        const tokenId = BigInt(marketplaceAction.tokenId);
+        const payerAddress = marketplaceAction.payer;
+        const alreadyHasAccess = yield this.hasAccess(payerAddress, tokenId);
+        if (alreadyHasAccess) {
+            console.log("User already has access to this item");
+            return null;
+        }
+        const expectedPrice = BigInt(marketplaceAction.amount);
+        const expectedDuration = BigInt(marketplaceAction.duration);
+        const expectedPaymentToken = marketplaceAction.asset;
+        const isNativeToken = expectedPaymentToken === "0x0000000000000000000000000000000000000000";
+        const value = isNativeToken ? expectedPrice : BigInt(0);
+        if (signer) {
+            const signerAdapter = createSignerAdapter(signer);
+            const marketplaceAddress = this.environment
+                .MARKETPLACE_CONTRACT_ADDRESS;
+            const abi = this.environment.MARKETPLACE_ABI;
+            const data = encodeFunctionData({
+                abi,
+                functionName: "buyAccess",
+                args: [
+                    payerAddress,
+                    tokenId,
+                    expectedPrice,
+                    expectedDuration,
+                    expectedPaymentToken,
+                ],
             });
+            if (signerAdapter.type === "viem") {
+                const viemSigner = signerAdapter.signer;
+                const txHash = yield viemSigner.sendTransaction({
+                    to: marketplaceAddress,
+                    data,
+                    value,
+                    account: (yield signerAdapter.getAddress()),
+                });
+                const receipt = yield viemSigner.waitForTransactionReceipt({
+                    hash: txHash,
+                });
+                return { txHash, receipt };
+            }
+            else if (signerAdapter.type === "ethers") {
+                const ethersSigner = signerAdapter.signer;
+                const tx = yield ethersSigner.sendTransaction({
+                    to: marketplaceAddress,
+                    data,
+                    value: value.toString(),
+                });
+                const receipt = yield tx.wait();
+                return { txHash: tx.hash, receipt };
+            }
+            else {
+                const customSigner = signerAdapter.signer;
+                if (typeof customSigner.sendTransaction !== "function") {
+                    throw new Error("Custom signer must implement sendTransaction() method");
+                }
+                const tx = yield customSigner.sendTransaction({
+                    to: marketplaceAddress,
+                    data,
+                    value: value.toString(),
+                });
+                if (tx.wait && typeof tx.wait === "function") {
+                    const receipt = yield tx.wait();
+                    return { txHash: tx.hash, receipt };
+                }
+                return { txHash: tx.hash || tx };
+            }
         }
+        if (!this.viemClient) {
+            throw new Error("No signer or wallet client provided for settleX402");
+        }
+        return yield this.buyAccess(payerAddress, tokenId, expectedPrice, expectedDuration, expectedPaymentToken, isNativeToken ? value : undefined);
     });
 }
 
@@ -3521,6 +3763,180 @@ const createLicenseTerms = (price, duration, royaltyBps, paymentToken) => {
         paymentToken,
     };
 };
+/**
+ * Defines the EIP-712 typed data structure for X402 Intent signatures.
+ */
+const X402_INTENT_TYPES = {
+    X402Intent: [
+        { name: "payer", type: "address" },
+        { name: "asset", type: "address" },
+        { name: "amount", type: "uint256" },
+        { name: "httpMethod", type: "string" },
+        { name: "payTo", type: "address" },
+        { name: "tokenId", type: "uint256" },
+        { name: "duration", type: "uint32" },
+        { name: "expiresAt", type: "uint256" },
+        { name: "nonce", type: "bytes32" },
+    ],
+};
+
+/**
+ * Fetch data with X402 payment handling.
+ * @param {bigint} tokenId The token ID to fetch data for.
+ * @param {any} [signer] Optional signer object for signing the X402 intent.
+ * @returns {Promise<any>} A promise that resolves with the fetched data.
+ * @throws {Error} Throws an error if the data cannot be fetched or if no signer/wallet client is provided.
+ */
+function getDataWithX402(tokenId, signer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const viemClient = this.viemClient;
+        if (!signer && !viemClient) {
+            throw new Error("No signer or wallet client provided for X402 intent.");
+        }
+        const initialResponse = yield fetch(`${this.environment.AUTH_HUB_BASE_API}/${this.environment.AUTH_ENDPOINT}/origin/data/${tokenId}`, {
+            method: "GET",
+        });
+        if (initialResponse.status !== 402) {
+            if (!initialResponse.ok) {
+                throw new Error("Failed to fetch data");
+            }
+            return initialResponse.json();
+        }
+        const sig = viemClient || createSignerAdapter(signer);
+        const walletAddress = viemClient
+            ? yield getCurrentAccount.call(this)
+            : yield sig.getAddress();
+        const intentData = yield initialResponse.json();
+        if (intentData.error) {
+            throw new Error(intentData.error);
+        }
+        const requirements = intentData.accepts[0];
+        const x402Payload = yield buildX402Payload.call(this, requirements, checksumAddress(walletAddress), sig);
+        const header = btoa(JSON.stringify(x402Payload));
+        const retryResponse = yield fetch(`${this.environment.AUTH_HUB_BASE_API}/${this.environment.AUTH_ENDPOINT}/origin/data/${tokenId}`, {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                "X-PAYMENT": header,
+            },
+        });
+        if (retryResponse.status === 402) {
+            // subscription required
+            return retryResponse.json();
+        }
+        if (!retryResponse.ok) {
+            throw new Error("Failed to fetch data after X402 payment");
+        }
+        const res = yield retryResponse.json();
+        return {
+            error: null,
+            data: (_a = res.data) !== null && _a !== void 0 ? _a : res,
+        };
+    });
+}
+/**
+ * Build the X402 payment payload.
+ * @private
+ */
+function buildX402Payload(requirements, payer, signer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const asset = requirements.asset === "native" ? zeroAddress : requirements.asset;
+        const amount = BigInt(requirements.maxAmountRequired || 0);
+        const duration = requirements.extra.duration;
+        const domain = makeX402IntentDomain.call(this);
+        const types = X402_INTENT_TYPES;
+        const nonce = crypto.randomUUID();
+        const nonceBytes32 = keccak256(toBytes(nonce));
+        const payment = {
+            payer: payer,
+            asset: asset,
+            amount: amount.toString(),
+            httpMethod: "GET",
+            payTo: checksumAddress(this.environment.MARKETPLACE_CONTRACT_ADDRESS),
+            tokenId: requirements.extra.tokenId,
+            duration: duration,
+            expiresAt: Math.floor(Date.now() / 1000) + requirements.maxTimeoutSeconds,
+            nonce: nonceBytes32,
+        };
+        const signerAdapter = createSignerAdapter(signer);
+        const signature = yield signerAdapter.signTypedData(domain, types, payment);
+        const x402Payload = {
+            x402Version: 1,
+            scheme: "exact",
+            network: requirements.network,
+            payload: Object.assign(Object.assign({}, payment), { sigType: "eip712", signature: signature, license: {
+                    tokenId: requirements.extra.tokenId,
+                    duration: duration,
+                } }),
+        };
+        return x402Payload;
+    });
+}
+/**
+ * Create the X402 Intent domain for EIP-712 signing.
+ * @private
+ */
+function makeX402IntentDomain() {
+    return {
+        name: "Origin X402 Intent",
+        version: "1",
+        chainId: this.environment.CHAIN.id,
+        verifyingContract: this.environment
+            .MARKETPLACE_CONTRACT_ADDRESS,
+    };
+}
+/**
+ * Get the current account address.
+ * @private
+ */
+function getCurrentAccount() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const viemClient = this.viemClient;
+        if (!viemClient) {
+            throw new Error("WalletClient not connected. Please connect a wallet.");
+        }
+        // If account is already set on the client, return it directly
+        if (viemClient.account) {
+            return viemClient.account.address;
+        }
+        // Otherwise request accounts (browser wallet flow)
+        const accounts = yield viemClient.request({
+            method: "eth_requestAccounts",
+            params: [],
+        });
+        if (!accounts || accounts.length === 0) {
+            throw new Error("No accounts found in connected wallet.");
+        }
+        return accounts[0];
+    });
+}
+
+/**
+ * Approves a spender to spend a specified amount of tokens on behalf of the owner.
+ * If the current allowance is less than the specified amount, it will perform the approval.
+ * @param {ApproveParams} params - The parameters for the approval.
+ */
+function approveIfNeeded(_a) {
+    return __awaiter(this, arguments, void 0, function* ({ walletClient, publicClient, tokenAddress, owner, spender, amount, }) {
+        const allowance = yield publicClient.readContract({
+            address: tokenAddress,
+            abi: erc20Abi,
+            functionName: "allowance",
+            args: [owner, spender],
+        });
+        if (allowance < amount) {
+            yield walletClient.writeContract({
+                address: tokenAddress,
+                account: owner,
+                abi: erc20Abi,
+                functionName: "approve",
+                args: [spender, amount],
+                chain: testnet,
+            });
+        }
+    });
+}
 
 var _Origin_instances, _Origin_generateURL, _Origin_setOriginStatus, _Origin_uploadFile, _Origin_waitForTxReceipt, _Origin_ensureChainId, _Origin_getCurrentAccount, _Origin_resolveWalletAddress;
 /**
@@ -3528,11 +3944,17 @@ var _Origin_instances, _Origin_generateURL, _Origin_setOriginStatus, _Origin_upl
  * Handles the upload of files to Origin, as well as querying the user's stats
  */
 class Origin {
-    constructor(jwt, environment, viemClient, baseParentId) {
+    constructor(environment, jwt, viemClient, baseParentId) {
         _Origin_instances.add(this);
-        this.jwt = jwt;
+        if (jwt) {
+            this.jwt = jwt;
+        }
+        else {
+            console.warn("JWT not provided. Some features may be unavailable.");
+        }
         this.viemClient = viemClient;
-        this.environment = environment;
+        this.environment =
+            typeof environment === "string" ? ENVIRONMENTS[environment] : environment;
         this.baseParentId = baseParentId;
         // DataNFT methods
         this.mintWithSignature = mintWithSignature.bind(this);
@@ -3554,6 +3976,8 @@ class Origin {
         this.buyAccess = buyAccess.bind(this);
         this.hasAccess = hasAccess.bind(this);
         this.subscriptionExpiry = subscriptionExpiry.bind(this);
+        this.settleX402 = settleX402.bind(this);
+        this.getDataWithX402 = getDataWithX402.bind(this);
     }
     getJwt() {
         return this.jwt;
@@ -3764,6 +4188,12 @@ class Origin {
             return this.buyAccess(account, tokenId, totalCost, duration, paymentToken);
         });
     }
+    /**
+     * Fetch the underlying data associated with a specific token ID.
+     * @param {bigint} tokenId - The token ID to fetch data for.
+     * @returns {Promise<any>} A promise that resolves with the fetched data.
+     * @throws {Error} Throws an error if the data cannot be fetched.
+     */
     getData(tokenId) {
         return __awaiter(this, void 0, void 0, function* () {
             const response = yield fetch(`${this.environment.AUTH_HUB_BASE_API}/${this.environment.AUTH_ENDPOINT}/origin/data/${tokenId}`, {
@@ -4138,155 +4568,6 @@ _Origin_instances = new WeakSet(), _Origin_generateURL = function _Origin_genera
     });
 };
 
-/**
- * Adapter for viem WalletClient
- */
-class ViemSignerAdapter {
-    constructor(signer) {
-        this.type = "viem";
-        this.signer = signer;
-    }
-    getAddress() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.signer.account) {
-                return this.signer.account.address;
-            }
-            const accounts = yield this.signer.request({
-                method: "eth_requestAccounts",
-                params: [],
-            });
-            if (!accounts || accounts.length === 0) {
-                throw new Error("No accounts found in viem wallet client");
-            }
-            return accounts[0];
-        });
-    }
-    signMessage(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const address = yield this.getAddress();
-            return yield this.signer.signMessage({
-                account: address,
-                message,
-            });
-        });
-    }
-    getChainId() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            return ((_a = this.signer.chain) === null || _a === void 0 ? void 0 : _a.id) || 1;
-        });
-    }
-}
-/**
- * Adapter for ethers Signer (v5 and v6)
- */
-class EthersSignerAdapter {
-    constructor(signer) {
-        this.type = "ethers";
-        this.signer = signer;
-    }
-    getAddress() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Works for both ethers v5 and v6
-            if (typeof this.signer.getAddress === "function") {
-                return yield this.signer.getAddress();
-            }
-            if (this.signer.address) {
-                return this.signer.address;
-            }
-            throw new Error("Unable to get address from ethers signer");
-        });
-    }
-    signMessage(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (typeof this.signer.signMessage !== "function") {
-                throw new Error("Signer does not support signMessage");
-            }
-            return yield this.signer.signMessage(message);
-        });
-    }
-    getChainId() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Try ethers v6 first
-            if (this.signer.provider &&
-                typeof this.signer.provider.getNetwork === "function") {
-                const network = yield this.signer.provider.getNetwork();
-                // ethers v6 returns bigint, v5 returns number
-                return typeof network.chainId === "bigint"
-                    ? Number(network.chainId)
-                    : network.chainId;
-            }
-            // Fallback for ethers v5
-            if (typeof this.signer.getChainId === "function") {
-                return yield this.signer.getChainId();
-            }
-            // Default to mainnet if we can't determine
-            return 484;
-        });
-    }
-}
-/**
- * Adapter for custom signer implementations
- */
-class CustomSignerAdapter {
-    constructor(signer) {
-        this.type = "custom";
-        this.signer = signer;
-    }
-    getAddress() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (typeof this.signer.getAddress === "function") {
-                return yield this.signer.getAddress();
-            }
-            if (this.signer.address) {
-                return this.signer.address;
-            }
-            throw new Error("Custom signer must implement getAddress() or have address property");
-        });
-    }
-    signMessage(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (typeof this.signer.signMessage !== "function") {
-                throw new Error("Custom signer must implement signMessage()");
-            }
-            return yield this.signer.signMessage(message);
-        });
-    }
-    getChainId() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (typeof this.signer.getChainId === "function") {
-                const chainId = yield this.signer.getChainId();
-                return typeof chainId === "bigint" ? Number(chainId) : chainId;
-            }
-            if (this.signer.chainId !== undefined) {
-                return typeof this.signer.chainId === "bigint"
-                    ? Number(this.signer.chainId)
-                    : this.signer.chainId;
-            }
-            // Default to mainnet
-            return 484;
-        });
-    }
-}
-/**
- * Factory function to create appropriate adapter based on signer type
- */
-function createSignerAdapter(signer) {
-    // Check for viem WalletClient
-    if (signer.transport &&
-        signer.chain &&
-        typeof signer.signMessage === "function") {
-        return new ViemSignerAdapter(signer);
-    }
-    // Check for ethers signer (v5 or v6)
-    if (signer._isSigner ||
-        (signer.provider && typeof signer.signMessage === "function")) {
-        return new EthersSignerAdapter(signer);
-    }
-    // Try custom adapter
-    return new CustomSignerAdapter(signer);
-}
-
 /**
  * Browser localStorage adapter
  */
@@ -4629,7 +4910,7 @@ class Auth {
                     this.isAuthenticated = true;
                     this.userId = res.userId;
                     this.jwt = res.token;
-                    this.origin = new Origin(this.jwt, this.environment, this.viem, this.baseParentId);
+                    this.origin = new Origin(this.environment, this.jwt, this.viem, this.baseParentId);
                     yield __classPrivateFieldGet(this, _Auth_storage, "f").setItem("camp-sdk:jwt", this.jwt);
                     yield __classPrivateFieldGet(this, _Auth_storage, "f").setItem("camp-sdk:wallet-address", this.walletAddress);
                     yield __classPrivateFieldGet(this, _Auth_storage, "f").setItem("camp-sdk:user-id", this.userId);
@@ -4691,7 +4972,7 @@ class Auth {
                     this.isAuthenticated = true;
                     this.userId = res.userId;
                     this.jwt = res.token;
-                    this.origin = new Origin(this.jwt, this.environment, this.viem, this.baseParentId);
+                    this.origin = new Origin(this.environment, this.jwt, this.viem, this.baseParentId);
                     yield __classPrivateFieldGet(this, _Auth_storage, "f").setItem("camp-sdk:jwt", this.jwt);
                     yield __classPrivateFieldGet(this, _Auth_storage, "f").setItem("camp-sdk:wallet-address", this.walletAddress);
                     yield __classPrivateFieldGet(this, _Auth_storage, "f").setItem("camp-sdk:user-id", this.userId);
@@ -5080,7 +5361,7 @@ _Auth_triggers = new WeakMap(), _Auth_isNodeEnvironment = new WeakMap(), _Auth_s
             this.walletAddress = walletAddress;
             this.userId = userId;
             this.jwt = jwt;
-            this.origin = new Origin(this.jwt, this.environment, this.viem, this.baseParentId);
+            this.origin = new Origin(this.environment, this.jwt, this.viem, this.baseParentId);
             this.isAuthenticated = true;
             if (provider) {
                 this.setProvider({