everything-dev
Version:
A consolidated product package for building Module Federation apps with oRPC APIs.
196 lines (194 loc) • 6.82 kB
JavaScript
const require_runtime = require('./_virtual/_rolldown/runtime.cjs');
const require_theme = require('./utils/theme.cjs');
let node_crypto = require("node:crypto");
let effect = require("effect");
let execa = require("execa");
//#region src/near-cli.ts
const INSTALLER_URL = `https://github.com/near/near-cli-rs/releases/download/v0.23.5/near-cli-rs-installer.sh`;
const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
var NearCliNotFoundError = class extends Error {
_tag = "NearCliNotFoundError";
constructor() {
super("NEAR CLI not found");
}
};
var NearTransactionError = class extends Error {
_tag = "NearTransactionError";
};
function base64UrlToBytes(input) {
const normalized = input.replace(/-/g, "+").replace(/_/g, "/");
return new Uint8Array(Buffer.from(normalized, "base64"));
}
function base58Encode(input) {
if (input.length === 0) return "";
const digits = [0];
for (const byte of input) {
let carry = byte;
for (let i = 0; i < digits.length; i++) {
carry += digits[i] << 8;
digits[i] = carry % 58;
carry = Math.floor(carry / 58);
}
while (carry > 0) {
digits.push(carry % 58);
carry = Math.floor(carry / 58);
}
}
let output = "";
for (const byte of input) if (byte === 0) output += BASE58_ALPHABET[0];
else break;
for (let i = digits.length - 1; i >= 0; i--) output += BASE58_ALPHABET[digits[i]];
return output;
}
function generateNearKeyPair() {
const { publicKey, privateKey } = (0, node_crypto.generateKeyPairSync)("ed25519");
const publicJwk = publicKey.export({ format: "jwk" });
const privateJwk = privateKey.export({ format: "jwk" });
if (!publicJwk.x || !privateJwk.d) throw new Error("Failed to generate NEAR keypair");
const publicBytes = base64UrlToBytes(publicJwk.x);
const privateSeed = base64UrlToBytes(privateJwk.d);
const secretBytes = new Uint8Array(privateSeed.length + publicBytes.length);
secretBytes.set(privateSeed, 0);
secretBytes.set(publicBytes, privateSeed.length);
return {
publicKey: `ed25519:${base58Encode(publicBytes)}`,
privateKey: `ed25519:${base58Encode(secretBytes)}`
};
}
const checkNearCliInstalled = effect.Effect.tryPromise({
try: async () => {
try {
await (0, execa.execa)("near", ["--version"], { stdio: "pipe" });
return true;
} catch {
return false;
}
},
catch: () => /* @__PURE__ */ new Error("Failed to check NEAR CLI")
});
async function runNearCommand(args) {
if (!process.stdin.isTTY) throw new NearTransactionError("No TTY available for keychain signing. Set NEAR_PRIVATE_KEY environment variable to sign locally.");
await (0, execa.execa)("near", args, {
stdin: "inherit",
stdout: "inherit",
stderr: "inherit"
});
}
function resolveNearSigningMode(privateKey) {
if (privateKey) return {
_tag: "privateKey",
privateKey
};
if (!process.stdin.isTTY) throw new NearTransactionError("No private key provided and no TTY available for keychain signing. Set NEAR_PRIVATE_KEY environment variable to sign locally.");
console.log(require_theme.colors.yellow(" Warning: No NEAR_PRIVATE_KEY set — falling back to interactive keychain signing."));
return { _tag: "interactiveKeychain" };
}
const ensureNearCli = effect.Effect.gen(function* () {
if (yield* checkNearCliInstalled) return;
console.log();
console.log(" NEAR CLI not found");
console.log();
console.log(` To install manually: curl --proto '=https' --tlsv1.2 -LsSf ${INSTALLER_URL} | sh`);
console.log();
yield* effect.Effect.fail(new NearCliNotFoundError());
});
function combineNearOutput(stdout, stderr) {
return [stdout, stderr].filter((value) => value && value.trim().length > 0).join("\n");
}
function extractTransactionHash(output) {
return output.match(/Transaction ID:\s*([A-Za-z0-9]+)/i)?.[1];
}
const executeTransaction = (config, signingMode) => effect.Effect.gen(function* () {
const resolvedSigningMode = signingMode ?? resolveNearSigningMode(config.privateKey);
const gas = (config.gas || "300Tgas").replace(/\s+/g, "");
const deposit = (config.deposit || "0NEAR").replace(/\s+/g, "");
const network = config.network || (config.account.endsWith(".testnet") ? "testnet" : "mainnet");
const args = [
"contract",
"call-function",
"as-transaction",
config.contract,
config.method,
"base64-args",
config.argsBase64,
"prepaid-gas",
gas,
"attached-deposit",
deposit,
"sign-as",
config.account,
"network-config",
network
];
if (resolvedSigningMode._tag === "privateKey") args.push("sign-with-plaintext-private-key", resolvedSigningMode.privateKey, "send");
else args.push("sign-with-keychain", "send");
const output = yield* effect.Effect.tryPromise({
try: async () => {
const isPrivateKeyMode = resolvedSigningMode._tag === "privateKey";
const proc = (0, execa.execa)("near", args, {
stdin: isPrivateKeyMode ? "ignore" : "inherit",
stdout: isPrivateKeyMode ? "pipe" : "inherit",
stderr: isPrivateKeyMode ? "pipe" : "inherit",
reject: false,
timeout: 300 * 1e3
});
if (isPrivateKeyMode) {
proc.stdout?.on("data", (chunk) => {
process.stdout.write(chunk);
});
proc.stderr?.on("data", (chunk) => {
process.stderr.write(chunk);
});
}
const result = await proc;
const combined = combineNearOutput(result.stdout, result.stderr);
const txHash = extractTransactionHash(combined);
const hasCodeDoesNotExist = /CodeDoesNotExist/i.test(combined);
const hasTransactionFailed = /Transaction failed/i.test(combined);
const softSuccess = Boolean(txHash) && hasCodeDoesNotExist && hasTransactionFailed;
if (result.exitCode === 0 || softSuccess) {
if (softSuccess) console.log(` ${txHash} — FastDATA CodeDoesNotExist (expected)`);
return {
success: true,
txHash,
output: combined || void 0
};
}
throw new NearTransactionError(combined || `Transaction failed with code ${result.exitCode}`);
},
catch: (error) => error
});
return {
success: true,
txHash: output.txHash,
output: output.output
};
});
async function addFunctionCallAccessKey(config) {
const keyPair = generateNearKeyPair();
await runNearCommand([
"account",
"add-key",
config.account,
"grant-function-call-access",
"--allowance",
config.allowance,
"--contract-account-id",
config.contract,
"--function-names",
config.functionNames.join(", "),
"use-manually-provided-public-key",
keyPair.publicKey,
"network-config",
config.network || (config.account.endsWith(".testnet") ? "testnet" : "mainnet"),
"sign-with-keychain",
"send"
]);
return keyPair;
}
//#endregion
exports.addFunctionCallAccessKey = addFunctionCallAccessKey;
exports.ensureNearCli = ensureNearCli;
exports.executeTransaction = executeTransaction;
exports.resolveNearSigningMode = resolveNearSigningMode;
//# sourceMappingURL=near-cli.cjs.map