zano-native 0.0.1

package/lib/scripts/smoke-node.js

@@ -0,0 +1,33 @@
+"use strict";
+// Smoke-test the Node addon: hello + getVersion.
+// Run after `npm run build-native-host`:
+//   node -r sucrase/register ./scripts/smoke-node.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const node_1 = require("../src/node");
+async function main() {
+    const documentDirectory = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'zano-node-'));
+    const module = (0, node_1.makeNodeZanoModule)({ documentDirectory });
+    const hello = await module.callZano('hello', []);
+    console.log('hello:', hello);
+    const version = await module.callZano('getVersion', []);
+    console.log('getVersion:', version);
+    const names = module.methodNames;
+    console.log('methodNames count:', names.length);
+    if (!names.includes('hello') || !names.includes('getVersion')) {
+        throw new Error('methodNames missing hello/getVersion');
+    }
+    if (hello !== 'hello') {
+        throw new Error(`unexpected hello result: ${hello}`);
+    }
+    if (version.length === 0) {
+        throw new Error('getVersion returned empty string');
+    }
+    process.exit(0);
+}
+main().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/lib/scripts/update-sources.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/scripts/update-sources.js

@@ -0,0 +1,412 @@
+"use strict";
+// Run this script as `node -r sucrase/register ./scripts/update-sources.ts`
+//
+// It will:
+// - Download third-party source code.
+// - Assemble Android shared libraries for each platform.
+// - Assemble an iOS universal static xcframework.
+//
+// Here is where each puzzle piece comes from:
+//
+// |         | Zano  | OpenSSL           | Boost             |
+// |---------|-------|-------------------|-------------------|
+// | Android | CMake | zano_native_lib   | Boost-for-Android |
+// | iOS     | CMake | OpenSSL-Universal | zano_native_lib   |
+//
+// For both iOS and Android, we build Zano by invoking CMake directly.
+// The zano_native_lib build scripts aren't really useful,
+// since the aren't geared towards React Native auto-linking.
+// Calling CMake ourselves isn't that hard.
+//
+// On Android, the zano_native_lib OpenSSL libraries in are fine,
+// but we have to use Boost-for-Android to get the right STL version.
+//
+// On iOS, the boost libraries are fine,
+// but their OpenSSL is just a re-packaged copy OpenSSL-Universal,
+// so it's simpler to pull that in from CocoaPods directly.
+//
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("fs/promises");
+const os_1 = require("os");
+const path_1 = require("path");
+const android_tools_1 = require("./utils/android-tools");
+const closeWalletPatch_1 = require("./utils/closeWalletPatch");
+const common_1 = require("./utils/common");
+const ios_tools_1 = require("./utils/ios-tools");
+const sdkFolders_1 = require("./utils/sdkFolders");
+const srcPath = (0, path_1.join)(__dirname, '../src');
+async function main() {
+    await (0, promises_1.mkdir)(common_1.tmpPath, { recursive: true });
+    await downloadSources();
+    await checkSdkFolders();
+    // Android:
+    await buildAndroidBoost();
+    for (const platform of androidPlatforms) {
+        await buildAndroidZano(platform);
+    }
+    // iOS:
+    for (const platform of iosPlatforms) {
+        await buildIosZano(platform);
+    }
+    await packageIosZano();
+}
+async function downloadSources() {
+    await (0, common_1.getRepo)('zano_native_lib', 'https://github.com/hyle-team/zano_native_lib.git', '91085c0ebd95fcdae3327071a9e5f5b615d7da3d', 
+    // The repo keeps prebuilt archives for every platform in Git LFS,
+    // but we only link against these two:
+    { lfsIncludes: ['_install_ios/**', '_libs_android/**'] });
+    await (0, common_1.getRepo)('Boost-for-Android', 'https://github.com/moritz-wundke/Boost-for-Android.git', '51924ec5533a4fefb5edf99feaeded794c06a4fb');
+    // Rename the compress function in RIPEMD160.c,
+    // since that conflicts with Zlib:
+    const mdPath = (0, path_1.join)(common_1.tmpPath, 'zano_native_lib/Zano/src/crypto/RIPEMD160.h');
+    const mdText = await (0, promises_1.readFile)(mdPath, 'utf8');
+    await (0, promises_1.writeFile)(mdPath, '#define compress md_compress\n' + mdText);
+    // Rework close_wallet so it does not hold the wallet-manager lock while
+    // it waits on the wallet, which permanently deadlocks the manager when a
+    // wallet is closed mid-scan (see closeWalletPatch.ts). Only the Android
+    // libraries build from these sources; iOS links the prebuilt framework:
+    const wmPath = (0, path_1.join)(common_1.tmpPath, 'zano_native_lib/Zano/src/wallet/wallets_manager.cpp');
+    const wmText = await (0, promises_1.readFile)(wmPath, 'utf8');
+    await (0, promises_1.writeFile)(wmPath, (0, closeWalletPatch_1.patchCloseWallet)(wmText));
+}
+/**
+ * Fails the build if the SDK declares a directory we do not know about.
+ *
+ * The SDK writes into directories it derives from the working directory the
+ * app hands it, and on iOS those have to be pre-created so they can be
+ * excluded from device backups -- the wallet files hold the seed and spend
+ * keys. That list lives in `ios/ZanoModule.mm` and cannot be derived at
+ * build time, so it has to be maintained by hand.
+ *
+ * Bumping the `zano_native_lib` pin is the only way a new directory can
+ * appear, and this script is what performs that bump, so this is the one
+ * place that always sees the new source. Without this check a new directory
+ * would ship silently, un-excluded, with nothing in the repo's diff to show
+ * for it -- `tmp/` is gitignored, so a pin bump reviews as a changed hash.
+ *
+ * This catches directories declared as `#define`d folder names, which is how
+ * the SDK has always declared them. It cannot catch a path composed inline,
+ * so it is a tripwire rather than a proof.
+ */
+async function checkSdkFolders() {
+    const apiPath = (0, path_1.join)(common_1.tmpPath, 'zano_native_lib/Zano/src/wallet/plain_wallet_api.cpp');
+    const apiText = await (0, promises_1.readFile)(apiPath, 'utf8');
+    const found = (0, sdkFolders_1.findSdkFolders)(apiText);
+    const missing = found.filter(name => !sdkFolders_1.sdkFolders.includes(name));
+    if (missing.length > 0) {
+        throw new Error(`The Zano SDK declares directories this package does not handle: ` +
+            `${missing.join(', ')}. Add them to \`sdkFolders\` here and to the ` +
+            '`prepareZanoDirectory` calls in `ios/ZanoModule.mm`, so they are ' +
+            'created and excluded from device backups.');
+    }
+    const extra = sdkFolders_1.sdkFolders.filter(name => !found.includes(name));
+    if (extra.length > 0) {
+        // Not fatal, since an unused directory is harmless. It usually means the
+        // SDK renamed something, in which case the new name failed above.
+        console.log(`Note: the SDK no longer declares ${extra.join(', ')}. ` +
+            'These can probably be dropped from `sdkFolders`.');
+    }
+    console.log(`Checked SDK directories: ${found.join(', ')}`);
+}
+// Compiler options:
+const includePaths = ['zano_native_lib/Zano/src/wallet'];
+// Source list (from src/):
+const sources = ['zano-wrapper/zano-methods.cpp'];
+// .a files from Zano:
+const zanoLibs = ['common', 'crypto', 'currency_core', 'wallet', 'z'];
+// .a files from boost:
+const boostLibs = [
+    'atomic',
+    'chrono',
+    'date_time',
+    'filesystem',
+    'program_options',
+    'regex',
+    'serialization',
+    'system',
+    'thread',
+    'timer'
+];
+const androidPlatforms = [
+    { arch: 'arm64-v8a', triple: 'aarch64-linux-android33' },
+    { arch: 'armeabi-v7a', triple: 'armv7a-linux-androideabi23' },
+    { arch: 'x86', triple: 'i686-linux-android23' },
+    { arch: 'x86_64', triple: 'x86_64-linux-android23' }
+];
+// Phones and simulators we need to support:
+const iosPlatforms = [
+    { sdk: 'iphoneos', arch: 'arm64', cmakePlatform: 'OS64' },
+    { sdk: 'iphonesimulator', arch: 'arm64', cmakePlatform: 'SIMULATORARM64' },
+    { sdk: 'iphonesimulator', arch: 'x86_64', cmakePlatform: 'SIMULATOR64' }
+    // Zano does not support these:
+    // { sdk: 'iphoneos', arch: 'armv7' },
+    // { sdk: 'iphoneos', arch: 'armv7s' },
+];
+/**
+ * `--arm64` narrows the build to the slices a modern phone, an Apple-Silicon
+ * simulator and the Node CLI actually need: one Android ABI and the two arm64
+ * iOS slices, instead of four ABIs and an Intel simulator. Filtering the
+ * shared arrays in place keeps every consumer in agreement about what exists
+ * — the build loops, Boost's `--arch` list, and the xcframework packaging,
+ * which would otherwise `lipo` a slice that was never built.
+ */
+if (process.argv.includes('--arm64')) {
+    androidPlatforms.splice(0, androidPlatforms.length, ...androidPlatforms.filter(platform => platform.arch === 'arm64-v8a'));
+    iosPlatforms.splice(0, iosPlatforms.length, ...iosPlatforms.filter(platform => platform.arch === 'arm64'));
+}
+const iosSdkTriples = {
+    iphoneos: '%arch%-apple-ios13.0',
+    iphonesimulator: '%arch%-apple-ios13.0-simulator'
+};
+/**
+ * We compile our own Boost for Android,
+ * because the Zano one is linking with the static STL library,
+ * but we need to link with the shared STL library.
+ */
+async function buildAndroidBoost() {
+    const boostExists = await (0, common_1.fileExists)((0, path_1.join)(common_1.tmpPath, 'Boost-for-Android/build/out/arm64-v8a/lib/libboost_atomic.a'));
+    if (boostExists)
+        return;
+    const ndkPath = await (0, android_tools_1.getNdkPath)();
+    await (0, common_1.loudExec)('./build-android.sh', [
+        `--arch=${androidPlatforms.map(platform => platform.arch).join(',')}`,
+        '--boost=1.84.0',
+        `--with-libraries=${boostLibs.join(',')}`,
+        '--layout=system',
+        ndkPath
+    ], { cwd: (0, path_1.join)(common_1.tmpPath, 'Boost-for-Android') });
+}
+/**
+ * Invokes CMake to build Zano,
+ * followed by clang++ to build the shared library.
+ */
+async function buildAndroidZano(platform) {
+    const { arch, triple } = platform;
+    const ndkPath = await (0, android_tools_1.getNdkPath)();
+    const working = (0, path_1.join)(common_1.tmpPath, `android-${arch}`);
+    const boostPath = (0, path_1.join)(common_1.tmpPath, 'Boost-for-Android/build/out/', arch);
+    const sslPath = (0, path_1.join)(common_1.tmpPath, 'zano_native_lib/_libs_android/openssl');
+    const zanoLibPath = (0, path_1.join)(common_1.tmpPath, `android-${arch}/${arch}/lib/`);
+    // Build Zano itself:
+    await (0, common_1.loudExec)('cmake', [
+        // Source directory:
+        `-S${(0, path_1.join)(common_1.tmpPath, 'zano_native_lib/Zano')}`,
+        // Build directory:
+        `-B${(0, path_1.join)(working, 'cmake')}`,
+        // Build options:
+        `-DBoost_INCLUDE_DIRS=${(0, path_1.join)(boostPath, 'include')}`,
+        `-DBoost_LIBRARY_DIRS=${(0, path_1.join)(boostPath, 'lib')}`,
+        `-DBoost_VERSION="1.84.0"`,
+        `-DCMAKE_ANDROID_ARCH_ABI=${arch}`,
+        `-DCMAKE_ANDROID_NDK=${ndkPath}`,
+        `-DCMAKE_ANDROID_STL_TYPE=c++_shared`,
+        `-DCMAKE_BUILD_TYPE=Release`,
+        `-DCMAKE_INSTALL_PREFIX=${working}`,
+        `-DCMAKE_SYSTEM_NAME=Android`,
+        `-DCMAKE_SYSTEM_VERSION=23`,
+        `-DDISABLE_TOR=TRUE`,
+        `-DOPENSSL_CRYPTO_LIBRARY=${(0, path_1.join)(sslPath, arch, 'lib/libcrypto.a')}`,
+        `-DOPENSSL_INCLUDE_DIR=${(0, path_1.join)(sslPath, 'include')}`,
+        `-DOPENSSL_SSL_LIBRARY=${(0, path_1.join)(sslPath, arch, 'lib/libssl.a')}`
+    ]);
+    await (0, common_1.loudExec)('cmake', [
+        '--build',
+        (0, path_1.join)(working, 'cmake'),
+        '--config',
+        'Release',
+        '--target',
+        'install',
+        '--',
+        `-j${(0, os_1.cpus)().length}`
+    ]);
+    // Build the library:
+    const cxxPath = (0, path_1.join)(ndkPath, `toolchains/llvm/prebuilt/darwin-x86_64/bin/${triple}-clang++`);
+    const outPath = (0, path_1.join)(common_1.tmpPath, '../android/src/main/jniLibs/', arch);
+    await (0, promises_1.mkdir)(outPath, { recursive: true });
+    const jniSources = [...sources, 'jni/jni.cpp'];
+    const sslLibs = ['crypto', 'ssl'];
+    console.log(`Linking librnzano.so for Android ${arch}`);
+    await (0, common_1.loudExec)(cxxPath, [
+        '-shared',
+        '-fPIC',
+        `-o${(0, path_1.join)(outPath, 'librnzano.so')}`,
+        ...includePaths.map(path => `-I${(0, path_1.join)(common_1.tmpPath, path)}`),
+        ...jniSources.map(source => (0, path_1.join)(srcPath, source)),
+        ...boostLibs.map(name => (0, path_1.join)(boostPath, `/lib/libboost_${name}.a`)),
+        ...sslLibs.map(name => (0, path_1.join)(sslPath, `${arch}/lib/lib${name}.a`)),
+        ...zanoLibs.map(name => (0, path_1.join)(zanoLibPath, `lib${name}.a`)),
+        '-llog',
+        `-Wl,--version-script=${(0, path_1.join)(srcPath, 'jni/exports.map')}`,
+        '-Wl,--no-undefined',
+        '-Wl,-z,max-page-size=16384',
+        // Drop the symbol table. JNI resolves through .dynsym, which
+        // --strip-all keeps, and the debug symbols roughly double the shipped
+        // library otherwise.
+        '-Wl,--strip-all'
+    ]);
+}
+/**
+ * Locates the slice of a prebuilt xcframework that matches one platform.
+ *
+ * An xcframework declares its own slices in `Info.plist`, so ask it rather
+ * than hardcoding directory names: a repackaged upstream framework then
+ * fails here with a clear message instead of further down with a missing
+ * file.
+ *
+ * The returned archive is checked against the architecture we are building.
+ * The simulator slice holds both architectures in one archive, so the slice
+ * alone does not pin the arch -- only the `-arch` flag on the relocatable
+ * link below does, and Apple's `ld` tends to warn rather than fail when an
+ * archive member does not match it. This also catches an unfetched Git LFS
+ * pointer sitting where the 150MB archive should be, which otherwise shows
+ * up as a confusing link error.
+ */
+async function findXcframeworkSlice(frameworkPath, platform) {
+    const { arch, sdk } = platform;
+    const variant = sdk === 'iphonesimulator' ? 'simulator' : undefined;
+    const plist = JSON.parse(await (0, common_1.captureExec)('plutil', [
+        '-convert',
+        'json',
+        '-o',
+        '-',
+        (0, path_1.join)(frameworkPath, 'Info.plist')
+    ]));
+    const slice = plist.AvailableLibraries.find(library => library.SupportedPlatform === 'ios' &&
+        library.SupportedPlatformVariant === variant &&
+        library.SupportedArchitectures.includes(arch));
+    if (slice == null) {
+        throw new Error(`${frameworkPath} has no ios${variant == null ? '' : `-${variant}`} slice for ${arch}. It offers: ${plist.AvailableLibraries.map(library => library.LibraryIdentifier).join(', ')}`);
+    }
+    const slicePath = (0, path_1.join)(frameworkPath, slice.LibraryIdentifier);
+    const libraryPath = (0, path_1.join)(slicePath, slice.LibraryPath);
+    const archs = (await (0, common_1.captureExec)('lipo', ['-archs', libraryPath])).split(/\s+/);
+    if (!archs.includes(arch)) {
+        throw new Error(`${libraryPath} holds ${archs.join(', ')}, but we are building ${arch}`);
+    }
+    return {
+        headersPath: (0, path_1.join)(slicePath, slice.HeadersPath ?? 'Headers'),
+        libraryPath
+    };
+}
+/**
+ * Compiles our wrapper and links it against the prebuilt
+ * libzano-plain-wallet static library (which already bundles Zano,
+ * Boost, and OpenSSL), then localizes symbols into a static lib.
+ *
+ * As of zano_native_lib HF6, the repo no longer ships the raw
+ * `_libs_ios` OpenSSL/Boost archives we used to build Zano from
+ * source against. Instead it provides prebuilt xcframeworks, so we
+ * link the plain-wallet bundle directly.
+ */
+async function buildIosZano(platform) {
+    const { sdk, arch } = platform;
+    const working = (0, path_1.join)(common_1.tmpPath, `${sdk}-${arch}`);
+    await (0, promises_1.mkdir)(working, { recursive: true });
+    // The prebuilt plain-wallet xcframework slice for this platform:
+    const { headersPath, libraryPath: zanoLib } = await findXcframeworkSlice((0, path_1.join)(common_1.tmpPath, 'zano_native_lib/_install_ios/lib/libzano-plain-wallet.xcframework'), platform);
+    // Find platform tools:
+    const ar = await (0, common_1.quietExec)('xcrun', ['--sdk', sdk, '--find', 'ar']);
+    const cc = await (0, common_1.quietExec)('xcrun', ['--sdk', sdk, '--find', 'clang']);
+    const cxx = await (0, common_1.quietExec)('xcrun', ['--sdk', sdk, '--find', 'clang++']);
+    const ld = await (0, common_1.quietExec)('xcrun', ['--sdk', sdk, '--find', 'ld']);
+    const objcopy = await (0, ios_tools_1.getObjcopyPath)();
+    const sdkFlags = [
+        '-arch',
+        arch,
+        '-target',
+        iosSdkTriples[sdk].replace('%arch%', arch),
+        '-isysroot',
+        await (0, common_1.quietExec)('xcrun', ['--sdk', sdk, '--show-sdk-path'])
+    ];
+    const cflags = [
+        `-I${headersPath}`,
+        '-miphoneos-version-min=13.0',
+        '-O2',
+        '-Werror=partial-availability'
+    ];
+    const cxxflags = [...cflags, '-std=c++11'];
+    // Compile our sources:
+    const objects = [];
+    for (const source of sources) {
+        console.log(`Compiling ${source} for ${sdk}-${arch}...`);
+        // Figure out the object file name:
+        const object = (0, path_1.join)(working, source.replace(/^.*\//, '').replace(/\.c$|\.cc$|\.cpp$/, '.o'));
+        objects.push(object);
+        const useCxx = /\.cpp$|\.cc$/.test(source);
+        await (0, common_1.loudExec)(useCxx ? cxx : cc, [
+            '-c',
+            ...(useCxx ? cxxflags : cflags),
+            ...sdkFlags,
+            `-o${object}`,
+            (0, path_1.join)(srcPath, source)
+        ]);
+    }
+    // Link our wrapper against the prebuilt plain-wallet library
+    // into a single relocatable object. `ld -r` pulls in only the
+    // archive members our wrapper transitively needs:
+    console.log(`Linking zano-module.o for ${sdk} ${arch}`);
+    const objectPath = (0, path_1.join)(working, 'zano-module.o');
+    await (0, common_1.loudExec)(ld, [
+        '-r',
+        '-arch',
+        arch,
+        '-o',
+        objectPath,
+        ...objects,
+        zanoLib
+    ]);
+    // Localize all symbols except the ones we really want,
+    // hiding them from future linking steps:
+    await (0, common_1.loudExec)(objcopy, [
+        objectPath,
+        '-w',
+        '-L*',
+        '-L!_zanoMethods',
+        '-L!_zanoMethodCount'
+    ]);
+    // Generate a static library:
+    console.log(`Building static library for ${sdk}-${arch}...`);
+    const library = (0, path_1.join)(working, `libzano-module.a`);
+    await (0, promises_1.rm)(library, { force: true });
+    await (0, common_1.loudExec)(ar, ['rcs', library, objectPath]);
+}
+/**
+ * Creates a unified xcframework file out of the per-platform
+ * static libraries that `buildIosZano` creates.
+ */
+async function packageIosZano() {
+    const sdks = new Set(iosPlatforms.map(row => row.sdk));
+    // Merge the platforms into a fat library:
+    const merged = [];
+    for (const sdk of sdks) {
+        console.log(`Merging libraries for ${sdk}...`);
+        const outPath = (0, path_1.join)(common_1.tmpPath, `${sdk}-lipo`);
+        await (0, promises_1.mkdir)(outPath, { recursive: true });
+        const output = (0, path_1.join)(outPath, 'libzano-module.a');
+        await (0, common_1.loudExec)('lipo', [
+            '-create',
+            '-output',
+            output,
+            ...iosPlatforms
+                .filter(platform => platform.sdk === sdk)
+                .map(({ sdk, arch }) => (0, path_1.join)(common_1.tmpPath, `${sdk}-${arch}`, `libzano-module.a`))
+        ]);
+        merged.push('-library', output);
+    }
+    // Bundle those into an XCFramework:
+    console.log('Creating XCFramework...');
+    await (0, promises_1.rm)('ios/ZanoModule.xcframework', { recursive: true, force: true });
+    await (0, common_1.loudExec)('xcodebuild', [
+        '-create-xcframework',
+        ...merged,
+        '-output',
+        (0, path_1.join)(__dirname, '../ios/ZanoModule.xcframework')
+    ]);
+}
+main().catch(error => {
+    // This is the `prepack` script, so a swallowed failure means `npm publish`
+    // reports success against whatever stale `ios/ZanoModule.xcframework` was
+    // lying around, and no check this script makes can ever fail a build.
+    console.error(error);
+    process.exitCode = 1;
+});

package/lib/scripts/utils/android-tools.d.ts

@@ -0,0 +1 @@
+export declare function getNdkPath(): Promise<string>;

package/lib/scripts/utils/android-tools.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNdkPath = void 0;
+const path_1 = require("path");
+const common_1 = require("./common");
+// Matches the Edge app NDK version
+// The Zano build used '27.2.12479018', so we could try upgrading.
+const NDK_VERSION = '26.1.10909125';
+async function getNdkPath() {
+    const { ANDROID_HOME } = process.env;
+    if (ANDROID_HOME == null) {
+        throw new Error('ANDROID_HOME is not set in the environment.');
+    }
+    // Find the NDK:
+    const ndkPath = (0, path_1.join)(ANDROID_HOME, 'ndk', NDK_VERSION);
+    const hasNdk = await (0, common_1.fileExists)(ndkPath);
+    // Install the NDK if we need it:
+    if (!hasNdk) {
+        console.log(`Installing NDK ${NDK_VERSION}...`);
+        const sdkManagerPath = (0, path_1.join)(ANDROID_HOME, 'cmdline-tools/latest/bin/sdkmanager');
+        await (0, common_1.loudExec)(sdkManagerPath, [`"ndk;${NDK_VERSION}"`]);
+    }
+    return ndkPath;
+}
+exports.getNdkPath = getNdkPath;

package/lib/scripts/utils/closeWalletPatch.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Rewrites the SDK's `wallets_manager::close_wallet` so it does not hold
+ * the wallet-manager lock while waiting on the wallet being closed. See
+ * the comment on `replacement` above for the deadlock this removes and
+ * the semantics it deliberately changes.
+ *
+ * Only the Android libraries pick this up: iOS links the prebuilt
+ * `libzano-plain-wallet` xcframework rather than building these sources,
+ * and iOS runs the same close-during-catch-up cycle without wedging.
+ *
+ * The function is located by its unique signature, delimited by brace
+ * counting, and then required to match the pinned original exactly
+ * (modulo trailing whitespace), so a pin bump that changes `close_wallet`
+ * in any way fails the build here instead of silently keeping (or
+ * dropping) a stale patch. The brace counter would be fooled by a brace
+ * inside a string literal, but the full-body comparison catches that case
+ * too: a mis-delimited body cannot match the original.
+ *
+ * @param text - The contents of the SDK's `wallets_manager.cpp`.
+ * @returns The patched contents. Already-patched input comes back
+ * unchanged, so the caller does not need to track whether it ran.
+ */
+export declare function patchCloseWallet(text: string): string;