@notifi-network/notifi-react-wallet-target-plugin
Version:
The Wallet Target Plugin context provider for @notifi-network/notifi-react
297 lines (287 loc) • 11 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// lib/index.ts
var index_exports = {};
__export(index_exports, {
NotifiContextProviderWithWalletTargetPlugin: () => NotifiContextProviderWithWalletTargetPlugin,
NotifiWalletTargetContextProvider: () => NotifiWalletTargetContextProvider,
useWalletTargetContext: () => useWalletTargetContext
});
module.exports = __toCommonJS(index_exports);
// lib/context/NotifiWalletTargetContext.tsx
var import_react2 = __toESM(require("react"));
// lib/hooks/useXmtp.ts
var import_notifi_frontend_client = require("@notifi-network/notifi-frontend-client");
var import_react_sdk = require("@xmtp/react-sdk");
var import_react = __toESM(require("react"));
// lib/utils/xmtp.ts
var coinbaseEndpoint = "https://broadcast.coinbase.com/api/rpc";
var createCoinbaseNonce = async () => {
const { result } = await fetch(`${coinbaseEndpoint}/createNonce`, {
method: "POST"
}).then((v) => v.json());
return result?.nonce;
};
var subscribeCoinbaseMessaging = async (payload) => {
const response = await fetch(`${coinbaseEndpoint}/messaging/subscribe`, {
method: "POST",
body: JSON.stringify(payload),
headers: {
"Content-Type": "text/plain"
}
});
return await response.json();
};
// lib/utils/signature.ts
var getMessage = (address, senderAddress, nonce) => `Coinbase Wallet Messaging subscribe
Address: ${address}
Partner Address: ${senderAddress}
Nonce: ${nonce}`;
var reformatSignature = (signature) => {
if (!signature) return "";
let hexString = "0x";
Object.values(signature).forEach(
(v) => hexString += v.toString(16).padStart(2, "0")
);
return hexString;
};
// lib/hooks/useXmtp.ts
var useXmpt = (input) => {
const { walletWithSignParams } = input;
const [isLoading, setIsLoading] = import_react.default.useState(false);
const [error, setError] = import_react.default.useState(null);
const authMethod = walletWithSignParams.walletBlockchain === "OFF_CHAIN" ? walletWithSignParams.signIn : walletWithSignParams.signMessage;
const xmtp = (0, import_react_sdk.useClient)();
const getSignature = import_react.default.useCallback(
async (message) => {
if (walletWithSignParams.walletBlockchain === "OFF_CHAIN") {
setError(Error(".getSignature: ERROR - OFF_CHAIN is not supported"));
return ".getSignature: ERROR - OFF_CHAIN is not supported";
}
let signature = "";
if (typeof message === "string") {
const encoder = new TextEncoder();
message = encoder.encode(message);
}
if ((0, import_notifi_frontend_client.isUsingEvmBlockchain)(walletWithSignParams)) {
signature = await walletWithSignParams.signMessage(message);
} else {
setError(Error(".getSignature: ERROR - This chain is not supported"));
console.error(".getSignature: ERROR - This chain is not supported");
}
return reformatSignature(signature);
},
[authMethod]
);
const xmtpXip42Impl = import_react.default.useCallback(
async (senderAddress) => {
if (walletWithSignParams.walletBlockchain === "OFF_CHAIN") {
setError(Error(".getSignature: ERROR - OFF_CHAIN is not supported"));
return ".getSignature: ERROR - OFF_CHAIN is not supported";
}
const options = {
persistConversations: false,
env: "production"
};
const address = walletWithSignParams.walletPublicKey;
const signer = {
getAddress: () => {
return new Promise((resolve) => {
resolve(address);
});
},
signMessage: async (message) => {
return getSignature(message);
}
};
const client = await xmtp.initialize({ options, signer });
if (!client) {
throw Error(
"xmtpXip42Impl: ERROR - XMTP client is uninitialized. Please try again."
);
}
const conversation = await client.conversations.newConversation(senderAddress);
await client.contacts.allow([senderAddress]);
return conversation.topic.split("/")[3];
},
[xmtp, getSignature]
);
const signCoinbaseSignature = import_react.default.useCallback(
async (frontendClient, web3TargetId, senderAddress) => {
if (walletWithSignParams.walletBlockchain === "OFF_CHAIN") {
setError(Error(".getSignature: ERROR - OFF_CHAIN is not supported"));
return;
}
setIsLoading(true);
try {
const conversationTopic = await xmtpXip42Impl(senderAddress);
if (!conversationTopic)
throw Error("Unable to get the conversation topic");
const address = walletWithSignParams.walletPublicKey;
const nonce = await createCoinbaseNonce();
const message = getMessage(address, senderAddress, nonce);
const signature = await getSignature(message);
if (!signature)
throw Error("Unable to sign the wallet. Please try again.");
const payload = {
address,
nonce,
signature,
isActivatedViaCb: true,
partnerAddress: senderAddress,
conversationTopic
};
await subscribeCoinbaseMessaging(payload);
const walletVerifyResult = await frontendClient.verifyXmtpTargetViaXip42({
input: {
web3TargetId,
accountId: address,
conversationTopic
}
});
return walletVerifyResult.verifyXmtpTargetViaXip42.web3Target;
} catch (e) {
console.error(".signCoinbaseSignature: ERROR - ", e);
setError(
e instanceof Error ? {
...e,
message: ".signCoinbaseSignature: ERROR - " + e.message
} : Error(".signCoinbaseSignature: ERROR - please try again.")
);
return;
} finally {
setIsLoading(false);
}
},
[xmtpXip42Impl]
);
return {
isLoading,
error,
signCoinbaseSignature
};
};
// lib/context/NotifiWalletTargetContext.tsx
var import_jsx_runtime = require("react/jsx-runtime");
var NotifiWalletTargetContext = import_react2.default.createContext({
isLoading: false,
error: null,
signCoinbaseSignature: async () => {
console.error(
"NotifiWalletTargetProvider: ERROR - signCoinbaseSignature not implemented"
);
return void 0;
}
});
var NotifiWalletTargetContextProvider = ({ children, walletWithSignParams }) => {
const contextValue = useXmpt({
walletWithSignParams
});
return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(NotifiWalletTargetContext.Provider, { value: contextValue, children });
};
var useWalletTargetContext = () => import_react2.default.useContext(NotifiWalletTargetContext);
// lib/context/NotifiContextProviderWithWalletTargetPlugin.tsx
var import_notifi_react = require("@notifi-network/notifi-react");
// ../notifi-react/lib/context/GlobalStateContext.tsx
var import_react3 = require("react");
var import_jsx_runtime2 = require("react/jsx-runtime");
var GlobalStateContext = (0, import_react3.createContext)({
globalLoading: { isLoading: false },
setGlobalLoading: () => void 0,
globalError: null,
setGlobalError: () => void 0,
globalCtas: null,
setGlobalCtas: () => void 0
});
var GlobalStateContextProvider = ({
children
}) => {
const [globalLoading, setGlobalLoading] = (0, import_react3.useState)({
isLoading: false
});
const [globalError, setGlobalError] = (0, import_react3.useState)(null);
const [globalCtas, setGlobalCtas] = (0, import_react3.useState)(null);
return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
GlobalStateContext.Provider,
{
value: {
globalLoading,
setGlobalLoading,
globalError,
setGlobalError,
globalCtas,
setGlobalCtas
},
children
}
);
};
// lib/context/NotifiContextProviderWithWalletTargetPlugin.tsx
var import_jsx_runtime3 = require("react/jsx-runtime");
var NotifiContextProviderWithWalletTargetPlugin = ({ children, ...params }) => {
const {
tenantId,
env,
storageOption,
isEnabledLoginViaTransaction,
...walletWithSignParams
} = params;
const contextValue = useXmpt({
walletWithSignParams
});
return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_notifi_react.NotifiFrontendClientContextProvider, { ...params, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
import_notifi_react.NotifiTenantConfigContextProvider,
{
cardId: params.cardId,
inputs: params.inputs,
children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
import_notifi_react.NotifiTargetContextProvider,
{
toggleTargetAvailability: params.toggleTargetAvailability,
plugin: { walletTarget: contextValue },
children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_notifi_react.NotifiTopicContextProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
import_notifi_react.NotifiHistoryContextProvider,
{
notificationCountPerPage: params.notificationCountPerPage,
unreadCountScope: params.unreadCountScope,
children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_notifi_react.NotifiUserSettingContextProvider, { children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(GlobalStateContextProvider, { children }) })
}
) })
}
)
}
) });
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
NotifiContextProviderWithWalletTargetPlugin,
NotifiWalletTargetContextProvider,
useWalletTargetContext
});
//# sourceMappingURL=index.js.map