@rialo/ts-cdk 0.3.0-alpha.1 → 0.4.0-alpha.0

package/dist/index.mjs

@@ -6955,11 +6955,11 @@ var QueryRpcClient = class extends BaseRpcClient {
     return result.value.map((v) => ({
       commission: BigInt(v.commission),
       pubkey: v.pubkey,
-      nodeIdentity: v.node_identity,
-      authorizedWithdrawer: v.authorized_withdrawer,
-      stakeNext: BigInt(v.stake_next),
-      stakeCurrent: v.stake_current !== void 0 ? BigInt(v.stake_current) : void 0,
-      address: v.address
+      signingKey: v.signing_key,
+      withdrawalKey: v.withdrawal_key,
+      stake: BigInt(v.stake),
+      address: v.address,
+      stateSyncAddress: v.state_sync_address
     }));
   }
   /**
@@ -10873,6 +10873,364 @@ var KeypairSigner = class {
     return this.keypair.sign(message);
   }
 };
+
+// src/program/constants.ts
+var RISCV_LOADER_PROGRAM_ID = "RiscVLoader11111111111111111111111111111111";
+var LOADER_V4_PROGRAM_ID = "LoaderV411111111111111111111111111111111111";
+var DEFAULT_CHUNK_SIZE = 3700;
+var DEFAULT_MAX_RETRIES2 = 350;
+var DEFAULT_RETRY_BASE_DELAY_MS = 50;
+var DEFAULT_RETRY_MAX_DELAY_MS = 1e3;
+var DEFAULT_CONFIRMATION_BATCH_SIZE = 25;
+var BUFFER_BALANCE_FACTOR = 1.2;
+var PROGRAM_DATA_OFFSET = 48;
+
+// src/program/deployment.ts
+init_base();
+
+// src/program/errors.ts
+var DeploymentErrorCode = /* @__PURE__ */ ((DeploymentErrorCode2) => {
+  DeploymentErrorCode2["EMPTY_PROGRAM_DATA"] = "EMPTY_PROGRAM_DATA";
+  DeploymentErrorCode2["INVALID_CHUNK_SIZE"] = "INVALID_CHUNK_SIZE";
+  DeploymentErrorCode2["OWNER_MISMATCH"] = "OWNER_MISMATCH";
+  DeploymentErrorCode2["TRANSACTION_FAILED"] = "TRANSACTION_FAILED";
+  DeploymentErrorCode2["TRANSACTION_TIMEOUT"] = "TRANSACTION_TIMEOUT";
+  DeploymentErrorCode2["RPC_ERROR"] = "RPC_ERROR";
+  DeploymentErrorCode2["BUFFER_NOT_READY"] = "BUFFER_NOT_READY";
+  return DeploymentErrorCode2;
+})(DeploymentErrorCode || {});
+var DeploymentError = class _DeploymentError extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "DeploymentError";
+  }
+  static emptyProgramData() {
+    return new _DeploymentError(
+      "EMPTY_PROGRAM_DATA" /* EMPTY_PROGRAM_DATA */,
+      "Program data must not be empty."
+    );
+  }
+  static invalidChunkSize(chunkSize) {
+    return new _DeploymentError(
+      "INVALID_CHUNK_SIZE" /* INVALID_CHUNK_SIZE */,
+      `chunkSize must be greater than 0, got ${chunkSize}.`,
+      { chunkSize }
+    );
+  }
+  static ownerMismatch(owner) {
+    return new _DeploymentError(
+      "OWNER_MISMATCH" /* OWNER_MISMATCH */,
+      `Existing account is not owned by RISC-V Loader (owner: ${owner}).`,
+      { owner }
+    );
+  }
+  static transactionFailed(err2, details) {
+    return new _DeploymentError(
+      "TRANSACTION_FAILED" /* TRANSACTION_FAILED */,
+      `Transaction failed: ${err2}`,
+      details
+    );
+  }
+  static transactionTimeout(message, details) {
+    return new _DeploymentError(
+      "TRANSACTION_TIMEOUT" /* TRANSACTION_TIMEOUT */,
+      `Transaction confirmation timed out: ${message}`,
+      details
+    );
+  }
+  static rpcError(message, details) {
+    return new _DeploymentError(
+      "RPC_ERROR" /* RPC_ERROR */,
+      `RPC error during deployment: ${message}`,
+      details
+    );
+  }
+  static bufferNotReady(maxRetries) {
+    return new _DeploymentError(
+      "BUFFER_NOT_READY" /* BUFFER_NOT_READY */,
+      `Buffer account not ready after ${maxRetries} attempts.`,
+      { maxRetries }
+    );
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.message,
+      details: this.details
+    };
+  }
+};
+
+// src/program/instructions.ts
+var RiscVLoaderInstruction = /* @__PURE__ */ ((RiscVLoaderInstruction2) => {
+  RiscVLoaderInstruction2[RiscVLoaderInstruction2["Write"] = 0] = "Write";
+  RiscVLoaderInstruction2[RiscVLoaderInstruction2["Copy"] = 1] = "Copy";
+  RiscVLoaderInstruction2[RiscVLoaderInstruction2["SetProgramLength"] = 2] = "SetProgramLength";
+  RiscVLoaderInstruction2[RiscVLoaderInstruction2["Deploy"] = 3] = "Deploy";
+  RiscVLoaderInstruction2[RiscVLoaderInstruction2["Retract"] = 4] = "Retract";
+  RiscVLoaderInstruction2[RiscVLoaderInstruction2["TransferAuthority"] = 5] = "TransferAuthority";
+  RiscVLoaderInstruction2[RiscVLoaderInstruction2["Finalize"] = 6] = "Finalize";
+  return RiscVLoaderInstruction2;
+})(RiscVLoaderInstruction || {});
+var LOADER_PROGRAM_ID = PublicKey.fromString(RISCV_LOADER_PROGRAM_ID);
+function writeInstruction(programAddress, authority, offset, bytes2) {
+  const writer = new BincodeWriter(4 + 4 + 8 + bytes2.length);
+  writer.writeVariant(0 /* Write */);
+  writer.writeU32(offset);
+  writer.writeVecBytes(bytes2);
+  return {
+    programId: LOADER_PROGRAM_ID,
+    accounts: [
+      { pubkey: programAddress, isSigner: false, isWritable: true },
+      { pubkey: authority, isSigner: true, isWritable: false }
+    ],
+    data: writer.toBytes()
+  };
+}
+function setProgramLengthInstruction(programAddress, authority, newSize, recipientAddress) {
+  const writer = new BincodeWriter(8);
+  writer.writeVariant(2 /* SetProgramLength */);
+  writer.writeU32(newSize);
+  return {
+    programId: LOADER_PROGRAM_ID,
+    accounts: [
+      { pubkey: programAddress, isSigner: false, isWritable: true },
+      { pubkey: authority, isSigner: true, isWritable: false },
+      { pubkey: recipientAddress, isSigner: false, isWritable: true }
+    ],
+    data: writer.toBytes()
+  };
+}
+function deployInstruction(programAddress, authority) {
+  const writer = new BincodeWriter(4);
+  writer.writeVariant(3 /* Deploy */);
+  return {
+    programId: LOADER_PROGRAM_ID,
+    accounts: [
+      { pubkey: programAddress, isSigner: false, isWritable: true },
+      { pubkey: authority, isSigner: true, isWritable: false }
+    ],
+    data: writer.toBytes()
+  };
+}
+function retractInstruction(programAddress, authority) {
+  const writer = new BincodeWriter(4);
+  writer.writeVariant(4 /* Retract */);
+  return {
+    programId: LOADER_PROGRAM_ID,
+    accounts: [
+      { pubkey: programAddress, isSigner: false, isWritable: true },
+      { pubkey: authority, isSigner: true, isWritable: false }
+    ],
+    data: writer.toBytes()
+  };
+}
+
+// src/program/deployment.ts
+function calculateBackoff2(attempt, baseDelayMs, maxDelayMs) {
+  const delay = baseDelayMs * 1.15 ** attempt;
+  return Math.min(delay, maxDelayMs);
+}
+var ProgramDeployment = class {
+  programData;
+  programKeypair;
+  chunkSize;
+  maxRetries;
+  retryBaseDelayMs;
+  retryMaxDelayMs;
+  confirmationBatchSize;
+  constructor(options) {
+    if (options.programData.length === 0) {
+      throw DeploymentError.emptyProgramData();
+    }
+    this.programData = options.programData;
+    this.programKeypair = options.programKeypair;
+    const chunkSize = options.config?.chunkSize ?? DEFAULT_CHUNK_SIZE;
+    if (chunkSize <= 0) {
+      throw DeploymentError.invalidChunkSize(chunkSize);
+    }
+    this.chunkSize = chunkSize;
+    this.maxRetries = options.config?.maxRetries ?? DEFAULT_MAX_RETRIES2;
+    this.retryBaseDelayMs = options.config?.retryBaseDelayMs ?? DEFAULT_RETRY_BASE_DELAY_MS;
+    this.retryMaxDelayMs = options.config?.retryMaxDelayMs ?? DEFAULT_RETRY_MAX_DELAY_MS;
+    this.confirmationBatchSize = options.config?.confirmationBatchSize ?? DEFAULT_CONFIRMATION_BATCH_SIZE;
+  }
+  /**
+   * Deploy the program to the blockchain.
+   *
+   * @param client - RPC client
+   * @param payerKeypair - Keypair that pays for transactions and becomes the program authority
+   * @returns The program's public key (derived from programKeypair)
+   */
+  async deploy(client, payerKeypair) {
+    const programPubkey = this.programKeypair.publicKey;
+    const payerPubkey = payerKeypair.publicKey;
+    const loaderPubkey = PublicKey.fromString(RISCV_LOADER_PROGRAM_ID);
+    const configHashPrefix = await client.getConfigHashPrefix();
+    const rentExempt = await client.getMinimumBalanceForRentExemption(
+      BigInt(PROGRAM_DATA_OFFSET + this.programData.length)
+    );
+    const bufferBalance = BigInt(Math.floor(Number(rentExempt) * BUFFER_BALANCE_FACTOR));
+    const validFrom = BigInt(Date.now());
+    const existing = await client.getAccountInfo(programPubkey).catch((e) => {
+      if (e instanceof Error && e.message.startsWith("Account does not exist")) {
+        return null;
+      }
+      throw e;
+    });
+    if (existing) {
+      if (existing.owner.toString() !== RISCV_LOADER_PROGRAM_ID) {
+        throw DeploymentError.ownerMismatch(existing.owner.toString());
+      }
+      const ixs = [];
+      if (existing.kelvin < bufferBalance) {
+        const deficit = bufferBalance - existing.kelvin;
+        ixs.push(transferInstruction(payerPubkey, programPubkey, deficit));
+      }
+      if (existing.executable) {
+        ixs.push(retractInstruction(programPubkey, payerPubkey));
+      }
+      ixs.push(
+        setProgramLengthInstruction(
+          programPubkey,
+          payerPubkey,
+          this.programData.length,
+          payerPubkey
+        )
+      );
+      const builder = TransactionBuilder.create().setPayer(payerPubkey).setValidFrom(validFrom).setConfigHashPrefix(configHashPrefix);
+      for (const ix of ixs) {
+        builder.addInstruction(ix);
+      }
+      const tx = builder.build().sign(payerKeypair);
+      await this.sendAndConfirm(client, tx.serialize());
+    } else {
+      const createIx = createAccount(
+        payerPubkey,
+        programPubkey,
+        bufferBalance,
+        0n,
+        // space=0, the loader manages sizing via SetProgramLength
+        loaderPubkey
+      );
+      const setLengthIx = setProgramLengthInstruction(
+        programPubkey,
+        payerPubkey,
+        this.programData.length,
+        payerPubkey
+      );
+      const tx = TransactionBuilder.create().setPayer(payerPubkey).setValidFrom(validFrom).setConfigHashPrefix(configHashPrefix).addInstruction(createIx).addInstruction(setLengthIx).build().signAll([payerKeypair, this.programKeypair]);
+      await this.sendAndConfirm(client, tx.serialize());
+    }
+    await this.waitForBufferReady(client, programPubkey);
+    const chunks = this.splitIntoChunks(this.programData);
+    const batchSignatures = [];
+    for (let i = 0; i < chunks.length; i++) {
+      const offset = i * this.chunkSize;
+      const ix = writeInstruction(programPubkey, payerPubkey, offset, chunks[i]);
+      const chunkValidFrom = BigInt(Date.now());
+      const tx = TransactionBuilder.create().setPayer(payerPubkey).setValidFrom(chunkValidFrom).setConfigHashPrefix(configHashPrefix).addInstruction(ix).build().sign(payerKeypair);
+      let sig;
+      try {
+        sig = await client.sendTransaction(tx.serialize());
+      } catch (e) {
+        throw this.toDeploymentError(e);
+      }
+      batchSignatures.push(base58.encode(sig));
+      const isBatchComplete = batchSignatures.length >= this.confirmationBatchSize;
+      const isLastChunk = i === chunks.length - 1;
+      if (isBatchComplete || isLastChunk) {
+        await this.confirmBatch(client, batchSignatures);
+        batchSignatures.length = 0;
+      }
+    }
+    const deployIx = deployInstruction(programPubkey, payerPubkey);
+    const deployValidFrom = BigInt(Date.now());
+    const deployTx = TransactionBuilder.create().setPayer(payerPubkey).setValidFrom(deployValidFrom).setConfigHashPrefix(configHashPrefix).addInstruction(deployIx).build().sign(payerKeypair);
+    await this.sendAndConfirm(client, deployTx.serialize());
+    return programPubkey;
+  }
+  splitIntoChunks(data) {
+    const chunks = [];
+    for (let offset = 0; offset < data.length; offset += this.chunkSize) {
+      chunks.push(data.subarray(offset, offset + this.chunkSize));
+    }
+    return chunks;
+  }
+  async sendAndConfirm(client, transaction) {
+    let result;
+    try {
+      result = await client.sendAndConfirmTransaction(transaction, {
+        confirmMaxRetries: this.maxRetries,
+        confirmRetryDelayMs: this.retryBaseDelayMs
+      });
+    } catch (e) {
+      throw this.toDeploymentError(e);
+    }
+    if (!result.executed) {
+      throw DeploymentError.transactionFailed(result.err ?? "unknown error");
+    }
+  }
+  async confirmBatch(client, signatures) {
+    let results;
+    try {
+      results = await Promise.all(
+        signatures.map((sig) => client.confirmTransaction(sig, {
+          maxRetries: this.maxRetries,
+          retryDelayMs: this.retryBaseDelayMs
+        }))
+      );
+    } catch (e) {
+      throw this.toDeploymentError(e);
+    }
+    for (const result of results) {
+      if (!result.executed) {
+        throw DeploymentError.transactionFailed(result.err ?? "unknown error", {
+          signature: result.signature
+        });
+      }
+    }
+  }
+  toDeploymentError(e) {
+    if (e instanceof DeploymentError) return e;
+    if (e instanceof RpcError) {
+      const details = { rpcCode: e.code, retryable: e.retryable, ...e.details };
+      switch (e.code) {
+        case "TRANSACTION_CONFIRMATION_TIMEOUT" /* TRANSACTION_CONFIRMATION_TIMEOUT */:
+          return DeploymentError.transactionTimeout(e.message, details);
+        case "TRANSACTION_REJECTED" /* TRANSACTION_REJECTED */:
+        case "INSUFFICIENT_FUNDS" /* INSUFFICIENT_FUNDS */:
+          return DeploymentError.transactionFailed(e.message, details);
+        default:
+          return DeploymentError.rpcError(e.message, details);
+      }
+    }
+    const message = e instanceof Error ? e.message : String(e);
+    return DeploymentError.rpcError(message, {
+      cause: e instanceof Error ? e.constructor.name : void 0
+    });
+  }
+  async waitForBufferReady(client, programPubkey) {
+    const expectedSize = PROGRAM_DATA_OFFSET + this.programData.length;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        const account = await client.getAccountInfo(programPubkey);
+        if (account.owner.toString() === RISCV_LOADER_PROGRAM_ID && account.space >= BigInt(expectedSize)) {
+          return;
+        }
+      } catch (e) {
+        if (!(e instanceof Error && e.message.startsWith("Account does not exist"))) {
+          throw e;
+        }
+      }
+      const delay = calculateBackoff2(attempt, this.retryBaseDelayMs, this.retryMaxDelayMs);
+      await sleep(delay);
+    }
+    throw DeploymentError.bufferNotReady(this.maxRetries);
+  }
+};
 /*! Bundled license information:
 
 @scure/base/index.js:
@@ -10889,6 +11247,6 @@ var KeypairSigner = class {
   (*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) *)
 */
 
-export { AccountMetaTable, BASE_DERIVATION_PATH, BaseRpcClient, BincodeReader, BincodeWriter, CHACHA20_POLY1305_TAG_LENGTH, CryptoError, CryptoErrorCode, DEFAULT_NUM_ACCOUNTS, ED25519_PUBLIC_KEY_LENGTH, HPKE_ENC_LENGTH, HPKE_OVERHEAD_LENGTH, HpkeError, HpkeErrorCode, HttpTransport, KELVIN_PER_RLO, Keypair, KeypairSigner, Message, Mnemonic, PUBLIC_KEY_LENGTH, PublicKey, QueryRpcClient, RIALO_DEVNET_CHAIN, RIALO_LOCALNET_CHAIN, RIALO_MAINNET_CHAIN, RIALO_TESTNET_CHAIN, RexValue, RexValueVariant, RialoClient, RialoError, RialoErrorType, RpcError, RpcErrorCode, SECRET_KEY_LENGTH, SECRET_SHARING_HPKE_INFO, SIGNATURE_LENGTH, SYSTEM_PROGRAM_ID, Schema, Signature, SystemInstruction, Transaction, TransactionBuilder, TransactionError, TransactionErrorCode, TransactionRpcClient, URL_DEVNET, URL_LOCALNET, URL_MAINNET, URL_TESTNET, USER_SECRET_AAD, X25519_PUBLIC_KEY_LENGTH, allocateInstruction, assignInstruction, calculateBackoff, concatBytes2 as concatBytes, createAccount, createBorshInstruction, createRialoClient, deserialize, deserializeBorsh, deserializeCompactU162 as deserializeCompactU16, deserializeStrict, encodeBorshData, encryptForRex, field, fixedArray, fromBase64, getCiphertextLength, getDefaultRialoClientConfig, getDevnetUrl, getLocalnetUrl, getMainnetUrl, getTestnetUrl, hpkeEncrypt, isOnCurve, isValidCiphertextLength, option, seedToBytes, serialize, serializeBorsh, serializeCompactU16, sleep, toBase64, transferInstruction, vec, writeCompactU16 };
+export { AccountMetaTable, BASE_DERIVATION_PATH, BUFFER_BALANCE_FACTOR, BaseRpcClient, BincodeReader, BincodeWriter, CHACHA20_POLY1305_TAG_LENGTH, CryptoError, CryptoErrorCode, DEFAULT_CHUNK_SIZE, DEFAULT_CONFIRMATION_BATCH_SIZE, DEFAULT_MAX_RETRIES2 as DEFAULT_MAX_RETRIES, DEFAULT_NUM_ACCOUNTS, DEFAULT_RETRY_BASE_DELAY_MS, DEFAULT_RETRY_MAX_DELAY_MS, DeploymentError, DeploymentErrorCode, ED25519_PUBLIC_KEY_LENGTH, HPKE_ENC_LENGTH, HPKE_OVERHEAD_LENGTH, HpkeError, HpkeErrorCode, HttpTransport, KELVIN_PER_RLO, Keypair, KeypairSigner, LOADER_V4_PROGRAM_ID, Message, Mnemonic, PROGRAM_DATA_OFFSET, PUBLIC_KEY_LENGTH, ProgramDeployment, PublicKey, QueryRpcClient, RIALO_DEVNET_CHAIN, RIALO_LOCALNET_CHAIN, RIALO_MAINNET_CHAIN, RIALO_TESTNET_CHAIN, RISCV_LOADER_PROGRAM_ID, RexValue, RexValueVariant, RialoClient, RialoError, RialoErrorType, RiscVLoaderInstruction, RpcError, RpcErrorCode, SECRET_KEY_LENGTH, SECRET_SHARING_HPKE_INFO, SIGNATURE_LENGTH, SYSTEM_PROGRAM_ID, Schema, Signature, SystemInstruction, Transaction, TransactionBuilder, TransactionError, TransactionErrorCode, TransactionRpcClient, URL_DEVNET, URL_LOCALNET, URL_MAINNET, URL_TESTNET, USER_SECRET_AAD, X25519_PUBLIC_KEY_LENGTH, allocateInstruction, assignInstruction, calculateBackoff, concatBytes2 as concatBytes, createAccount, createBorshInstruction, createRialoClient, deployInstruction, deserialize, deserializeBorsh, deserializeCompactU162 as deserializeCompactU16, deserializeStrict, encodeBorshData, encryptForRex, field, fixedArray, fromBase64, getCiphertextLength, getDefaultRialoClientConfig, getDevnetUrl, getLocalnetUrl, getMainnetUrl, getTestnetUrl, hpkeEncrypt, isOnCurve, isValidCiphertextLength, option, retractInstruction, seedToBytes, serialize, serializeBorsh, serializeCompactU16, setProgramLengthInstruction, sleep, toBase64, transferInstruction, vec, writeCompactU16, writeInstruction };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map