remove staker address from bond_public

Author: christianwwwwwwww

create-leo-app/template-offline-public-transaction-ts/src/index.ts

@@ -64,7 +64,13 @@ try {
 }
 
 /// Build bonding and unbonding transactions without connection to the internet
-async function buildBondingTxOffline(stakerAddress: Address,  validatorAddress: Address, withdrawalAddress: Address, amount: number, latestStateRoot: string, keyPaths: {}): Promise<Transaction[]> {
+async function buildBondingTxOffline(
+    validatorAddress: Address, 
+    withdrawalAddress: Address, 
+    amount: number, 
+    latestStateRoot: string, 
+    keyPaths: {}
+): Promise<Transaction[]> {
     // Create an offline program manager
     const programManager = new ProgramManager();
 
@@ -87,8 +93,7 @@ async function buildBondingTxOffline(stakerAddress: Address,  validatorAddress:
     console.log("Creating offline key provider");
     const offlineKeyProvider = new OfflineKeyProvider();
 
-    // Insert the proving keys into the offline key provider. The key provider will automatically insert the verifying
-    // keys into the key manager.
+    // Insert the proving keys into the offline key provider
     console.log("Inserting proving keys into key provider");
     offlineKeyProvider.insertFeePublicKeys(feePublicProvingKey);
     offlineKeyProvider.insertBondPublicKeys(bondPublicProvingKey);
@@ -100,38 +105,48 @@ async function buildBondingTxOffline(stakerAddress: Address,  validatorAddress:
 
     // Build the bonding transactions offline
     console.log("Building a bond_public execution transaction offline");
+
+    if (!latestStateRoot) {
+        throw new Error("latestStateRoot is undefined");
+    }
+
     const bondPublicOptions = {
         keySearchParams: OfflineSearchParams.bondPublicKeyParams(),
-        offlineQuery: new OfflineQuery(latestStateRoot)
+        offlineQuery: new OfflineQuery(0, latestStateRoot)
     };
-    
+
 
     const bondTx = <Transaction>await programManager.buildBondPublicTransaction(
-        stakerAddress.to_string(),
         validatorAddress.to_string(),
         withdrawalAddress.to_string(),
         amount,
-        bondPublicOptions,
-    )
+        bondPublicOptions
+    );
+
     console.log("\nbond_public transaction built!\n");
 
-    console.log("Building an unbond_public execution transaction offline")
     const unbondPublicOptions = {
         keySearchParams: OfflineSearchParams.unbondPublicKeyParams(),
-        offlineQuery: new OfflineQuery(latestStateRoot)
+        offlineQuery: new OfflineQuery(0, latestStateRoot)
     };
 
-    const unBondTx = <Transaction>await programManager.buildUnbondPublicTransaction(stakerAddress.to_string(), amount, unbondPublicOptions);
+    const unBondTx = <Transaction>await programManager.buildUnbondPublicTransaction(
+        stakerAddress.to_string(),
+        amount,
+        unbondPublicOptions
+    );
     console.log("\nunbond_public transaction built!\n");
 
-    console.log("Building a claim_unbond_public transaction offline")
-    // Build the claim unbonding transaction offline
+    console.log("Building a claim_unbond_public transaction offline");
     const claimUnbondPublicOptions = {
         keySearchParams: OfflineSearchParams.claimUnbondPublicKeyParams(),
-        offlineQuery: new OfflineQuery(latestStateRoot)
+        offlineQuery: new OfflineQuery(0, latestStateRoot)
     };
 
-    const claimUnbondTx = <Transaction>await programManager.buildClaimUnbondPublicTransaction(stakerAddress.to_string(), claimUnbondPublicOptions);
+    const claimUnbondTx = <Transaction>await programManager.buildClaimUnbondPublicTransaction(
+        stakerAddress.to_string(),
+        claimUnbondPublicOptions
+    );
     console.log("\nclaim_unbond_public transaction built!\n");
     return [bondTx, unBondTx, claimUnbondTx];
 }
@@ -159,7 +174,7 @@ console.log(`\n---------------transfer_public transaction---------------\n${tran
 console.log(`---------------------------------------------------------`);
 
 // Build bonding & unbonding transactions
-const bondTransactions = await buildBondingTxOffline(stakerAddress, validatorAddress, withdrawalAddress, 100, latestStateRoot, bondingKeyPaths);
+const bondTransactions = await buildBondingTxOffline(validatorAddress, withdrawalAddress, 100, latestStateRoot, bondingKeyPaths);
 console.log("Bonding transactions built offline!");
 console.log(`\n-----------------bond_public transaction-----------------\n${bondTransactions[0]}`);
 console.log(`---------------------------------------------------------`);
@@ -174,4 +189,4 @@ console.log(`---------------------------------------------------------`);
 // ONLINE COMPONENT (Uncomment this part to send the transaction to the Aleo Network on an internet connected machine)
 // Submit the transaction to the network
 // const transferTxId = await networkClient.submitTransaction(transferTx);
-//---------------------------------------------------------
+//---------------------------------------------------------

sdk/src/program-manager.ts

@@ -843,7 +843,6 @@ class ProgramManager {
      * const result = await programManager.networkClient.submitTransaction(tx);
      *
      * @returns string
-     * @param {string} staker_address Address of the staker who is bonding the credits
      * @param {string} validator_address Address of the validator to bond to, if this address is the same as the staker (i.e. the
      * executor of this function), it will attempt to bond the credits as a validator. Bonding as a validator currently
      * requires a minimum of 10,000,000 credits to bond (subject to change). If the address is specified is an existing
@@ -853,15 +852,15 @@ class ProgramManager {
      * @param {number} amount The amount of credits to bond
      * @param {Partial<ExecuteOptions>} options - Override default execution options.
      */
-    async buildBondPublicTransaction(staker_address: string, validator_address: string, withdrawal_address: string, amount: number, options: Partial<ExecuteOptions> = {}) {
+    async buildBondPublicTransaction(validator_address: string, withdrawal_address: string, amount: number, options: Partial<ExecuteOptions> = {}) {
         const scaledAmount = Math.trunc(amount * 1000000);
 
         const {
             programName = "credits.aleo",
             functionName = "bond_public",
             fee = options.fee || 0.86,
             privateFee = false,
-            inputs = [staker_address, validator_address, withdrawal_address, `${scaledAmount.toString()}u64`],
+            inputs = [validator_address, withdrawal_address, `${scaledAmount.toString()}u64`],
             keySearchParams = new AleoKeyProviderParams({
                 proverUri: CREDITS_PROGRAM_KEYS.bond_public.prover,
                 verifierUri: CREDITS_PROGRAM_KEYS.bond_public.verifier,
@@ -900,7 +899,6 @@ class ProgramManager {
      * const tx_id = await programManager.bondPublic("aleo1jx8s4dvjepculny4wfrzwyhs3tlyv65r58ns3g6q2gm2esh7ps8sqy9s5j", "aleo1rhgdu77hgyqd3xjj8ucu3jj9r2krwz6mnzyd80gncr5fxcwlh5rsvzp9px", "aleo1feya8sjy9k2zflvl2dx39pdsq5tju28elnp2ektnn588uu9ghv8s84msv9", 2000000);
      *
      * @returns string
-     * @param {string} staker_address Address of the staker who is bonding the credits
      * @param {string} validator_address Address of the validator to bond to, if this address is the same as the signer (i.e. the
      * executor of this function), it will attempt to bond the credits as a validator. Bonding as a validator currently
      * requires a minimum of 1,000,000 credits to bond (subject to change). If the address is specified is an existing
@@ -910,8 +908,8 @@ class ProgramManager {
      * @param {number} amount The amount of credits to bond
      * @param {Options} options Options for the execution
      */
-    async bondPublic(staker_address: string, validator_address: string, withdrawal_address:string, amount: number, options: Partial<ExecuteOptions> = {}) {
-        const tx = <Transaction>await this.buildBondPublicTransaction(staker_address, validator_address, withdrawal_address, amount, options);
+    async bondPublic(validator_address: string, withdrawal_address:string, amount: number, options: Partial<ExecuteOptions> = {}) {
+        const tx = <Transaction>await this.buildBondPublicTransaction(validator_address, withdrawal_address, amount, options);
         return await this.networkClient.submitTransaction(tx);
     }