2018-09-13 18:48:51 -07:00
|
|
|
// @flow
|
|
|
|
|
2018-11-18 08:48:14 -08:00
|
|
|
import invariant from 'assert';
|
2018-10-06 11:13:58 -07:00
|
|
|
import * as BufferLayout from 'buffer-layout';
|
2018-09-13 18:48:51 -07:00
|
|
|
import nacl from 'tweetnacl';
|
|
|
|
import bs58 from 'bs58';
|
|
|
|
|
2018-10-06 11:13:58 -07:00
|
|
|
import * as Layout from './layout';
|
2018-10-23 19:13:59 -07:00
|
|
|
import {PublicKey} from './publickey';
|
2018-09-30 18:42:45 -07:00
|
|
|
import type {Account} from './account';
|
2018-09-13 18:48:51 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @typedef {string} TransactionSignature
|
|
|
|
*/
|
|
|
|
export type TransactionSignature = string;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @typedef {string} TransactionId
|
|
|
|
*/
|
|
|
|
export type TransactionId = string;
|
|
|
|
|
2018-10-23 15:17:43 -07:00
|
|
|
/**
|
|
|
|
* List of TransactionInstruction object fields that may be initialized at construction
|
|
|
|
*
|
|
|
|
* @typedef {Object} TransactionInstructionCtorFields
|
|
|
|
* @property {?Array<PublicKey>} keys
|
|
|
|
* @property {?PublicKey} programId
|
|
|
|
* @property {?Buffer} userdata
|
|
|
|
*/
|
|
|
|
type TransactionInstructionCtorFields = {|
|
2018-11-04 11:41:21 -08:00
|
|
|
keys?: Array<PublicKey>,
|
|
|
|
programId?: PublicKey,
|
|
|
|
userdata?: Buffer,
|
2018-10-23 15:17:43 -07:00
|
|
|
|};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Transaction Instruction class
|
|
|
|
*/
|
|
|
|
export class TransactionInstruction {
|
|
|
|
/**
|
|
|
|
* Public keys to include in this transaction
|
|
|
|
*/
|
|
|
|
keys: Array<PublicKey> = [];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Program Id to execute
|
|
|
|
*/
|
|
|
|
programId: PublicKey;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Program input
|
|
|
|
*/
|
|
|
|
userdata: Buffer = Buffer.alloc(0);
|
|
|
|
|
|
|
|
constructor(opts?: TransactionInstructionCtorFields) {
|
|
|
|
opts && Object.assign(this, opts);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-09-18 12:46:59 -07:00
|
|
|
/**
|
|
|
|
* List of Transaction object fields that may be initialized at construction
|
2018-09-20 15:35:41 -07:00
|
|
|
*
|
|
|
|
* @typedef {Object} TransactionCtorFields
|
|
|
|
* @property {?number} fee
|
2018-09-18 12:46:59 -07:00
|
|
|
*/
|
|
|
|
type TransactionCtorFields = {|
|
2018-11-04 11:41:21 -08:00
|
|
|
fee?: number,
|
2018-09-18 12:46:59 -07:00
|
|
|
|};
|
|
|
|
|
2018-11-18 08:48:14 -08:00
|
|
|
/**
|
|
|
|
* @private
|
|
|
|
*/
|
|
|
|
type SignaturePubkeyPair = {|
|
|
|
|
signature: Buffer | null,
|
|
|
|
publicKey: PublicKey,
|
|
|
|
|};
|
|
|
|
|
2018-09-13 18:48:51 -07:00
|
|
|
/**
|
2018-10-23 15:17:43 -07:00
|
|
|
* Transaction class
|
2018-09-13 18:48:51 -07:00
|
|
|
*/
|
|
|
|
export class Transaction {
|
|
|
|
/**
|
2018-11-18 08:48:14 -08:00
|
|
|
* Signatures for the transaction. Typically created by invoking the
|
|
|
|
* `sign()` method one or more times.
|
2018-09-13 18:48:51 -07:00
|
|
|
*/
|
2018-11-18 08:48:14 -08:00
|
|
|
signatures: Array<SignaturePubkeyPair> = [];
|
|
|
|
|
|
|
|
/**
|
|
|
|
* The first (primary) Transaction signature
|
|
|
|
*/
|
|
|
|
get signature(): Buffer | null {
|
|
|
|
if (this.signatures.length > 0) {
|
|
|
|
return this.signatures[0].signature;
|
|
|
|
}
|
|
|
|
return null;
|
|
|
|
}
|
2018-09-13 18:48:51 -07:00
|
|
|
|
2018-09-18 12:46:59 -07:00
|
|
|
/**
|
2018-10-23 15:17:43 -07:00
|
|
|
* The instructions to atomically execute
|
2018-09-18 12:46:59 -07:00
|
|
|
*/
|
2018-10-23 15:17:43 -07:00
|
|
|
instructions: Array<TransactionInstruction> = [];
|
2018-09-18 12:46:59 -07:00
|
|
|
|
2018-09-13 18:48:51 -07:00
|
|
|
/**
|
|
|
|
* A recent transaction id. Must be populated by the caller
|
|
|
|
*/
|
|
|
|
lastId: ?TransactionId;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Fee for this transaction
|
|
|
|
*/
|
2018-11-27 08:31:06 -08:00
|
|
|
fee: number = 1;
|
2018-09-13 18:48:51 -07:00
|
|
|
|
2018-10-23 19:13:59 -07:00
|
|
|
/**
|
|
|
|
* Construct an empty Transaction
|
|
|
|
*/
|
2018-09-18 12:46:59 -07:00
|
|
|
constructor(opts?: TransactionCtorFields) {
|
|
|
|
opts && Object.assign(this, opts);
|
|
|
|
}
|
|
|
|
|
2018-10-23 19:13:59 -07:00
|
|
|
/**
|
|
|
|
* Add instructions to this Transaction
|
|
|
|
*/
|
|
|
|
add(item: Transaction | TransactionInstructionCtorFields): Transaction {
|
|
|
|
if (item instanceof Transaction) {
|
|
|
|
this.instructions = this.instructions.concat(item.instructions);
|
|
|
|
} else {
|
|
|
|
this.instructions.push(new TransactionInstruction(item));
|
2018-10-23 15:17:43 -07:00
|
|
|
}
|
|
|
|
return this;
|
|
|
|
}
|
|
|
|
|
2018-09-13 18:48:51 -07:00
|
|
|
/**
|
|
|
|
* @private
|
|
|
|
*/
|
|
|
|
_getSignData(): Buffer {
|
2018-10-23 15:17:43 -07:00
|
|
|
const {lastId} = this;
|
2018-09-13 18:48:51 -07:00
|
|
|
if (!lastId) {
|
|
|
|
throw new Error('Transaction lastId required');
|
|
|
|
}
|
2018-10-23 15:17:43 -07:00
|
|
|
|
2018-10-23 19:13:59 -07:00
|
|
|
if (this.instructions.length < 1) {
|
|
|
|
throw new Error('No instructions provided');
|
2018-10-23 15:17:43 -07:00
|
|
|
}
|
|
|
|
|
2018-11-18 08:48:14 -08:00
|
|
|
const keys = this.signatures.map(({publicKey}) => publicKey.toString());
|
2018-10-23 19:13:59 -07:00
|
|
|
const programIds = [];
|
|
|
|
this.instructions.forEach(instruction => {
|
|
|
|
const programId = instruction.programId.toString();
|
|
|
|
if (!programIds.includes(programId)) {
|
|
|
|
programIds.push(programId);
|
|
|
|
}
|
|
|
|
|
2018-11-04 11:41:21 -08:00
|
|
|
instruction.keys.map(key => key.toString()).forEach(key => {
|
2018-10-23 19:13:59 -07:00
|
|
|
if (!keys.includes(key)) {
|
|
|
|
keys.push(key);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
|
|
|
|
|
|
|
const instructions = this.instructions.map(instruction => {
|
|
|
|
const {userdata, programId} = instruction;
|
|
|
|
return {
|
|
|
|
programIdIndex: programIds.indexOf(programId.toString()),
|
|
|
|
keyIndices: instruction.keys.map(key => keys.indexOf(key.toString())),
|
2018-10-10 10:46:15 -07:00
|
|
|
userdata,
|
2018-10-23 19:13:59 -07:00
|
|
|
};
|
|
|
|
});
|
|
|
|
|
|
|
|
instructions.forEach(instruction => {
|
2018-11-18 08:48:14 -08:00
|
|
|
invariant(instruction.programIdIndex >= 0);
|
|
|
|
instruction.keyIndices.forEach(keyIndex => invariant(keyIndex >= 0));
|
2018-10-23 19:13:59 -07:00
|
|
|
});
|
2018-10-10 10:46:15 -07:00
|
|
|
|
|
|
|
const instructionLayout = BufferLayout.struct([
|
2018-10-23 19:13:59 -07:00
|
|
|
BufferLayout.u8('programIdIndex'),
|
2018-10-10 10:46:15 -07:00
|
|
|
|
2018-10-23 19:13:59 -07:00
|
|
|
BufferLayout.u32('keyIndicesLength'),
|
|
|
|
BufferLayout.u32('keyIndicesLengthPadding'),
|
|
|
|
BufferLayout.seq(
|
|
|
|
BufferLayout.u8('keyIndex'),
|
|
|
|
BufferLayout.offset(BufferLayout.u32(), -8),
|
2018-11-04 11:41:21 -08:00
|
|
|
'keyIndices',
|
2018-10-23 19:13:59 -07:00
|
|
|
),
|
|
|
|
BufferLayout.u32('userdataLength'),
|
|
|
|
BufferLayout.u32('userdataLengthPadding'),
|
2018-10-10 10:46:15 -07:00
|
|
|
BufferLayout.seq(
|
2018-10-23 19:13:59 -07:00
|
|
|
BufferLayout.u8('userdatum'),
|
2018-10-10 10:46:15 -07:00
|
|
|
BufferLayout.offset(BufferLayout.u32(), -8),
|
2018-11-04 11:41:21 -08:00
|
|
|
'userdata',
|
2018-10-10 10:46:15 -07:00
|
|
|
),
|
|
|
|
]);
|
2018-09-13 18:48:51 -07:00
|
|
|
|
2018-10-06 11:13:58 -07:00
|
|
|
const signDataLayout = BufferLayout.struct([
|
2018-10-23 19:13:59 -07:00
|
|
|
BufferLayout.u32('keysLength'),
|
|
|
|
BufferLayout.u32('keysLengthPadding'),
|
2018-10-06 11:13:58 -07:00
|
|
|
BufferLayout.seq(
|
2018-10-23 19:13:59 -07:00
|
|
|
Layout.publicKey('key'),
|
2018-10-10 10:46:15 -07:00
|
|
|
BufferLayout.offset(BufferLayout.u32(), -8),
|
2018-11-04 11:41:21 -08:00
|
|
|
'keys',
|
2018-10-06 11:13:58 -07:00
|
|
|
),
|
|
|
|
Layout.publicKey('lastId'),
|
|
|
|
BufferLayout.ns64('fee'),
|
2018-10-10 10:46:15 -07:00
|
|
|
|
|
|
|
BufferLayout.u32('programIdsLength'),
|
|
|
|
BufferLayout.u32('programIdsLengthPadding'),
|
|
|
|
BufferLayout.seq(
|
|
|
|
Layout.publicKey('programId'),
|
|
|
|
BufferLayout.offset(BufferLayout.u32(), -8),
|
2018-11-04 11:41:21 -08:00
|
|
|
'programIds',
|
2018-10-10 10:46:15 -07:00
|
|
|
),
|
|
|
|
|
|
|
|
BufferLayout.u32('instructionsLength'),
|
|
|
|
BufferLayout.u32('instructionsLengthPadding'),
|
|
|
|
BufferLayout.seq(
|
|
|
|
instructionLayout,
|
|
|
|
BufferLayout.offset(BufferLayout.u32(), -8),
|
2018-11-04 11:41:21 -08:00
|
|
|
'instructions',
|
2018-10-10 10:46:15 -07:00
|
|
|
),
|
2018-10-06 11:13:58 -07:00
|
|
|
]);
|
|
|
|
|
2018-10-10 10:46:15 -07:00
|
|
|
const transaction = {
|
2018-11-04 11:41:21 -08:00
|
|
|
keys: keys.map(key => new PublicKey(key).toBuffer()),
|
2018-10-10 10:46:15 -07:00
|
|
|
lastId: Buffer.from(bs58.decode(lastId)),
|
2018-10-23 19:13:59 -07:00
|
|
|
fee: this.fee,
|
2018-11-04 11:41:21 -08:00
|
|
|
programIds: programIds.map(programId =>
|
|
|
|
new PublicKey(programId).toBuffer(),
|
|
|
|
),
|
2018-10-10 10:46:15 -07:00
|
|
|
instructions,
|
|
|
|
};
|
2018-09-13 18:48:51 -07:00
|
|
|
|
2018-10-10 10:46:15 -07:00
|
|
|
let signData = Buffer.alloc(2048);
|
|
|
|
const length = signDataLayout.encode(transaction, signData);
|
2018-10-06 11:13:58 -07:00
|
|
|
signData = signData.slice(0, length);
|
2018-10-10 10:46:15 -07:00
|
|
|
|
2018-10-06 11:13:58 -07:00
|
|
|
return signData;
|
2018-09-13 18:48:51 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2018-11-18 08:48:14 -08:00
|
|
|
* Sign the Transaction with the specified accounts. Multiple signatures may
|
|
|
|
* be applied to a Transaction. The first signature is considered "primary"
|
|
|
|
* and is used when testing for Transaction confirmation.
|
|
|
|
*
|
|
|
|
* Transaction fields should not be modified after the first call to `sign`,
|
|
|
|
* as doing so may invalidate the signature and cause the Transaction to be
|
|
|
|
* rejected.
|
2018-09-13 18:48:51 -07:00
|
|
|
*
|
|
|
|
* The Transaction must be assigned a valid `lastId` before invoking this method
|
|
|
|
*/
|
2018-11-18 08:48:14 -08:00
|
|
|
sign(...signers: Array<Account>) {
|
|
|
|
if (signers.length === 0) {
|
|
|
|
throw new Error('No signers');
|
|
|
|
}
|
|
|
|
const signatures: Array<SignaturePubkeyPair> = signers.map(account => {
|
|
|
|
return {
|
|
|
|
signature: null,
|
|
|
|
publicKey: account.publicKey,
|
|
|
|
};
|
|
|
|
});
|
|
|
|
this.signatures = signatures;
|
2018-10-06 11:13:58 -07:00
|
|
|
const signData = this._getSignData();
|
2018-11-18 08:48:14 -08:00
|
|
|
|
|
|
|
signers.forEach((account, index) => {
|
|
|
|
const signature = nacl.sign.detached(signData, account.secretKey);
|
|
|
|
invariant(signature.length === 64);
|
|
|
|
signatures[index].signature = signature;
|
|
|
|
});
|
2018-09-13 18:48:51 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Serialize the Transaction in the wire format.
|
|
|
|
*
|
|
|
|
* The Transaction must have a valid `signature` before invoking this method
|
|
|
|
*/
|
|
|
|
serialize(): Buffer {
|
2018-11-18 08:48:14 -08:00
|
|
|
const {signatures} = this;
|
|
|
|
if (!signatures) {
|
2018-09-13 18:48:51 -07:00
|
|
|
throw new Error('Transaction has not been signed');
|
|
|
|
}
|
|
|
|
|
2018-10-06 11:13:58 -07:00
|
|
|
const signData = this._getSignData();
|
2018-11-16 19:28:57 -08:00
|
|
|
const wireTransaction = Buffer.alloc(
|
2018-11-18 08:48:14 -08:00
|
|
|
8 + signatures.length * 64 + signData.length,
|
|
|
|
);
|
|
|
|
invariant(signatures.length < 256);
|
|
|
|
wireTransaction.writeUInt8(signatures.length, 0);
|
|
|
|
signatures.forEach(({signature}, index) => {
|
|
|
|
invariant(signature !== null, `null signature`);
|
|
|
|
invariant(signature.length === 64, `signature has invalid length`);
|
|
|
|
Buffer.from(signature).copy(wireTransaction, 8 + index * 64);
|
|
|
|
});
|
|
|
|
signData.copy(wireTransaction, 8 + signatures.length * 64);
|
|
|
|
invariant(
|
|
|
|
wireTransaction.length < 512,
|
|
|
|
`${wireTransaction.length}, ${signatures.length}`,
|
2018-11-16 19:28:57 -08:00
|
|
|
);
|
2018-09-13 18:48:51 -07:00
|
|
|
return wireTransaction;
|
|
|
|
}
|
2018-10-23 15:17:43 -07:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Deprecated method
|
|
|
|
* @private
|
|
|
|
*/
|
|
|
|
get keys(): Array<PublicKey> {
|
2018-11-18 08:48:14 -08:00
|
|
|
invariant(this.instructions.length === 1);
|
2018-10-23 15:17:43 -07:00
|
|
|
return this.instructions[0].keys;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Deprecated method
|
|
|
|
* @private
|
|
|
|
*/
|
|
|
|
get programId(): PublicKey {
|
2018-11-18 08:48:14 -08:00
|
|
|
invariant(this.instructions.length === 1);
|
2018-10-23 15:17:43 -07:00
|
|
|
return this.instructions[0].programId;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Deprecated method
|
|
|
|
* @private
|
|
|
|
*/
|
|
|
|
get userdata(): Buffer {
|
2018-11-18 08:48:14 -08:00
|
|
|
invariant(this.instructions.length === 1);
|
2018-10-23 15:17:43 -07:00
|
|
|
return this.instructions[0].userdata;
|
|
|
|
}
|
2018-09-14 08:27:40 -07:00
|
|
|
}
|