Hedera
Search…
Schedule Your First Transaction

Summary

In this tutorial, you'll learn how to create and sign a scheduled transaction. Scheduled Transactions enable multiple parties to easily, inexpensively, and natively schedule and execute any type of Hedera transaction together. Once a transaction is scheduled, additional signatures can be submitted via a ScheduleSign transaction. After the last signature is received within the allotted timeframe, the scheduled transaction will execute
We recommend you complete the following introduction to get a basic understanding of Hedera transactions. This example does not build upon the previous examples.

1. Create a transaction to schedule

First, you will need to build the transaction to schedule. In the example below, you will create a transfer transaction. The sender account has a threshold key structure that requires 2 out of the 3 keys to sign the transaction to authorize the transfer amount.
Java
JavaScript
Go
1
//Create a transaction to schedule
2
TransferTransaction transaction = new TransferTransaction()
3
.addHbarTransfer(senderAccount, Hbar.fromTinybars(-1))
4
.addHbarTransfer(recipientAccount, Hbar.fromTinybars(1));
Copied!
1
//Create a transaction to schedule
2
const transaction = new TransferTransaction()
3
.addHbarTransfer(senderAccount, Hbar.fromTinybars(-1))
4
.addHbarTransfer(recipientAccount, Hbar.fromTinybars(1));
Copied!
1
//Create a transaction to schedule
2
transaction := hedera.NewTransferTransaction().
3
AddHbarTransfer(senderAccount, hedera.HbarFromTinybar(-1)).
4
AddHbarTransfer(recipientAccount, hedera.HbarFromTinybar(1))
5
Copied!

2. Schedule the transfer transaction

Next, you will schedule the transfer transaction by submitting a ScheduleCreate transaction to the network. Once the transfer transaction is scheduled, you can obtain the schedule ID from the receipt of the ScheduleCreate transaction. The schedule ID identifies the schedule that scheduled the transfer transaction.The schedule ID can be shared with the three signatories. The schedule is immutable unless the admin key is specified during creation.
The scheduled transaction ID of the transfer transaction can also be returned from the receipt of the ScheduleCreate transaction. You will notice that the transaction ID for a scheduled transaction includes a ?scheduled flag e.g. [email protected]?scheduled. All transactions that have been scheduled will include this flag.
You can optionally add signatures you may have during the creation of the ScheduleCreate transaction by calling .freezeWith(client) and .sign() methods. This might make sense if you are one of the required signatures for the scheduled transaction.
Visit the page below to view additional properties that can be set when building a ScheduleCreate transaction.
Java
JavaScript
Go
1
//Schedule a transaction
2
TransactionResponse scheduleTransaction = new ScheduleCreateTransaction()
3
.setScheduledTransaction(transaction)
4
.execute(client);
5
​
6
//Get the receipt of the transaction
7
TransactionReceipt receipt = scheduleTransaction.getReceipt(client);
8
9
//Get the schedule ID
10
ScheduleId scheduleId = receipt.scheduleId;
11
System.out.println("The schedule ID is " +scheduleId);
12
​
13
//Get the scheduled transaction ID
14
TransactionId scheduledTxId = receipt.scheduledTransactionId;
15
System.out.println("The scheduled transaction ID is " +scheduledTxId);
Copied!
1
//Schedule a transaction
2
const scheduleTransaction = await new ScheduleCreateTransaction()
3
.setScheduledTransaction(transaction)
4
.execute(client);
5
​
6
//Get the receipt of the transaction
7
const receipt = await scheduleTransaction.getReceipt(client);
8
9
//Get the schedule ID
10
const scheduleId = receipt.scheduleId;
11
console.log("The schedule ID is " +scheduleId);
12
​
13
//Get the scheduled transaction ID
14
const scheduledTxId = receipt.scheduledTransactionId;
15
console.log("The scheduled transaction ID is " +scheduledTxId);
Copied!
1
//Schedule a transaction
2
scheduleTransaction, err := hedera.NewScheduleCreateTransaction().
3
SetScheduledTransaction(transaction)
4
if err != nil {
5
panic(err)
6
}
7
​
8
submitScheduleTx, err := scheduleTransaction.Execute(client)
9
if err != nil {
10
panic(err)
11
}
12
​
13
//Get the receipt of the transaction
14
receipt, err := submitScheduleTx.GetReceipt(client)
15
if err != nil {
16
panic(err)
17
}
18
19
//Get the schedule ID
20
scheduleId := receipt.ScheduleID
21
fmt.Printf("The schedule ID %v\n", scheduleId)
22
​
23
//Get the scheduled transaction ID
24
scheduleTxId := receipt1.ScheduledTransactionID
25
fmt.Printf("The scheduled transaction ID is %v\n", scheduleTxId)
Copied!

3. Submit one of the required signatures for the transfer transaction

The signatures are submitted to the network via a ScheduleSign transaction. The ScheduleSign transaction requires the schedule ID of the schedule and the signature of one or more of the required keys. The scheduled transaction has 30 minutes from the time it is scheduled to receive all of its signatures; if the signature requirements are not met, the scheduled transaction will expire.
In the example below, you will submit one signature, confirm the transaction was successful, and get the schedule info to verify the signature was added to the schedule. To verify the signature was added, you can compare the public key of the submitted signature to the public key that is returned from the schedule info request.
Java
JavaScript
Go
1
//Submit the first signatures
2
TransactionResponse signature1 = new ScheduleSignTransaction()
3
.setScheduleId(scheduleId)
4
.freezeWith(client)
5
.sign(signerKey1)
6
.execute(client);
7
8
//Verify the transaction was successful and submit a schedule info request
9
TransactionReceipt receipt1 = signature1.getReceipt(client);
10
System.out.println("The transaction status is " +receipt1.status);
11
​
12
ScheduleInfo query1 = new ScheduleInfoQuery()
13
.setScheduleId(scheduleId)
14
.execute(client);
15
​
16
//Confirm the signature was added to the schedule
17
System.out.println(query1);
Copied!
1
//Submit the first signature
2
const signature1 = await (await new ScheduleSignTransaction()
3
.setScheduleId(scheduleId)
4
.freezeWith(client)
5
.sign(signerKey1))
6
.execute(client);
7
8
//Verify the transaction was successful and submit a schedule info request
9
const receipt1 = await signature1.getReceipt(client);
10
console.log("The transaction status is " +receipt1.status.toString());
11
​
12
const query1 = await new ScheduleInfoQuery()
13
.setScheduleId(scheduleId)
14
.execute(client);
15
​
16
//Confirm the signature was added to the schedule
17
console.log(query1);
Copied!
1
//Submit the first signature
2
signature1, err := hedera.NewScheduleSignTransaction().
3
SetScheduleID(scheduleId).
4
FreezeWith(client)
5
if err != nil {
6
panic(err)
7
}
8
​
9
//Verify the transaction was successful and submit a schedule info request
10
submitTx, err := signature1.Sign(signerKey1).Execute(client)
11
if err != nil {
12
panic(err)
13
}
14
​
15
receipt1, err := submitTx.GetReceipt(client)
16
if err != nil {
17
panic(err)
18
}
19
​
20
status := receipt1.Status
21
​
22
fmt.Printf("The transaction status is %v\n", status)
23
​
24
query1, err := hedera.NewScheduleInfoQuery().
25
SetScheduleID(scheduleId).
26
Execute(client)
27
28
//Confirm the signature was added to the schedule
29
fmt.Print(query1)
Copied!

4. Submit the second signature

Next, you will submit the second signature and verify the transaction was successful by requesting the receipt. For example purposes, you have access to all three signing keys. But the idea here is that each signer can independently submit their signature to the network.
Java
JavaScript
Go
Java
1
//Submit the second signature
2
TransactionResponse signature2 = new ScheduleSignTransaction()
3
.setScheduleId(scheduleId)
4
.freezeWith(client)
5
.sign(signerKey2)
6
.execute(client);
7
8
//Verify the transaction was successful
9
TransactionReceipt receipt2 = signature2.getReceipt(client);
10
System.out.println("The transaction status" +receipt2.status);
Copied!
1
//Submit the second signature
2
const signature2 = await (await new ScheduleSignTransaction()
3
.setScheduleId(scheduleId)
4
.freezeWith(client)
5
.sign(signerKey2))
6
.execute(client);
7
8
//Verify the transaction was successful
9
const receipt2 = await signature2.getReceipt(client);
10
console.log("The transaction status " +receipt2.status.toString());
Copied!
1
//Submit the second signature
2
signature2, err := hedera.NewScheduleSignTransaction().
3
SetScheduleID(scheduleId).
4
FreezeWith(client)
5
if err != nil {
6
panic(err)
7
}
8
​
9
//Verify the transaction was successful and submit a schedule info request
10
submitTx2, err := signature2.Sign(signerKey2).Execute(client)
11
if err != nil {
12
panic(err)
13
}
14
​
15
receipt2, err := submitTx2.GetReceipt(client)
16
if err != nil {
17
panic(err)
18
}
19
​
20
status2 := receipt2.Status
21
​
22
fmt.Printf("The transaction status is %v\n", status2)
Copied!

5. Verify the schedule was triggered

The schedule is triggered after it meets its minimum signing requirements. As soon as the last required signature is submitted, the schedule executes the scheduled transaction. To verify the schedule was triggered, query for the schedule info. When the schedule info is returned, you should notice both public keys that signed in the signatories field and the timestamp recorded for when the schedule transaction was executed in the executedAt field.
Java
JavaScript
Go
1
//Get the schedule info
2
ScheduleInfo query2 = new ScheduleInfoQuery()
3
.setScheduleId(scheduleId)
4
.execute(client);
5
6
System.out.println(query2);
Copied!
1
//Get the schedule info
2
const query2 = await new ScheduleInfoQuery()
3
.setScheduleId(scheduleId)
4
.execute(client);
5
6
console.log(query2);
Copied!
1
//Get the schedule info
2
query2, err := hedera.NewScheduleInfoQuery().
3
SetScheduleID(scheduleId).
4
Execute(client)
5
​
6
fmt.Print(query2)
Copied!

6. Verify the scheduled transaction executed

When the scheduled transaction (transfer transaction) executes a record is produced that contains the transaction details. The scheduled transaction record can be requested immediately after the transaction has executed and includes the corresponding schedule ID. If you do not know when the scheduled transaction will execute, you can always query a mirror node using the scheduled transaction ID without the ?scheduled flag to get a copy of the transaction record.
Java
JavaScript
Go
1
//Get the scheduled transaction record
2
TransactionRecord scheduledTxRecord = TransactionId.fromString(scheduledTxId.toString()).getRecord(client);
3
System.out.println("The scheduled transaction record is: " +scheduledTxRecord);
Copied!
1
//Get the scheduled transaction record
2
const scheduledTxRecord = await TransactionId.fromString(scheduledTxId.toString()).getRecord(client);
3
console.log("The scheduled transaction record is: " +scheduledTxRecord);
Copied!
1
scheduledTxRecord, err := scheduledTransactionId.GetRecord(client)
2
fmt.Printf("The scheduled transaction record is %v\n", scheduledTxRecord)
Copied!