אינטגרציה עם חתימות שרשרת של NEAR

אינטראקציה בין-שרשרתית דורשת באופן מסורתי גשרים או פריסת חוזים בכל שרשרת. אנו מציעים חלופה—אינטגרציה סוהר עם חתימות שרשרת של NEAR. חשבון NEAR אחד מנהל נכסים ב-Ethereum, Bitcoin, Solana ללא חוזים נוספים. הניסיון שלנו מראה הפחתה של 40% בזמן ו-60% בעלות בהשוואה לגשרים קלאסיים. נבחן את הפרויקט שלך בחינם.

איך זה עובד

בליבה נמצאת רשת MPC (חישוב רב-צדדי) של מאמתי NEAR המאחסנים יחד מפתח ראשי. משתמש מבקש חתימת עסקה לשרשרת אחרת; רשת ה-MPC מייצרת חתימה באמצעות קריפטוגרפיה סף. החתימה המתקבלת תקפה לשרשרת היעד וניתן לשדר אותה.

משמעות הדבר היא שחשבון ה-NEAR שלך יכול לשלוט בכתובת Bitcoin, כתובת Ethereum, כתובת Solana—ללא ביטוי גיבוי לכל אחת. חשבון NEAR אחד = גישה לכל הנכסים בכל השרשרות.

NEAR Account (alice.near)
├── Controls ETH address: 0x1234... (secp256k1 derived key)
├── Controls BTC address: bc1q... (secp256k1 derived key)
└── Controls SOL address: ABC... (ed25519 derived key)

מהו נתיב גזירה ולמה הוא נחוץ?

כל חשבון NEAR יכול לקבל כתובות מרובות בשרשרות חיצוניות באמצעות נתיב גזירה. חשבון אחד מנהל ארנקים מרובים: alice.near עם נתיב 'eth-1' נותן כתובת ETH אחת, עם נתיב 'eth-2' אחרת, עם נתיב 'btc-main' כתובת BTC. זה מאפשר מבנה נכסים לפי מטרה.

const ethPath = `ethereum-1`;
const btcPath = `bitcoin-main`;
const ethAddress = await deriveAddress(nearAccount, ethPath, 'secp256k1');
const btcAddress = await deriveAddress(nearAccount, btcPath, 'secp256k1');

איך חתימות שרשרת חותמות על עסקה לשרשרת אחרת?

התהליך מורכב מכמה שלבים. ראשית, אתה יוצר עסקה לא חתומה לשרשרת היעד (למשל, Ethereum). לאחר מכן, ה-hash של עסקה זו נשלח לחוזה v1.signer.near. רשת ה-MPC של מאמתים מייצרת חתימת ECDSA או EdDSA באמצעות קריפטוגרפיה סף. החתימה המתקבלת תואמת לשרשרת היעד—אתה מחבר אותה לעסקה ומשדר ישירות.

import { connect, KeyPair, utils } from "near-api-js";
import { CONTRACT_ID } from "./constants";

async function requestEthSignature(
  nearAccount: Account,
  ethTxPayload: string,
  derivationPath: string
): Promise<{ r: string; s: string; v: number }> {
  const result = await nearAccount.functionCall({
    contractId: "v1.signer.near",
    methodName: "sign",
    args: {
      payload: Array.from(Buffer.from(ethTxPayload, "hex")),
      path: derivationPath,
      key_version: 0,
    },
    gas: "300000000000000",
    attachedDeposit: utils.format.parseNearAmount("0.1"),
  });
  const { big_r, s, recovery_id } = result as any;
  return {
    r: big_r.affine_point,
    s: s.scalar,
    v: recovery_id,
  };
}

זרימה מלאה: NEAR → עסקת Ethereum

import { ethers } from "ethers";

async function sendEthFromNear(
  nearAccount: Account,
  recipient: string,
  amountWei: bigint,
  derivationPath: string
) {
  const ethAddress = await getEthAddressFromNear(nearAccount, derivationPath);
  const provider = new ethers.JsonRpcProvider("https://eth.llamarpc.com");
  const nonce = await provider.getTransactionCount(ethAddress);
  const feeData = await provider.getFeeData();

  const tx = {
    to: recipient,
    value: amountWei,
    nonce,
    chainId: 1,
    maxFeePerGas: feeData.maxFeePerGas,
    maxPriorityFeePerGas: feeData.maxPriorityFeePerGas,
    gasLimit: 21000n,
    type: 2,
  };

  const serialized = ethers.Transaction.from(tx).unsignedSerialized;
  const payload = ethers.getBytes(ethers.keccak256(serialized));
  const signature = await requestEthSignature(
    nearAccount,
    Buffer.from(payload).toString("hex"),
    derivationPath
  );

  const signedTx = ethers.Transaction.from({
    ...tx,
    signature: {
      r: "0x" + signature.r,
      s: "0x" + signature.s,
      v: signature.v,
    },
  });

  const txResponse = await provider.broadcastTransaction(signedTx.serialized);
  return txResponse.wait();
}

אינטגרציית Bitcoin

המערכת תומכת ב-Bitcoin (secp256k1 + P2WPKH/P2TR). זו יכולת ייחודית: רוב הפרוטוקולים הבין-שרשרתיים האחרים אינם תומכים ב-Bitcoin באופן טבעי. באמצעות תיעוד חתימות שרשרת של NEAR, יישמנו חתימת עסקאות Bitcoin.

import * as bitcoin from "bitcoinjs-lib";

async function sendBitcoinFromNear(
  nearAccount: Account,
  recipient: string,
  satoshis: number,
  derivationPath: string
) {
  const network = bitcoin.networks.bitcoin;
  const btcAddress = await getBtcAddressFromNear(nearAccount, derivationPath);
  const utxos = await fetchUTXOs(btcAddress);
  const psbt = new bitcoin.Psbt({ network });

  for (const utxo of utxos) {
    psbt.addInput({
      hash: utxo.txid,
      index: utxo.vout,
      witnessUtxo: utxo.witnessUtxo,
    });
  }

  psbt.addOutput({ address: recipient, value: satoshis });

  for (let i = 0; i < utxos.length; i++) {
    const sighash = psbt.data.inputs[i].sighashType ?? bitcoin.Transaction.SIGHASH_ALL;
    const hash = psbt.__CACHE.__TX.hashForWitnessV0(
      i,
      psbt.data.inputs[i].witnessScript!,
      utxos[i].value,
      sighash
    );
    const signature = await requestBtcSignature(
      nearAccount,
      hash.toString("hex"),
      derivationPath
    );
    psbt.finalizeInput(i, /* custom finalizer with MPC signature */);
  }

  const rawTx = psbt.extractTransaction().toHex();
  return broadcastBitcoin(rawTx);
}

מקרי שימוש

DeFi אומני-שרשרת. dApp על NEAR המנהל עמדות ב-Ethereum AAVE, Uniswap, GMX ללא גשר. המשתמש מתקשר רק עם NEAR (זול, מהיר), חתימות שרשרת מבצעות פעולות על Ethereum.

בוט חיסול בין-שרשרתי. ניטור עמדות במספר שרשרות, חיסול אוטומטי באמצעות חתימות שרשרת לחתימת עסקאות ללא טעינת ETH מראש בכתובות מבצע.

ניהול תיק רב-שרשרתי. ניהול נכסים ב-Ethereum, Bitcoin, Solana מחשבון NEAR אחד.

החלפות אטומיות ללא גשר. ETH ↔ BTC ללא בורסה מרכזית, עם ערבויות על-שרשרת באמצעות HTLC + חתימות שרשרת.

השוואה: חתימות שרשרת מול גשרי L2

חתימות שרשרת מהירות וזולות פי 3-5 להחלפות אטומיות בין שרשרות.

מגבלות ובשלות

פתרון זה הוא מוצר חדש יחסית (mainnet הושק). בשלות התשתית נמוכה יותר מ-Axelar או LayerZero. השהיית MPC: חתימה אורכת 3-5 שניות. עלות: כל בקשת חתימה עולה ~0.1 NEAR + גז.

מחסנית טכנולוגית

• Frontend: React + near-api-js
• חוזים חכמים של NEAR: Rust (near-sdk-rs) או TypeScript (near-sdk-js)
• אינטראקציות עם שרשרת היעד: ethers.js, bitcoinjs-lib, @solana/web3.js
• חוזה MPC: v1.signer.near (mainnet), v1.signer-prod.testnet (testnet)

למה לבחור בחתימות שרשרת לפרויקט שלך?

אם המשימה שלך היא DeFi אומני-שרשרת, תיק רב-שרשרתי, או אוטומציה ללא גשרים, הפרוטוקול מציע יתרונות: נקודת שליטה אחת, השהיה נמוכה, והפחתת עלות תשתית פי 3. נבחן את התרחיש שלך בשלב פיילוט—צור קשר.

מה כלול באינטגרציה

• תכנון ארכיטקטוני ובחירת נתיבי גזירה
• קוד TypeScript בצד הלקוח עבור Ethereum, Bitcoin, Solana
• הגדרת חוזה MPC וניהול תקציב גז
• תיעוד על טיפול בשגיאות ואסטרטגיות גיבוי
• בדיקות על testnet ו-mainnet
• תמיכה תפעולית בשלב ההפעלה

לוחות זמנים

• חשבון NEAR + זרימת חתימות שרשרת בסיסית: 2-3 שבועות
• אינטגרציית Ethereum (עסקאות + ERC-20): +1-2 שבועות
• תמיכה ב-Bitcoin: +2-3 שבועות
• dApp אומני-שרשרת מלא: 2-3 חודשים

לצוות שלנו 5 שנות ניסיון בלוקצ'יין ויותר מ-10 פרויקטים מיושמים. צור קשר להערכה חינמית של התרחיש שלך—נעזור לקבוע אם הטכנולוגיה מתאימה למשימה שלך.