@flapsdk/vault-runtime 0.1.36-next.0 → 0.1.37
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +45 -0
- package/{chunk-FWYBGHBX.js → chunk-22KTLOYH.js} +4 -17
- package/chunk-22KTLOYH.js.map +1 -0
- package/{chunk-SAG36LUR.js → chunk-27VBKY3J.js} +4 -3
- package/chunk-27VBKY3J.js.map +1 -0
- package/{chunk-MLAOJT5Q.js → chunk-3X2K7YYU.js} +524 -367
- package/chunk-3X2K7YYU.js.map +1 -0
- package/chunk-AGLB72HK.js +61 -0
- package/chunk-AGLB72HK.js.map +1 -0
- package/{chunk-V7U4QTMT.js → chunk-HYBZWS6U.js} +279 -104
- package/chunk-HYBZWS6U.js.map +1 -0
- package/{chunk-PU7VEZWA.js → chunk-SRZFHGSO.js} +3 -3
- package/{chunk-PU7VEZWA.js.map → chunk-SRZFHGSO.js.map} +1 -1
- package/host-client.d.mts +2 -9
- package/host-client.js +5 -5
- package/host.d.mts +5 -5
- package/host.js +4 -4
- package/{hostRuntimeConfig-DibvcxHE.d.mts → hostRuntimeConfig-DM6JjbeO.d.mts} +1 -1
- package/{mpegts-J2J6JTD7.js → mpegts-536UQHCG.js} +6 -6
- package/{mpegts-J2J6JTD7.js.map → mpegts-536UQHCG.js.map} +1 -1
- package/package.json +3 -4
- package/runtime-contract.json +3 -3
- package/sdk.d.mts +6 -40
- package/sdk.js +9 -39
- package/sdk.js.map +1 -1
- package/server.d.mts +3 -3
- package/server.js +2 -2
- package/{txError-OBuRV8xN.d.mts → txError-vvvBIsa-.d.mts} +2 -15
- package/{types-DUZWZ3mC.d.mts → types-cyAEoeXa.d.mts} +6 -98
- package/ui.d.mts +13 -5
- package/ui.js +2 -2
- package/chunk-A3ER7XYN.js +0 -408
- package/chunk-A3ER7XYN.js.map +0 -1
- package/chunk-FWYBGHBX.js.map +0 -1
- package/chunk-MLAOJT5Q.js.map +0 -1
- package/chunk-SAG36LUR.js.map +0 -1
- package/chunk-V7U4QTMT.js.map +0 -1
|
@@ -1,78 +1,259 @@
|
|
|
1
|
-
import { createVaultRuntimeContext, chainLabelForChain
|
|
2
|
-
import {
|
|
1
|
+
import { createVaultRuntimeContext, chainLabelForChain } from './chunk-AGLB72HK.js';
|
|
2
|
+
import { createLocalNftMetadataReader, createLocalMediaUploader, vaultV2NftAbi, nftTokenUriAbi } from './chunk-SRZFHGSO.js';
|
|
3
3
|
import { fetchOracleJson } from './chunk-JLI25XFB.js';
|
|
4
|
-
import { RuntimeContext, Alert } from './chunk-
|
|
4
|
+
import { RuntimeContext, Alert } from './chunk-3X2K7YYU.js';
|
|
5
5
|
import { isValidAddress, ZERO_ADDRESS } from './chunk-B4WKI3EW.js';
|
|
6
|
-
import {
|
|
7
|
-
import {
|
|
8
|
-
import {
|
|
9
|
-
import { toFunctionSelector, parseAbi, encodeFunctionData,
|
|
6
|
+
import { resolveIpfsImageUrls } from './chunk-27VBKY3J.js';
|
|
7
|
+
import { useState, useRef, useCallback, useEffect, useMemo } from 'react';
|
|
8
|
+
import { useAccount, useChainId, useConnect, useDisconnect, useSwitchChain, usePublicClient, useWalletClient, useBalance } from 'wagmi';
|
|
9
|
+
import { toFunctionSelector, parseAbi, encodeFunctionData, formatUnits, decodeFunctionResult, decodeAbiParameters, decodeEventLog, getContractAddress, concatHex, encodeAbiParameters, keccak256 } from 'viem';
|
|
10
|
+
import { jsxs, jsx } from 'react/jsx-runtime';
|
|
10
11
|
|
|
11
|
-
|
|
12
|
-
|
|
13
|
-
|
|
14
|
-
|
|
15
|
-
|
|
16
|
-
|
|
17
|
-
|
|
18
|
-
|
|
19
|
-
|
|
20
|
-
|
|
21
|
-
|
|
22
|
-
|
|
23
|
-
|
|
24
|
-
|
|
25
|
-
|
|
26
|
-
|
|
27
|
-
|
|
28
|
-
|
|
29
|
-
|
|
30
|
-
|
|
31
|
-
|
|
32
|
-
|
|
33
|
-
|
|
34
|
-
|
|
35
|
-
|
|
36
|
-
|
|
37
|
-
|
|
38
|
-
|
|
39
|
-
|
|
40
|
-
|
|
41
|
-
|
|
42
|
-
|
|
43
|
-
|
|
44
|
-
|
|
45
|
-
|
|
46
|
-
|
|
47
|
-
|
|
48
|
-
|
|
49
|
-
|
|
50
|
-
|
|
12
|
+
// src/sdk/fsiPolicy.mjs
|
|
13
|
+
var FSI_QUERY_PREFIX = "https://bsc-debug.butterfly.army/fsi/v1";
|
|
14
|
+
var FSI_ORIGIN = "https://bsc-debug.butterfly.army";
|
|
15
|
+
var FSI_PATH = "/fsi/v1";
|
|
16
|
+
var encodedPathSyntax = /%(?:2e|2f|5c|25)/i;
|
|
17
|
+
var hasDotSegment = (path) => path.split("/").some((part) => part === "." || part === "..");
|
|
18
|
+
function isFsiQueryUrl(value) {
|
|
19
|
+
try {
|
|
20
|
+
if (typeof value !== "string" || /[\\#\u0000-\u0020\u007f]/.test(value)) return false;
|
|
21
|
+
const rawPath = value.match(/^[a-z][a-z\d+.-]*:\/\/[^/?#]*([^?#]*)/i)?.[1];
|
|
22
|
+
if (rawPath === void 0 || encodedPathSyntax.test(rawPath) || hasDotSegment(rawPath)) return false;
|
|
23
|
+
const url = new URL(value);
|
|
24
|
+
return url.origin === FSI_ORIGIN && !url.username && !url.password && !url.hash && (url.pathname === FSI_PATH || url.pathname.startsWith(`${FSI_PATH}/`)) && !encodedPathSyntax.test(url.pathname);
|
|
25
|
+
} catch {
|
|
26
|
+
return false;
|
|
27
|
+
}
|
|
28
|
+
}
|
|
29
|
+
function hasFsiQueryDeclaration(endpoints) {
|
|
30
|
+
const urls = typeof endpoints === "string" ? [endpoints] : endpoints;
|
|
31
|
+
return Array.isArray(urls) && urls.some((value) => {
|
|
32
|
+
if (!isFsiQueryUrl(value)) return false;
|
|
33
|
+
const url = new URL(value);
|
|
34
|
+
return !url.search && (url.pathname === FSI_PATH || url.pathname === `${FSI_PATH}/`);
|
|
35
|
+
});
|
|
36
|
+
}
|
|
37
|
+
function buildFsiQueryUrl(path, params = {}) {
|
|
38
|
+
if (typeof path !== "string" || path.startsWith("/") || /[\\?#\s\u0000-\u001f\u007f]/.test(path)) {
|
|
39
|
+
throw new Error("FSI path must be relative to /fsi/v1 without query or fragment; pass query parameters separately.");
|
|
40
|
+
}
|
|
41
|
+
if (encodedPathSyntax.test(path) || hasDotSegment(path)) {
|
|
42
|
+
throw new Error("FSI path traversal and encoded path separators/dots are not allowed.");
|
|
43
|
+
}
|
|
44
|
+
const url = new URL(`${FSI_QUERY_PREFIX}/${path}`);
|
|
45
|
+
if (!isFsiQueryUrl(url.href)) throw new Error("FSI URL is outside the platform query allowlist.");
|
|
46
|
+
for (const [key, value] of Object.entries(params)) {
|
|
47
|
+
if (typeof value !== "string") throw new Error("FSI query parameter values must be strings.");
|
|
48
|
+
url.searchParams.set(key, value);
|
|
49
|
+
}
|
|
50
|
+
return url.href;
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
// src/sdk/fsi.ts
|
|
54
|
+
async function readFsiJson(endpoints, path, params, fetchImpl = fetch) {
|
|
55
|
+
if (!hasFsiQueryDeclaration(endpoints)) {
|
|
56
|
+
throw new Error("FSI requires https://bsc-debug.butterfly.army/fsi/v1 in manifest.endpoints for review.");
|
|
57
|
+
}
|
|
58
|
+
const url = buildFsiQueryUrl(path, params);
|
|
59
|
+
const response = await fetchImpl(url, {
|
|
60
|
+
method: "GET",
|
|
61
|
+
credentials: "omit",
|
|
62
|
+
redirect: "error",
|
|
63
|
+
referrerPolicy: "no-referrer",
|
|
64
|
+
cache: "no-store"
|
|
65
|
+
});
|
|
66
|
+
if (!response.ok) throw new Error(`FSI request returned ${response.status}.`);
|
|
67
|
+
return await response.json();
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
// src/sdk/ipfsText.ts
|
|
71
|
+
var MAX_TEXT_BYTES = 256 * 1024;
|
|
72
|
+
var MAX_CONCURRENT_READS = 6;
|
|
73
|
+
var MAX_PENDING_READS = 128;
|
|
74
|
+
var MAX_CACHED_READS = 64;
|
|
75
|
+
var TEXT_MEDIA_TYPES = /* @__PURE__ */ new Set(["text/plain", "application/json", "application/octet-stream"]);
|
|
76
|
+
async function readTextBody(response, signal) {
|
|
77
|
+
const contentType = response.headers.get("content-type") ?? "";
|
|
78
|
+
if (!TEXT_MEDIA_TYPES.has(contentType.split(";")[0].trim().toLowerCase())) {
|
|
79
|
+
throw new Error("IPFS text must use text/plain, application/json or application/octet-stream.");
|
|
80
|
+
}
|
|
81
|
+
const charset = /charset\s*=\s*["']?([^;"'\s]+)/i.exec(contentType)?.[1];
|
|
82
|
+
if (charset && !/^utf-?8$/i.test(charset)) throw new Error("IPFS text must use UTF-8.");
|
|
83
|
+
if (Number(response.headers.get("content-length")) > MAX_TEXT_BYTES) {
|
|
84
|
+
await response.body?.cancel();
|
|
85
|
+
throw new Error("IPFS text exceeds 256 KiB.");
|
|
86
|
+
}
|
|
87
|
+
const reader = response.body?.getReader();
|
|
88
|
+
if (!reader) return "";
|
|
89
|
+
const abort = () => {
|
|
90
|
+
void reader.cancel().catch(() => {
|
|
91
|
+
});
|
|
92
|
+
};
|
|
93
|
+
signal.addEventListener("abort", abort, { once: true });
|
|
94
|
+
const decoder = new TextDecoder("utf-8", { fatal: true });
|
|
95
|
+
let bytes = 0;
|
|
96
|
+
let text = "";
|
|
97
|
+
try {
|
|
98
|
+
while (true) {
|
|
99
|
+
const chunk = await reader.read();
|
|
100
|
+
if (signal.aborted) throw new Error("IPFS text request timed out.");
|
|
101
|
+
if (chunk.done) break;
|
|
102
|
+
bytes += chunk.value.byteLength;
|
|
103
|
+
if (bytes > MAX_TEXT_BYTES) throw new Error("IPFS text exceeds 256 KiB.");
|
|
104
|
+
text += decoder.decode(chunk.value, { stream: true });
|
|
105
|
+
}
|
|
106
|
+
text += decoder.decode();
|
|
107
|
+
if (/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/.test(text)) throw new Error("IPFS content is not plain UTF-8 text.");
|
|
108
|
+
return text;
|
|
109
|
+
} catch (error) {
|
|
110
|
+
void reader.cancel().catch(() => {
|
|
111
|
+
});
|
|
112
|
+
throw error;
|
|
113
|
+
} finally {
|
|
114
|
+
signal.removeEventListener("abort", abort);
|
|
115
|
+
reader.releaseLock();
|
|
116
|
+
}
|
|
117
|
+
}
|
|
118
|
+
function createIpfsTextReader({ fetchImpl = fetch, timeoutMs = 8e3 } = {}) {
|
|
119
|
+
const cache = /* @__PURE__ */ new Map();
|
|
120
|
+
const pending = /* @__PURE__ */ new Map();
|
|
121
|
+
const waiting = [];
|
|
122
|
+
let active = 0;
|
|
123
|
+
async function load(urls) {
|
|
124
|
+
if (active >= MAX_CONCURRENT_READS) await new Promise((resolve) => waiting.push(resolve));
|
|
125
|
+
active++;
|
|
126
|
+
const controller = new AbortController();
|
|
127
|
+
const timer = setTimeout(() => controller.abort(), timeoutMs);
|
|
128
|
+
try {
|
|
129
|
+
let lastError;
|
|
130
|
+
for (const url of urls) {
|
|
131
|
+
let response;
|
|
132
|
+
try {
|
|
133
|
+
response = await fetchImpl(url, {
|
|
134
|
+
method: "GET",
|
|
135
|
+
credentials: "omit",
|
|
136
|
+
redirect: "error",
|
|
137
|
+
referrerPolicy: "no-referrer",
|
|
138
|
+
cache: "force-cache",
|
|
139
|
+
signal: controller.signal
|
|
140
|
+
});
|
|
141
|
+
} catch (error) {
|
|
142
|
+
if (controller.signal.aborted) throw new Error("IPFS text request timed out.");
|
|
143
|
+
lastError = error;
|
|
144
|
+
continue;
|
|
51
145
|
}
|
|
52
|
-
|
|
53
|
-
|
|
54
|
-
|
|
55
|
-
|
|
56
|
-
|
|
57
|
-
|
|
58
|
-
const receipt = await publicClient(chainId).waitForTransactionReceipt({ hash: hash2 });
|
|
59
|
-
return { hash: receipt.transactionHash, status: receipt.status, blockNumber: receipt.blockNumber, logs: receipt.logs };
|
|
60
|
-
},
|
|
61
|
-
getCode: (chainId, address2) => publicClient(chainId).getCode({ address: address2 }),
|
|
62
|
-
getGasPrice: (chainId) => publicClient(chainId).getGasPrice(),
|
|
63
|
-
getBlockNumber: (chainId) => publicClient(chainId).getBlockNumber(),
|
|
64
|
-
getBalance: (chainId, address2) => publicClient(chainId).getBalance({ address: address2 }),
|
|
65
|
-
getContractEvents: async (chainId, request) => publicClient(chainId).getContractEvents(request),
|
|
66
|
-
upload: mediaUploader,
|
|
67
|
-
openUrl: (url) => {
|
|
68
|
-
window.open(url, "_blank", "noopener,noreferrer");
|
|
146
|
+
if (!response.ok) {
|
|
147
|
+
await response.body?.cancel();
|
|
148
|
+
lastError = new Error(`IPFS text request returned ${response.status}.`);
|
|
149
|
+
continue;
|
|
150
|
+
}
|
|
151
|
+
return await readTextBody(response, controller.signal);
|
|
69
152
|
}
|
|
70
|
-
|
|
71
|
-
|
|
153
|
+
throw lastError ?? new Error("IPFS text could not be loaded.");
|
|
154
|
+
} finally {
|
|
155
|
+
clearTimeout(timer);
|
|
156
|
+
controller.abort();
|
|
157
|
+
active--;
|
|
158
|
+
waiting.shift()?.();
|
|
159
|
+
}
|
|
160
|
+
}
|
|
161
|
+
return (cid, path) => {
|
|
162
|
+
const urls = resolveIpfsImageUrls(cid, 56, path);
|
|
163
|
+
if (!urls.length) return Promise.reject(new Error("IPFS text requires a bare CID and an optional safe relative path."));
|
|
164
|
+
const key = urls[0];
|
|
165
|
+
const cached = cache.get(key);
|
|
166
|
+
if (cached !== void 0) {
|
|
167
|
+
cache.delete(key);
|
|
168
|
+
cache.set(key, cached);
|
|
169
|
+
return Promise.resolve(cached);
|
|
170
|
+
}
|
|
171
|
+
const existing = pending.get(key);
|
|
172
|
+
if (existing) return existing;
|
|
173
|
+
if (pending.size >= MAX_PENDING_READS) return Promise.reject(new Error("Too many IPFS text reads; paginate the content."));
|
|
174
|
+
const request = load(urls).then((text) => {
|
|
175
|
+
cache.set(key, text);
|
|
176
|
+
if (cache.size > MAX_CACHED_READS) cache.delete(cache.keys().next().value);
|
|
177
|
+
return text;
|
|
178
|
+
}).finally(() => pending.delete(key));
|
|
179
|
+
pending.set(key, request);
|
|
180
|
+
return request;
|
|
181
|
+
};
|
|
182
|
+
}
|
|
183
|
+
|
|
184
|
+
// src/sdk/contractWriteFees.ts
|
|
185
|
+
var MAX_CONTRACT_WRITE_GAS = 5000000n;
|
|
186
|
+
var MAX_GAS_PRICE_MULTIPLIER = 2n;
|
|
187
|
+
async function resolveSafeContractWriteFeeOverrides(request, getNetworkGasPrice) {
|
|
188
|
+
if (request.gas !== void 0) {
|
|
189
|
+
if (request.gas <= 0n) throw new Error("Contract write gas must be greater than zero.");
|
|
190
|
+
if (request.gas > MAX_CONTRACT_WRITE_GAS) {
|
|
191
|
+
throw new Error(`Contract write gas must not exceed ${MAX_CONTRACT_WRITE_GAS.toString()}.`);
|
|
192
|
+
}
|
|
193
|
+
}
|
|
194
|
+
if (request.gasPrice !== void 0) {
|
|
195
|
+
if (request.gasPrice <= 0n) throw new Error("Contract write gasPrice must be greater than zero.");
|
|
196
|
+
const networkGasPrice = await getNetworkGasPrice();
|
|
197
|
+
if (networkGasPrice <= 0n) throw new Error("The runtime returned an invalid network gas price.");
|
|
198
|
+
const maximumGasPrice = networkGasPrice * MAX_GAS_PRICE_MULTIPLIER;
|
|
199
|
+
if (request.gasPrice > maximumGasPrice) {
|
|
200
|
+
throw new Error(
|
|
201
|
+
`Contract write gasPrice ${request.gasPrice.toString()} exceeds the runtime safety limit ${maximumGasPrice.toString()}.`
|
|
202
|
+
);
|
|
203
|
+
}
|
|
204
|
+
}
|
|
205
|
+
return {
|
|
206
|
+
...request.gas === void 0 ? {} : { gas: request.gas },
|
|
207
|
+
...request.gasPrice === void 0 ? {} : { gasPrice: request.gasPrice }
|
|
208
|
+
};
|
|
209
|
+
}
|
|
210
|
+
|
|
211
|
+
// src/sdk/contractEvents.ts
|
|
212
|
+
var MAX_CONTRACT_EVENT_BLOCK_SPAN = 1000n;
|
|
213
|
+
var MAX_CONTRACT_EVENT_BLOCK_LOOKBACK = 20000n;
|
|
214
|
+
var CONTRACT_EVENT_QUERY_CONCURRENCY = 4;
|
|
215
|
+
function splitContractEventBlockRanges(fromBlock, toBlock, maxBlockSpan = MAX_CONTRACT_EVENT_BLOCK_SPAN, maxLookback = MAX_CONTRACT_EVENT_BLOCK_LOOKBACK) {
|
|
216
|
+
if (fromBlock < 0n || toBlock < 0n) {
|
|
217
|
+
throw new RangeError("Contract event block numbers must not be negative.");
|
|
218
|
+
}
|
|
219
|
+
if (maxBlockSpan <= 0n) {
|
|
220
|
+
throw new RangeError("Contract event block span must be greater than zero.");
|
|
221
|
+
}
|
|
222
|
+
if (maxLookback < 0n) {
|
|
223
|
+
throw new RangeError("Contract event block lookback must not be negative.");
|
|
224
|
+
}
|
|
225
|
+
if (toBlock < fromBlock) return [];
|
|
226
|
+
if (toBlock - fromBlock > maxLookback) {
|
|
227
|
+
throw new RangeError(`Contract event block range must not exceed ${maxLookback.toString()} blocks.`);
|
|
228
|
+
}
|
|
229
|
+
const ranges = [];
|
|
230
|
+
let cursor = fromBlock;
|
|
231
|
+
while (cursor <= toBlock) {
|
|
232
|
+
const candidateEnd = cursor + maxBlockSpan;
|
|
233
|
+
const chunkEnd = candidateEnd < toBlock ? candidateEnd : toBlock;
|
|
234
|
+
ranges.push({ fromBlock: cursor, toBlock: chunkEnd });
|
|
235
|
+
cursor = chunkEnd + 1n;
|
|
236
|
+
}
|
|
237
|
+
return ranges;
|
|
238
|
+
}
|
|
239
|
+
async function readContractEventsInBlockRanges(input) {
|
|
240
|
+
const concurrency = input.concurrency ?? CONTRACT_EVENT_QUERY_CONCURRENCY;
|
|
241
|
+
if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > CONTRACT_EVENT_QUERY_CONCURRENCY) {
|
|
242
|
+
throw new RangeError(`Contract event query concurrency must be between 1 and ${CONTRACT_EVENT_QUERY_CONCURRENCY}.`);
|
|
243
|
+
}
|
|
244
|
+
const ranges = splitContractEventBlockRanges(input.fromBlock, input.toBlock);
|
|
245
|
+
const events = [];
|
|
246
|
+
for (let index2 = 0; index2 < ranges.length; index2 += concurrency) {
|
|
247
|
+
const batch = ranges.slice(index2, index2 + concurrency);
|
|
248
|
+
const batchEvents = await Promise.all(batch.map((range) => input.readRange(range)));
|
|
249
|
+
for (const items of batchEvents) events.push(...items);
|
|
250
|
+
}
|
|
251
|
+
return events;
|
|
72
252
|
}
|
|
73
253
|
var forbiddenName = /^(?:execute(?:Call|Batch)?|multicall|delegatecall|approve|increaseAllowance|decreaseAllowance|setApprovalForAll|transferOwnership|acceptOwnership|upgradeTo.*|setConfig|setSwapPath|setSplit)$/i;
|
|
74
|
-
var forbiddenSignatures = ["
|
|
254
|
+
var forbiddenSignatures = ["executeCall(address,uint256,bytes)", "approve(address,uint256)", "setApprovalForAll(address,bool)", "transferOwnership(address)", "upgradeTo(address)", "upgradeToAndCall(address,bytes)"];
|
|
75
255
|
var forbiddenSelectors = new Set(forbiddenSignatures.map(toFunctionSelector));
|
|
256
|
+
var executeSelectors = new Set(["execute(address,uint256,bytes,uint8)", "execute(address,uint256,bytes)"].map(toFunctionSelector));
|
|
76
257
|
var hash = /^0x[0-9a-fA-F]{64}$/;
|
|
77
258
|
var index = (x) => Number.isInteger(x) && x >= 0 && x < 32;
|
|
78
259
|
function requireRule(ok, reason) {
|
|
@@ -99,7 +280,8 @@ function parseResolvedContract(input) {
|
|
|
99
280
|
const seen = /* @__PURE__ */ new Set();
|
|
100
281
|
for (const f of writes) {
|
|
101
282
|
const selector = toFunctionSelector(f);
|
|
102
|
-
|
|
283
|
+
const reviewedExecute = f.name === "execute";
|
|
284
|
+
requireRule(!["view", "pure"].includes(f.stateMutability) && (reviewedExecute || !forbiddenName.test(f.name)) && !forbiddenSelectors.has(selector) && (reviewedExecute || !executeSelectors.has(selector) && !f.inputs.some(hasDynamicBytes)), "forbidden-write");
|
|
103
285
|
requireRule(!seen.has(selector), "duplicate-selector");
|
|
104
286
|
seen.add(selector);
|
|
105
287
|
}
|
|
@@ -453,8 +635,6 @@ async function withdrawNftAccount(env, request) {
|
|
|
453
635
|
}
|
|
454
636
|
return { hash: hash2, status, accountAddress, recipient, amount: input.amount, balanceAfter };
|
|
455
637
|
}
|
|
456
|
-
|
|
457
|
-
// src/sdk/runtime.tsx
|
|
458
638
|
var EMPTY_NFT_ACCOUNT_POLICIES = Object.freeze([]);
|
|
459
639
|
var defaultNftMetadataReader = createLocalNftMetadataReader();
|
|
460
640
|
var defaultMediaUploader = createLocalMediaUploader();
|
|
@@ -492,7 +672,7 @@ function VaultRuntimeProvider({ children, manifest, i18n, runtimeContext: runtim
|
|
|
492
672
|
const { address: accountAddress, isConnected } = useAccount();
|
|
493
673
|
const connectedChainId = useChainId();
|
|
494
674
|
const { connect, connectors } = useConnect();
|
|
495
|
-
const { disconnect
|
|
675
|
+
const { disconnect } = useDisconnect();
|
|
496
676
|
const { switchChainAsync, isPending: isSwitchingChain } = useSwitchChain();
|
|
497
677
|
const effectiveChainId = runtimeOverrides?.chainId ?? hostRuntimeResult?.addresses.chainId ?? connectedChainId ?? manifest.match.bindings[0]?.chainId ?? 56;
|
|
498
678
|
const publicClient = usePublicClient({ chainId: effectiveChainId });
|
|
@@ -581,7 +761,7 @@ function VaultRuntimeProvider({ children, manifest, i18n, runtimeContext: runtim
|
|
|
581
761
|
const connector = connectors[0];
|
|
582
762
|
if (connector) connect({ connector });
|
|
583
763
|
},
|
|
584
|
-
disconnect: () =>
|
|
764
|
+
disconnect: () => disconnect(),
|
|
585
765
|
switchChain: async () => {
|
|
586
766
|
if (previewWallet) {
|
|
587
767
|
throw new Error(`Switch wallet to ${chainLabelForChain(runtimeContext.chainId)} before continuing.`);
|
|
@@ -593,7 +773,7 @@ function VaultRuntimeProvider({ children, manifest, i18n, runtimeContext: runtim
|
|
|
593
773
|
}
|
|
594
774
|
};
|
|
595
775
|
},
|
|
596
|
-
[accountAddress, connect, connectedChainId, connectors,
|
|
776
|
+
[accountAddress, connect, connectedChainId, connectors, disconnect, isConnected, isSwitchingChain, nativeBalance, runtimeContext.chainId, runtimeOverrides?.previewWallet, switchChainAsync]
|
|
597
777
|
);
|
|
598
778
|
const assertWalletWriteReady = useCallback(
|
|
599
779
|
(actionLabel) => {
|
|
@@ -710,7 +890,7 @@ function VaultRuntimeProvider({ children, manifest, i18n, runtimeContext: runtim
|
|
|
710
890
|
if (!publicClient || !contractRuntime) throw new Error("resolved-contract/client-unavailable");
|
|
711
891
|
const contract = input.contract;
|
|
712
892
|
const prepared = contractRuntime.snapshot(input);
|
|
713
|
-
prepared.request = snapshotGenericContractWrite(prepared.request);
|
|
893
|
+
if (!prepared.record) prepared.request = snapshotGenericContractWrite(prepared.request);
|
|
714
894
|
const feeOverrides = await resolveSafeContractWriteFeeOverrides(prepared.request, getGasPrice);
|
|
715
895
|
const checked = await contractRuntime.validate(prepared, true);
|
|
716
896
|
const request = checked.request;
|
|
@@ -734,7 +914,7 @@ function VaultRuntimeProvider({ children, manifest, i18n, runtimeContext: runtim
|
|
|
734
914
|
assertWalletWriteReady(`writing ${input.functionName}`);
|
|
735
915
|
if (!walletClient || !publicClient || !contractRuntime) throw new Error("resolved-contract/client-unavailable");
|
|
736
916
|
const prepared = contractRuntime.snapshot(input);
|
|
737
|
-
prepared.request = snapshotGenericContractWrite(prepared.request);
|
|
917
|
+
if (!prepared.record) prepared.request = snapshotGenericContractWrite(prepared.request);
|
|
738
918
|
const feeOverrides = await resolveSafeContractWriteFeeOverrides(prepared.request, getGasPrice);
|
|
739
919
|
let checked = await contractRuntime.validate(prepared, true);
|
|
740
920
|
if (prepared.record) {
|
|
@@ -792,6 +972,13 @@ function VaultRuntimeProvider({ children, manifest, i18n, runtimeContext: runtim
|
|
|
792
972
|
},
|
|
793
973
|
[oracleReader, runtimeContext]
|
|
794
974
|
);
|
|
975
|
+
const fsiEndpointsRef = useRef(runtimeContext.manifest.endpoints);
|
|
976
|
+
const readIpfsText = useMemo(() => createIpfsTextReader(), []);
|
|
977
|
+
fsiEndpointsRef.current = runtimeContext.manifest.endpoints;
|
|
978
|
+
const readFsi = useCallback(
|
|
979
|
+
(path, params) => readFsiJson(fsiEndpointsRef.current, path, params),
|
|
980
|
+
[]
|
|
981
|
+
);
|
|
795
982
|
const readNftMetadata = useCallback(
|
|
796
983
|
async (request) => {
|
|
797
984
|
if (request.tokenId < 0n) throw new Error("NFT tokenId must not be negative.");
|
|
@@ -902,25 +1089,8 @@ function VaultRuntimeProvider({ children, manifest, i18n, runtimeContext: runtim
|
|
|
902
1089
|
}
|
|
903
1090
|
}, [assertWalletWriteReady, nftWithdrawalEnvironment, publicClient, refetch, runtimeContext, walletClient]);
|
|
904
1091
|
const componentContext = useMemo(() => structuredClone(runtimeContext), [runtimeContext]);
|
|
905
|
-
const chainRuntime = useFlapWalletRuntime({ connect: wallet.connect, mediaUploader: mediaUploader ?? defaultMediaUploader });
|
|
906
|
-
const forChain = useCallback((chainId) => createFlapChainSdk({
|
|
907
|
-
...chainRuntime,
|
|
908
|
-
// Reuse the Vault's strict target and resolver policies for scoped access too.
|
|
909
|
-
simulateContract: async (_chainId, request) => {
|
|
910
|
-
if (_chainId !== runtimeContext.chainId) throw new Error("Vault writes require the bound network.");
|
|
911
|
-
return (await simulateContract(request)).result;
|
|
912
|
-
},
|
|
913
|
-
writeContract: async (_chainId, request) => {
|
|
914
|
-
if (_chainId !== runtimeContext.chainId) throw new Error("Vault writes require the bound network.");
|
|
915
|
-
return writeContract(request);
|
|
916
|
-
},
|
|
917
|
-
sendTransaction: async () => {
|
|
918
|
-
throw new Error("Raw transactions require a reviewed standalone App.");
|
|
919
|
-
}
|
|
920
|
-
}, { chainId, manifest, writableChains: [runtimeContext.chainId], i18n: i18nApi, notify }), [chainRuntime, manifest, runtimeContext.chainId, i18nApi, notify, simulateContract, writeContract]);
|
|
921
1092
|
const sdk = useMemo(
|
|
922
1093
|
() => ({
|
|
923
|
-
forChain,
|
|
924
1094
|
context: componentContext,
|
|
925
1095
|
i18n: i18nApi,
|
|
926
1096
|
notify,
|
|
@@ -935,6 +1105,8 @@ function VaultRuntimeProvider({ children, manifest, i18n, runtimeContext: runtim
|
|
|
935
1105
|
waitForTx,
|
|
936
1106
|
withdrawNftAccount: withdrawNftAccount2,
|
|
937
1107
|
readOracle,
|
|
1108
|
+
readFsi,
|
|
1109
|
+
readIpfsText,
|
|
938
1110
|
readNftMetadata,
|
|
939
1111
|
uploadImage,
|
|
940
1112
|
uploadText,
|
|
@@ -942,18 +1114,21 @@ function VaultRuntimeProvider({ children, manifest, i18n, runtimeContext: runtim
|
|
|
942
1114
|
refetchNonce: version,
|
|
943
1115
|
openExplorerTx
|
|
944
1116
|
}),
|
|
945
|
-
[
|
|
1117
|
+
[getBlockNumber, getContractEvents, getGasPrice, i18nApi, notify, openExplorerTx, resolveContract, readContract, readNftMetadata, readOracle, readFsi, readIpfsText, refetch, componentContext, simulateContract, uploadImage, uploadText, version, waitForTx, wallet, withdrawNftAccount2, writeContract]
|
|
946
1118
|
);
|
|
947
|
-
return /* @__PURE__ */
|
|
948
|
-
|
|
949
|
-
{
|
|
950
|
-
|
|
951
|
-
|
|
952
|
-
|
|
953
|
-
|
|
954
|
-
|
|
1119
|
+
return /* @__PURE__ */ jsxs(RuntimeContext.Provider, { value: sdk, children: [
|
|
1120
|
+
children,
|
|
1121
|
+
/* @__PURE__ */ jsx("div", { className: "pointer-events-none fixed bottom-4 right-4 z-50 flex w-[min(360px,calc(100vw-2rem))] flex-col gap-2", children: messages.map((message) => /* @__PURE__ */ jsx("div", { className: "pointer-events-auto", children: /* @__PURE__ */ jsx(
|
|
1122
|
+
Alert,
|
|
1123
|
+
{
|
|
1124
|
+
tone: message.level === "error" ? "danger" : message.level,
|
|
1125
|
+
className: "cursor-pointer shadow-panel backdrop-blur-sm transition hover:translate-y-[-1px]",
|
|
1126
|
+
children: /* @__PURE__ */ jsx("button", { type: "button", className: "w-full text-left", onClick: () => dismissMessage(message.id), children: message.message })
|
|
1127
|
+
}
|
|
1128
|
+
) }, message.id)) })
|
|
1129
|
+
] });
|
|
955
1130
|
}
|
|
956
1131
|
|
|
957
|
-
export { VaultRuntimeProvider
|
|
958
|
-
//# sourceMappingURL=chunk-
|
|
959
|
-
//# sourceMappingURL=chunk-
|
|
1132
|
+
export { VaultRuntimeProvider };
|
|
1133
|
+
//# sourceMappingURL=chunk-HYBZWS6U.js.map
|
|
1134
|
+
//# sourceMappingURL=chunk-HYBZWS6U.js.map
|