@dynamic-labs-sdk/starknet 0.0.0 → 0.5.0

package/README.md

@@ -0,0 +1,15 @@
+# @dynamic-labs-sdk/starknet
+
+This package contains the Starknet integration for the Dynamic SDK.
+
+## Usage
+
+```ts
+import { addStarknetExtension } from '@dynamic-labs-sdk/starknet';
+import { createDynamicClient } from '@dynamic-labs-sdk/client';
+
+const dynamicClient = createDynamicClient({
+  environmentId: '123',
+});
+addStarknetExtension(dynamicClient);
+```

package/dist/StarknetNetworkProvider.types.d.ts

@@ -0,0 +1,8 @@
+import type { BaseNetworkProvider } from '@dynamic-labs-sdk/client/core';
+export type StarknetNetworkProvider = BaseNetworkProvider<'STARK'>;
+declare global {
+    interface NetworkProviderMap {
+        STARK: StarknetNetworkProvider;
+    }
+}
+//# sourceMappingURL=StarknetNetworkProvider.types.d.ts.map

package/dist/StarknetNetworkProvider.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StarknetNetworkProvider.types.d.ts","sourceRoot":"","sources":["../src/StarknetNetworkProvider.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AAEzE,MAAM,MAAM,uBAAuB,GAAG,mBAAmB,CAAC,OAAO,CAAC,CAAC;AAEnE,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,kBAAkB;QAC1B,KAAK,EAAE,uBAAuB,CAAC;KAChC;CACF"}

package/dist/StarknetWalletAccount.types.d.ts

@@ -0,0 +1,8 @@
+import type { BaseWalletAccount } from '@dynamic-labs-sdk/client/core';
+export type StarknetWalletAccount = BaseWalletAccount<'STARK'>;
+declare global {
+    interface WalletAccountMap {
+        STARK: StarknetWalletAccount;
+    }
+}
+//# sourceMappingURL=StarknetWalletAccount.types.d.ts.map

package/dist/StarknetWalletAccount.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StarknetWalletAccount.types.d.ts","sourceRoot":"","sources":["../src/StarknetWalletAccount.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAEvE,MAAM,MAAM,qBAAqB,GAAG,iBAAiB,CAAC,OAAO,CAAC,CAAC;AAE/D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,gBAAgB;QACxB,KAAK,EAAE,qBAAqB,CAAC;KAC9B;CACF"}

package/dist/StarknetWalletProvider.types.d.ts

@@ -0,0 +1,12 @@
+import type { WalletProvider } from '@dynamic-labs-sdk/client/core';
+import type { WalletAccount } from 'starknet';
+import type { StarknetWalletAccount } from './StarknetWalletAccount.types';
+export type StarknetWalletProvider = WalletProvider & {
+    chain: 'STARK';
+    getStarknetAccount: (args: {
+        walletAccount: StarknetWalletAccount;
+    }) => Promise<{
+        account: WalletAccount;
+    }>;
+};
+//# sourceMappingURL=StarknetWalletProvider.types.d.ts.map

package/dist/StarknetWalletProvider.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StarknetWalletProvider.types.d.ts","sourceRoot":"","sources":["../src/StarknetWalletProvider.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE9C,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAE3E,MAAM,MAAM,sBAAsB,GAAG,cAAc,GAAG;IACpD,KAAK,EAAE,OAAO,CAAC;IACf,kBAAkB,EAAE,CAAC,IAAI,EAAE;QACzB,aAAa,EAAE,qBAAqB,CAAC;KACtC,KAAK,OAAO,CAAC;QAAE,OAAO,EAAE,aAAa,CAAA;KAAE,CAAC,CAAC;CAC3C,CAAC"}

package/dist/addStarknetExtension/addStarknetExtension.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Adds the Starknet extension to the Dynamic client.
+ *
+ * This is a convenience function that adds support for a variety of Starknet wallets,
+ * like Braavos, Ready and more.
+ *
+ * @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+ */
+export declare const addStarknetExtension: (client?: import("@dynamic-labs-sdk/client").DynamicClient) => void;
+//# sourceMappingURL=addStarknetExtension.d.ts.map

package/dist/addStarknetExtension/addStarknetExtension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addStarknetExtension.d.ts","sourceRoot":"","sources":["../../src/addStarknetExtension/addStarknetExtension.ts"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AAEH,eAAO,MAAM,oBAAoB,iEAAkC,IAElE,CAAC"}

package/dist/addStarknetExtension/index.d.ts

@@ -0,0 +1,2 @@
+export { addStarknetExtension } from './addStarknetExtension';
+//# sourceMappingURL=index.d.ts.map

package/dist/addStarknetExtension/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/addStarknetExtension/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/addStarknetInjectedWalletsExtension-Bn4EkQTD.cjs.js

@@ -0,0 +1,582 @@
+//#region rolldown:runtime
+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 __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+let _dynamic_labs_sdk_client_core = require("@dynamic-labs-sdk/client/core");
+let _starknet_io_get_starknet_core = require("@starknet-io/get-starknet-core");
+_starknet_io_get_starknet_core = __toESM(_starknet_io_get_starknet_core);
+let starknet = require("starknet");
+let _dynamic_labs_sdk_client = require("@dynamic-labs-sdk/client");
+let _dynamic_labs_sdk_api_core = require("@dynamic-labs/sdk-api-core");
+
+//#region package.json
+var name = "@dynamic-labs-sdk/starknet";
+var version = "0.5.0";
+
+//#endregion
+//#region src/utils/constants.ts
+const WEI_PER_ETH = 0xde0b6b3a7640000;
+const ETH_STARKNET_ADDRESS = "0x049d36570d4e46f48e99674bd3fcc84644ddd6b96f7c741b1562b82f9e004dc7";
+const ETH_CONTRACT_ABI = [
+	{
+		members: [{
+			name: "low",
+			offset: 0,
+			type: "felt"
+		}, {
+			name: "high",
+			offset: 1,
+			type: "felt"
+		}],
+		name: "Uint256",
+		size: 2,
+		type: "struct"
+	},
+	{
+		data: [
+			{
+				name: "from_",
+				type: "felt"
+			},
+			{
+				name: "to",
+				type: "felt"
+			},
+			{
+				name: "value",
+				type: "Uint256"
+			}
+		],
+		keys: [],
+		name: "Transfer",
+		type: "event"
+	},
+	{
+		data: [
+			{
+				name: "owner",
+				type: "felt"
+			},
+			{
+				name: "spender",
+				type: "felt"
+			},
+			{
+				name: "value",
+				type: "Uint256"
+			}
+		],
+		keys: [],
+		name: "Approval",
+		type: "event"
+	},
+	{
+		inputs: [],
+		name: "name",
+		outputs: [{
+			name: "name",
+			type: "felt"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "symbol",
+		outputs: [{
+			name: "symbol",
+			type: "felt"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "totalSupply",
+		outputs: [{
+			name: "totalSupply",
+			type: "Uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "decimals",
+		outputs: [{
+			name: "decimals",
+			type: "felt"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			name: "account",
+			type: "felt"
+		}],
+		name: "balanceOf",
+		outputs: [{
+			name: "balance",
+			type: "Uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			name: "owner",
+			type: "felt"
+		}, {
+			name: "spender",
+			type: "felt"
+		}],
+		name: "allowance",
+		outputs: [{
+			name: "remaining",
+			type: "Uint256"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "permittedMinter",
+		outputs: [{
+			name: "minter",
+			type: "felt"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "initialized",
+		outputs: [{
+			name: "res",
+			type: "felt"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "get_version",
+		outputs: [{
+			name: "version",
+			type: "felt"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [],
+		name: "get_identity",
+		outputs: [{
+			name: "identity",
+			type: "felt"
+		}],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [{
+			name: "init_vector_len",
+			type: "felt"
+		}, {
+			name: "init_vector",
+			type: "felt*"
+		}],
+		name: "initialize",
+		outputs: [],
+		type: "function"
+	},
+	{
+		inputs: [{
+			name: "recipient",
+			type: "felt"
+		}, {
+			name: "amount",
+			type: "Uint256"
+		}],
+		name: "transfer",
+		outputs: [{
+			name: "success",
+			type: "felt"
+		}],
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				name: "sender",
+				type: "felt"
+			},
+			{
+				name: "recipient",
+				type: "felt"
+			},
+			{
+				name: "amount",
+				type: "Uint256"
+			}
+		],
+		name: "transferFrom",
+		outputs: [{
+			name: "success",
+			type: "felt"
+		}],
+		type: "function"
+	},
+	{
+		inputs: [{
+			name: "spender",
+			type: "felt"
+		}, {
+			name: "amount",
+			type: "Uint256"
+		}],
+		name: "approve",
+		outputs: [{
+			name: "success",
+			type: "felt"
+		}],
+		type: "function"
+	},
+	{
+		inputs: [{
+			name: "spender",
+			type: "felt"
+		}, {
+			name: "added_value",
+			type: "Uint256"
+		}],
+		name: "increaseAllowance",
+		outputs: [{
+			name: "success",
+			type: "felt"
+		}],
+		type: "function"
+	},
+	{
+		inputs: [{
+			name: "spender",
+			type: "felt"
+		}, {
+			name: "subtracted_value",
+			type: "Uint256"
+		}],
+		name: "decreaseAllowance",
+		outputs: [{
+			name: "success",
+			type: "felt"
+		}],
+		type: "function"
+	},
+	{
+		inputs: [{
+			name: "recipient",
+			type: "felt"
+		}, {
+			name: "amount",
+			type: "Uint256"
+		}],
+		name: "permissionedMint",
+		outputs: [],
+		type: "function"
+	},
+	{
+		inputs: [{
+			name: "account",
+			type: "felt"
+		}, {
+			name: "amount",
+			type: "Uint256"
+		}],
+		name: "permissionedBurn",
+		outputs: [],
+		type: "function"
+	}
+];
+
+//#endregion
+//#region src/utils/fetchStarknetBalance/fetchStarknetBalance.ts
+const fetchStarknetBalance = async ({ address, networkData }) => {
+	const { balance } = await new starknet.Contract(ETH_CONTRACT_ABI, ETH_STARKNET_ADDRESS, new starknet.RpcProvider({ nodeUrl: networkData.rpcUrls.http[0] })).balanceOf(address);
+	return (Number(starknet.cairo.uint256(balance.low).low) / WEI_PER_ETH).toFixed(6);
+};
+
+//#endregion
+//#region src/utils/createStarknetNetworkProvider/createStarknetNetworkProvider.ts
+const createStarknetNetworkProvider = (networkData) => ({
+	...(0, _dynamic_labs_sdk_client_core.createBaseNetworkProvider)("STARK", networkData),
+	getBalance: async ({ address }) => ({ balance: await fetchStarknetBalance({
+		address,
+		networkData
+	}) })
+});
+
+//#endregion
+//#region src/registerStarknetNetworkProviderBuilder/registerStarknetNetworkProviderBuilder.ts
+const registerStarknetNetworkProviderBuilder = (client) => {
+	const networkProviderBuilderRegistry = (0, _dynamic_labs_sdk_client_core.getNetworkProviderBuilderRegistry)(client);
+	if (networkProviderBuilderRegistry.get().get("STARK")) return;
+	networkProviderBuilderRegistry.register({
+		builder: createStarknetNetworkProvider,
+		chain: "STARK"
+	});
+};
+
+//#endregion
+//#region src/utils/formatStarknetTypedDataMessage/formatStarknetTypedDataMessage.ts
+const defaultTypedData = {
+	primaryType: "Message",
+	types: {
+		Message: [{
+			name: "message",
+			type: "felt"
+		}],
+		StarkNetDomain: [
+			{
+				name: "name",
+				type: "felt"
+			},
+			{
+				name: "chainId",
+				type: "felt"
+			},
+			{
+				name: "version",
+				type: "felt"
+			}
+		]
+	}
+};
+const formatStarknetTypedDataMessage = ({ inputMessage, chainId }) => {
+	let nonce, domain;
+	try {
+		const { nonce: parsedNonce, domain: parsedDomain } = JSON.parse(inputMessage);
+		nonce = parsedNonce;
+		domain = parsedDomain;
+	} catch {
+		nonce = inputMessage;
+		domain = "domain";
+	}
+	const message = { message: nonce.substring(0, 31) };
+	return {
+		...defaultTypedData,
+		domain: {
+			chainId,
+			name: domain.substring(0, 31),
+			version: "0.0.1"
+		},
+		message
+	};
+};
+
+//#endregion
+//#region src/injected/utils/createWalletProviderFromStarknetWallet/createWalletProviderFromStarknetWallet.ts
+const createWalletProviderFromStarknetWallet = ({ dynamicClient, starknetWindowProvider }) => {
+	const walletProviderType = _dynamic_labs_sdk_api_core.WalletProviderEnum.BrowserExtension;
+	const key = (0, _dynamic_labs_sdk_client_core.formatWalletProviderKey)({
+		chain: "STARK",
+		displayName: starknetWindowProvider.name,
+		walletProviderType
+	});
+	const connect = async () => {
+		return { addresses: (await starknetWindowProvider.request({ type: "wallet_requestAccounts" })).map((address) => ({ address })) };
+	};
+	const disconnect = async () => {
+		try {
+			await starknetWindowProvider.request({ type: "wallet_disconnect" });
+		} catch {}
+		await _starknet_io_get_starknet_core.default.disconnect();
+	};
+	const getActiveNetworkId = async () => {
+		return { networkId: await starknetWindowProvider.request({ type: "wallet_requestChainId" }) };
+	};
+	const getConnectedAddresses = async () => {
+		return { addresses: await starknetWindowProvider.request({
+			params: { silent_mode: true },
+			type: "wallet_requestAccounts"
+		}) };
+	};
+	const getStarknetAccount = async ({ walletAccount }) => {
+		await (0, _dynamic_labs_sdk_client.assertWalletAccountSigningAvailability)({ walletAccount }, dynamicClient);
+		const { networkData } = await (0, _dynamic_labs_sdk_client.getActiveNetworkData)({ walletAccount }, dynamicClient);
+		(0, _dynamic_labs_sdk_client_core.assertDefined)(networkData, "No active network data found");
+		const rpcProvider = new starknet.RpcProvider({ nodeUrl: networkData.rpcUrls.http[0] });
+		return { account: await starknet.WalletAccount.connectSilent(rpcProvider, starknetWindowProvider) };
+	};
+	const signMessage = async ({ message, walletAccount }) => {
+		(0, _dynamic_labs_sdk_client_core.assertDefined)(walletAccount, "Wallet account not found");
+		await (0, _dynamic_labs_sdk_client.assertWalletAccountSigningAvailability)({ walletAccount }, dynamicClient);
+		const { networkId } = await getActiveNetworkId();
+		const encodedMessage = formatStarknetTypedDataMessage({
+			chainId: networkId,
+			inputMessage: message
+		});
+		return { signature: (await starknetWindowProvider.request({
+			params: encodedMessage,
+			type: "wallet_signTypedData"
+		})).join(",") };
+	};
+	const switchActiveNetwork = async ({ networkId }) => {
+		await starknetWindowProvider.request({
+			params: { chainId: networkId },
+			type: "wallet_switchStarknetChain"
+		});
+	};
+	const { getEventEmitter, cleanupEventEmitter } = (0, _dynamic_labs_sdk_client_core.createWalletProviderEventEmitter)({
+		removeEventListeners: ({ setupReturnValue }) => {
+			(0, _dynamic_labs_sdk_client_core.assertDefined)(setupReturnValue, "Setup return value not defined");
+			setupReturnValue.removeNetworkChangeListener();
+			setupReturnValue.removeAccountChangeListener();
+		},
+		setupEventListeners: ({ handleAccountsChanged, handleNetworkChanged }) => {
+			const onAccountsChanged = (accounts) => {
+				handleAccountsChanged({ addresses: accounts ?? [] });
+			};
+			starknetWindowProvider.on("accountsChanged", onAccountsChanged);
+			const removeAccountChangeListener = () => {
+				starknetWindowProvider.off("accountsChanged", onAccountsChanged);
+			};
+			const onNetworkChanged = (network) => {
+				if (!network) return;
+				handleNetworkChanged({ networkId: network.toString() });
+			};
+			starknetWindowProvider.on("networkChanged", onNetworkChanged);
+			const removeNetworkChangeListener = () => {
+				starknetWindowProvider.off("networkChanged", onNetworkChanged);
+			};
+			return {
+				removeAccountChangeListener,
+				removeNetworkChangeListener
+			};
+		},
+		supportedEvents: ["accountsChanged", "networkChanged"]
+	});
+	const terminate = async () => {
+		cleanupEventEmitter();
+	};
+	return {
+		chain: "STARK",
+		connect,
+		disconnect,
+		get events() {
+			return getEventEmitter();
+		},
+		getActiveNetworkId,
+		getConnectedAddresses,
+		getStarknetAccount,
+		groupKey: (0, _dynamic_labs_sdk_client_core.formatWalletProviderGroupKey)(starknetWindowProvider.name),
+		key,
+		metadata: {
+			displayName: starknetWindowProvider.name,
+			icon: typeof starknetWindowProvider.icon === "string" ? starknetWindowProvider.icon : starknetWindowProvider.icon.light
+		},
+		signMessage,
+		switchActiveNetwork,
+		terminate,
+		walletProviderType
+	};
+};
+
+//#endregion
+//#region src/injected/addStarknetInjectedWalletsExtension/addStarknetInjectedWalletsExtension.ts
+const STARKNET_INJECTED_WALLETS_EXTENSION_KEY = "starknetInjectedWallets";
+/**
+* Adds the Starknet Injected Wallets extension to the Dynamic client.
+*
+* This extension enables integration with many Starknet wallets, like Braavos, Ready and Xverse.
+*
+* @param [client] - The Dynamic client instance. Only required when using multiple Dynamic clients.
+*/
+const addStarknetInjectedWalletsExtension = (client = (0, _dynamic_labs_sdk_client_core.getDefaultClient)()) => {
+	if ((0, _dynamic_labs_sdk_client_core.hasExtension)({ extensionKey: STARKNET_INJECTED_WALLETS_EXTENSION_KEY }, client)) return;
+	(0, _dynamic_labs_sdk_client_core.registerExtension)({ extensionKey: STARKNET_INJECTED_WALLETS_EXTENSION_KEY }, client);
+	registerStarknetNetworkProviderBuilder(client);
+	const walletProviderRegistry = (0, _dynamic_labs_sdk_client_core.getWalletProviderRegistry)(client);
+	_starknet_io_get_starknet_core.default.getAvailableWallets().then((starknetWindowProviders) => {
+		starknetWindowProviders.forEach((starknetWindowProvider) => {
+			const walletProvider = createWalletProviderFromStarknetWallet({
+				dynamicClient: client,
+				starknetWindowProvider
+			});
+			walletProviderRegistry.register({
+				priority: _dynamic_labs_sdk_client_core.WalletProviderPriority.WINDOW_INJECT,
+				walletProvider
+			});
+		});
+	}).catch((error) => {
+		(0, _dynamic_labs_sdk_client_core.getCore)(client).logger.error("Error getting available starknet wallets", error);
+	});
+};
+
+//#endregion
+Object.defineProperty(exports, 'ETH_CONTRACT_ABI', {
+  enumerable: true,
+  get: function () {
+    return ETH_CONTRACT_ABI;
+  }
+});
+Object.defineProperty(exports, 'ETH_STARKNET_ADDRESS', {
+  enumerable: true,
+  get: function () {
+    return ETH_STARKNET_ADDRESS;
+  }
+});
+Object.defineProperty(exports, 'WEI_PER_ETH', {
+  enumerable: true,
+  get: function () {
+    return WEI_PER_ETH;
+  }
+});
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});
+Object.defineProperty(exports, 'addStarknetInjectedWalletsExtension', {
+  enumerable: true,
+  get: function () {
+    return addStarknetInjectedWalletsExtension;
+  }
+});
+Object.defineProperty(exports, 'name', {
+  enumerable: true,
+  get: function () {
+    return name;
+  }
+});
+Object.defineProperty(exports, 'version', {
+  enumerable: true,
+  get: function () {
+    return version;
+  }
+});
+//# sourceMappingURL=addStarknetInjectedWalletsExtension-Bn4EkQTD.cjs.js.map