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

package/dist/index.js

@@ -6957,11 +6957,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
     }));
   }
   /**
@@ -10875,6 +10875,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:
@@ -10893,13 +11251,21 @@ var KeypairSigner = class {
 
 exports.AccountMetaTable = AccountMetaTable;
 exports.BASE_DERIVATION_PATH = BASE_DERIVATION_PATH;
+exports.BUFFER_BALANCE_FACTOR = BUFFER_BALANCE_FACTOR;
 exports.BaseRpcClient = BaseRpcClient;
 exports.BincodeReader = BincodeReader;
 exports.BincodeWriter = BincodeWriter;
 exports.CHACHA20_POLY1305_TAG_LENGTH = CHACHA20_POLY1305_TAG_LENGTH;
 exports.CryptoError = CryptoError;
 exports.CryptoErrorCode = CryptoErrorCode;
+exports.DEFAULT_CHUNK_SIZE = DEFAULT_CHUNK_SIZE;
+exports.DEFAULT_CONFIRMATION_BATCH_SIZE = DEFAULT_CONFIRMATION_BATCH_SIZE;
+exports.DEFAULT_MAX_RETRIES = DEFAULT_MAX_RETRIES2;
 exports.DEFAULT_NUM_ACCOUNTS = DEFAULT_NUM_ACCOUNTS;
+exports.DEFAULT_RETRY_BASE_DELAY_MS = DEFAULT_RETRY_BASE_DELAY_MS;
+exports.DEFAULT_RETRY_MAX_DELAY_MS = DEFAULT_RETRY_MAX_DELAY_MS;
+exports.DeploymentError = DeploymentError;
+exports.DeploymentErrorCode = DeploymentErrorCode;
 exports.ED25519_PUBLIC_KEY_LENGTH = ED25519_PUBLIC_KEY_LENGTH;
 exports.HPKE_ENC_LENGTH = HPKE_ENC_LENGTH;
 exports.HPKE_OVERHEAD_LENGTH = HPKE_OVERHEAD_LENGTH;
@@ -10909,20 +11275,25 @@ exports.HttpTransport = HttpTransport;
 exports.KELVIN_PER_RLO = KELVIN_PER_RLO;
 exports.Keypair = Keypair;
 exports.KeypairSigner = KeypairSigner;
+exports.LOADER_V4_PROGRAM_ID = LOADER_V4_PROGRAM_ID;
 exports.Message = Message;
 exports.Mnemonic = Mnemonic;
+exports.PROGRAM_DATA_OFFSET = PROGRAM_DATA_OFFSET;
 exports.PUBLIC_KEY_LENGTH = PUBLIC_KEY_LENGTH;
+exports.ProgramDeployment = ProgramDeployment;
 exports.PublicKey = PublicKey;
 exports.QueryRpcClient = QueryRpcClient;
 exports.RIALO_DEVNET_CHAIN = RIALO_DEVNET_CHAIN;
 exports.RIALO_LOCALNET_CHAIN = RIALO_LOCALNET_CHAIN;
 exports.RIALO_MAINNET_CHAIN = RIALO_MAINNET_CHAIN;
 exports.RIALO_TESTNET_CHAIN = RIALO_TESTNET_CHAIN;
+exports.RISCV_LOADER_PROGRAM_ID = RISCV_LOADER_PROGRAM_ID;
 exports.RexValue = RexValue;
 exports.RexValueVariant = RexValueVariant;
 exports.RialoClient = RialoClient;
 exports.RialoError = RialoError;
 exports.RialoErrorType = RialoErrorType;
+exports.RiscVLoaderInstruction = RiscVLoaderInstruction;
 exports.RpcError = RpcError;
 exports.RpcErrorCode = RpcErrorCode;
 exports.SECRET_KEY_LENGTH = SECRET_KEY_LENGTH;
@@ -10950,6 +11321,7 @@ exports.concatBytes = concatBytes2;
 exports.createAccount = createAccount;
 exports.createBorshInstruction = createBorshInstruction;
 exports.createRialoClient = createRialoClient;
+exports.deployInstruction = deployInstruction;
 exports.deserialize = deserialize;
 exports.deserializeBorsh = deserializeBorsh;
 exports.deserializeCompactU16 = deserializeCompactU162;
@@ -10969,14 +11341,17 @@ exports.hpkeEncrypt = hpkeEncrypt;
 exports.isOnCurve = isOnCurve;
 exports.isValidCiphertextLength = isValidCiphertextLength;
 exports.option = option;
+exports.retractInstruction = retractInstruction;
 exports.seedToBytes = seedToBytes;
 exports.serialize = serialize;
 exports.serializeBorsh = serializeBorsh;
 exports.serializeCompactU16 = serializeCompactU16;
+exports.setProgramLengthInstruction = setProgramLengthInstruction;
 exports.sleep = sleep;
 exports.toBase64 = toBase64;
 exports.transferInstruction = transferInstruction;
 exports.vec = vec;
 exports.writeCompactU16 = writeCompactU16;
+exports.writeInstruction = writeInstruction;
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map