diff --git a/packages/api-metadata/src/extrinsics/index.spec.ts b/packages/api-metadata/src/extrinsics/index.spec.ts index 77992d47ef..9fb230dea1 100644 --- a/packages/api-metadata/src/extrinsics/index.spec.ts +++ b/packages/api-metadata/src/extrinsics/index.spec.ts @@ -18,6 +18,7 @@ describe('extrinsics', (): void => { extrinsics.balances.transfer(keyring.bob.publicKey, 6969) ).sign(keyring.alice, { blockHash: '0xec7afaf1cca720ce88c1d1b689d81f0583cc15a97d621cf046dd9abf605ef22f', + genesisHash: '0xdcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025b', nonce: 0 }).toHex() ).toEqual( diff --git a/packages/api/src/SubmittableExtrinsic.ts b/packages/api/src/SubmittableExtrinsic.ts index d05fa55369..c90b010a04 100644 --- a/packages/api/src/SubmittableExtrinsic.ts +++ b/packages/api/src/SubmittableExtrinsic.ts @@ -178,7 +178,8 @@ export default function createSubmittableExtrinsic ( blockHash: api.genesisHash, version: api.runtimeVersion, ...options, - ...extras + ...extras, + genesisHash: api.genesisHash } as unknown as SignatureOptions; } diff --git a/packages/types/src/primitive/Extrinsic/Extrinsic.ts b/packages/types/src/primitive/Extrinsic/Extrinsic.ts index 4f14db1de7..531db2aa57 100644 --- a/packages/types/src/primitive/Extrinsic/Extrinsic.ts +++ b/packages/types/src/primitive/Extrinsic/Extrinsic.ts @@ -14,10 +14,11 @@ import Address from '../Generic/Address'; import Call from '../Generic/Call'; import ExtrinsicV1, { ExtrinsicValueV1 } from './v1/Extrinsic'; import ExtrinsicV2, { ExtrinsicValueV2 } from './v2/Extrinsic'; +import ExtrinsicV3, { ExtrinsicValueV3 } from './v3/Extrinsic'; import ExtrinsicEra from './ExtrinsicEra'; import { BIT_SIGNED, BIT_UNSIGNED, DEFAULT_VERSION, UNMASK_VERSION } from './constants'; -type ExtrinsicValue = ExtrinsicValueV1 | ExtrinsicValueV2; +type ExtrinsicValue = ExtrinsicValueV1 | ExtrinsicValueV2 | ExtrinsicValueV3; interface ExtrinsicOptions { version?: number; @@ -35,12 +36,12 @@ interface ExtrinsicOptions { * - signed, to create a transaction * - left as is, to create an inherent */ -export default class Extrinsic extends Base implements IExtrinsic { +export default class Extrinsic extends Base implements IExtrinsic { public constructor (value: Extrinsic | ExtrinsicValue | AnyU8a | Call | undefined, { version }: ExtrinsicOptions = {}) { super(Extrinsic.decodeExtrinsic(value, version)); } - private static newFromValue (value: any, version: number): ExtrinsicV1 | ExtrinsicV2 { + private static newFromValue (value: any, version: number): ExtrinsicV1 | ExtrinsicV2 | ExtrinsicV3 { if (value instanceof Extrinsic) { return value.raw; } @@ -51,11 +52,12 @@ export default class Extrinsic extends Base implement switch (type) { case 1: return new ExtrinsicV1(value, { isSigned }); case 2: return new ExtrinsicV2(value, { isSigned }); + case 3: return new ExtrinsicV3(value, { isSigned }); default: throw new Error(`Unsupported extrinsic version ${type}`); } } - public static decodeExtrinsic (value: Extrinsic | ExtrinsicValue | AnyU8a | Call | undefined, version: number = DEFAULT_VERSION): ExtrinsicV1 | ExtrinsicV2 { + public static decodeExtrinsic (value: Extrinsic | ExtrinsicValue | AnyU8a | Call | undefined, version: number = DEFAULT_VERSION): ExtrinsicV1 | ExtrinsicV2 | ExtrinsicV3 { if (Array.isArray(value) || isHex(value)) { // Instead of the block below, it should simply be: // return Extrinsic.decodeExtrinsic(hexToU8a(value as string)); @@ -90,7 +92,7 @@ export default class Extrinsic extends Base implement return Extrinsic.newFromValue(value, version); } - private static decodeU8a (value: Uint8Array): ExtrinsicV1 | ExtrinsicV2 { + private static decodeU8a (value: Uint8Array): ExtrinsicV1 | ExtrinsicV2 | ExtrinsicV3 { return Extrinsic.newFromValue(value.subarray(1), value[0]); } @@ -226,8 +228,10 @@ export default class Extrinsic extends Base implement // @ts-ignore if (args.length === 2) { payload = { + blockHash: new Uint8Array(), // @ts-ignore era: args[1] as string, + genesisHash: new Uint8Array(), method: this.method.toHex(), nonce: args[0] as string, tip: 0 diff --git a/packages/types/src/primitive/Extrinsic/ExtrinsicPayload.ts b/packages/types/src/primitive/Extrinsic/ExtrinsicPayload.ts index 35fbbd5ad5..cb0911ed85 100644 --- a/packages/types/src/primitive/Extrinsic/ExtrinsicPayload.ts +++ b/packages/types/src/primitive/Extrinsic/ExtrinsicPayload.ts @@ -3,7 +3,7 @@ // of the Apache-2.0 license. See the LICENSE file for details. import { Balance, Hash, Index } from '../../interfaces/runtime'; -import { IKeyringPair } from '../../types'; +import { ExtrinsicPayloadValue, IKeyringPair } from '../../types'; import { u8aToHex } from '@polkadot/util'; @@ -11,8 +11,9 @@ import createType from '../../codec/createType'; import Base from '../../codec/Base'; import Compact from '../../codec/Compact'; import U8a from '../../codec/U8a'; -import ExtrinsicPayloadV1, { ExtrinsicPayloadValueV1 } from './v1/ExtrinsicPayload'; -import ExtrinsicPayloadV2, { ExtrinsicPayloadValueV2 } from './v2/ExtrinsicPayload'; +import ExtrinsicPayloadV1 from './v1/ExtrinsicPayload'; +import ExtrinsicPayloadV2 from './v2/ExtrinsicPayload'; +import ExtrinsicPayloadV3 from './v3/ExtrinsicPayload'; import ExtrinsicEra from './ExtrinsicEra'; import { DEFAULT_VERSION } from './constants'; @@ -26,14 +27,14 @@ interface ExtrinsicPayloadOptions { * A signing payload for an [[Extrinsic]]. For the final encoding, it is variable length based * on the contents included */ -export default class ExtrinsicPayload extends Base { - public constructor (value: Partial | Partial | Uint8Array | string | undefined, { version }: ExtrinsicPayloadOptions = {}) { +export default class ExtrinsicPayload extends Base { + public constructor (value: Partial | Uint8Array | string | undefined, { version }: ExtrinsicPayloadOptions = {}) { super( - ExtrinsicPayload.decodeExtrinsicPayload(value, version) + ExtrinsicPayload.decodeExtrinsicPayload(value as ExtrinsicPayloadValue, version) ); } - public static decodeExtrinsicPayload (value: ExtrinsicPayload | Partial | Partial | Uint8Array | string | undefined, version: number = DEFAULT_VERSION): ExtrinsicPayloadV1 | ExtrinsicPayloadV2 { + public static decodeExtrinsicPayload (value: ExtrinsicPayload | ExtrinsicPayloadValue | Uint8Array | string | undefined, version: number = DEFAULT_VERSION): ExtrinsicPayloadV1 | ExtrinsicPayloadV2 | ExtrinsicPayloadV3 { if (value instanceof ExtrinsicPayload) { return value.raw; } @@ -41,6 +42,7 @@ export default class ExtrinsicPayload extends Base { - return (this.raw as ExtrinsicPayloadV2).tip || createType('Compact', 0); + // NOTE from v2 + return (this.raw as ExtrinsicPayloadV2).tip || createType('Compact'); } /** diff --git a/packages/types/src/primitive/Extrinsic/types.ts b/packages/types/src/primitive/Extrinsic/types.ts new file mode 100644 index 0000000000..66388556bd --- /dev/null +++ b/packages/types/src/primitive/Extrinsic/types.ts @@ -0,0 +1,19 @@ +// Copyright 2017-2019 @polkadot/types authors & contributors +// This software may be modified and distributed under the terms +// of the Apache-2.0 license. See the LICENSE file for details. + +import { AnyNumber } from '../../types'; + +export interface ExtrinsicOptions { + isSigned?: boolean; +} + +export interface ExtrinsicSignatureOptions { + isSigned?: boolean; +} + +export interface ExtrinsicExtraValue { + era?: Uint8Array; + nonce?: AnyNumber; + tip?: AnyNumber; +} diff --git a/packages/types/src/primitive/Extrinsic/v1/Extrinsic.ts b/packages/types/src/primitive/Extrinsic/v1/Extrinsic.ts index 0e3778e0c9..378303feec 100644 --- a/packages/types/src/primitive/Extrinsic/v1/Extrinsic.ts +++ b/packages/types/src/primitive/Extrinsic/v1/Extrinsic.ts @@ -3,6 +3,7 @@ // of the Apache-2.0 license. See the LICENSE file for details. import { ExtrinsicPayloadValue, IExtrinsicImpl, IKeyringPair, SignatureOptions } from '../../../types'; +import { ExtrinsicOptions } from '../types'; import { isU8a } from '@polkadot/util'; @@ -16,10 +17,6 @@ export interface ExtrinsicValueV1 { signature?: ExtrinsicSignature; } -interface ExtrinsicV1Options { - isSigned?: boolean; -} - const TRANSACTION_VERSION = 1; /** @@ -28,7 +25,7 @@ const TRANSACTION_VERSION = 1; * The first generation of compact extrinsics */ export default class ExtrinsicV1 extends Struct implements IExtrinsicImpl { - public constructor (value?: Uint8Array | ExtrinsicValueV1, { isSigned }: ExtrinsicV1Options = {}) { + public constructor (value?: Uint8Array | ExtrinsicValueV1, { isSigned }: ExtrinsicOptions = {}) { super({ signature: ExtrinsicSignature, method: Call diff --git a/packages/types/src/primitive/Extrinsic/v1/ExtrinsicPayload.ts b/packages/types/src/primitive/Extrinsic/v1/ExtrinsicPayload.ts index e7431bb4f2..9ab7778820 100644 --- a/packages/types/src/primitive/Extrinsic/v1/ExtrinsicPayload.ts +++ b/packages/types/src/primitive/Extrinsic/v1/ExtrinsicPayload.ts @@ -3,7 +3,7 @@ // of the Apache-2.0 license. See the LICENSE file for details. import { Hash, Index } from '../../../interfaces/runtime'; -import { AnyNumber, AnyU8a, ExtrinsicPayloadValue, IExtrinsicEra, IKeyringPair, IMethod } from '../../../types'; +import { ExtrinsicPayloadValue, IKeyringPair } from '../../../types'; import { ClassOf } from '../../../codec/createType'; import Compact from '../../../codec/Compact'; @@ -12,13 +12,6 @@ import U8a from '../../../codec/U8a'; import ExtrinsicEra from '../ExtrinsicEra'; import { sign } from '../util'; -export interface ExtrinsicPayloadValueV1 { - blockHash: AnyU8a; - era: AnyU8a | IExtrinsicEra; - method: AnyU8a | IMethod; - nonce: AnyNumber; -} - /** * @name ExtrinsicPayloadV1 * @description @@ -31,7 +24,7 @@ export interface ExtrinsicPayloadValueV1 { * 32 bytes: The hash of the authoring block implied by the Transaction Era and the current block. */ export default class ExtrinsicPayloadV1 extends Struct { - public constructor (value?: ExtrinsicPayloadValue | ExtrinsicPayloadValueV1 | Uint8Array | string) { + public constructor (value?: ExtrinsicPayloadValue | Uint8Array | string) { super({ nonce: ClassOf('Compact'), method: U8a, diff --git a/packages/types/src/primitive/Extrinsic/v1/ExtrinsicSignature.ts b/packages/types/src/primitive/Extrinsic/v1/ExtrinsicSignature.ts index d077515472..9fd903fbbb 100644 --- a/packages/types/src/primitive/Extrinsic/v1/ExtrinsicSignature.ts +++ b/packages/types/src/primitive/Extrinsic/v1/ExtrinsicSignature.ts @@ -4,6 +4,7 @@ import { Address, Balance, Index, Signature } from '../../../interfaces/runtime'; import { ExtrinsicPayloadValue, IExtrinsicSignature, IKeyringPair, SignatureOptions } from '../../../types'; +import { ExtrinsicSignatureOptions } from '../types'; import createType, { ClassOf } from '../../../codec/createType'; import Compact from '../../../codec/Compact'; @@ -13,10 +14,6 @@ import ExtrinsicEra from '../ExtrinsicEra'; import { EMPTY_U8A, IMMORTAL_ERA } from '../constants'; import ExtrinsicPayload from './ExtrinsicPayload'; -interface ExtrinsicSignatureV1Options { - isSigned?: boolean; -} - /** * @name ExtrinsicSignature * @description @@ -28,7 +25,7 @@ export default class ExtrinsicSignatureV1 extends Struct implements IExtrinsicSi // 64 bytes: The sr25519/ed25519 signature of the Signing Payload // 1-8 bytes: The Compact of the signing account // 1/2 bytes: The Transaction Era - public constructor (value?: ExtrinsicSignatureV1 | Uint8Array, { isSigned }: ExtrinsicSignatureV1Options = {}) { + public constructor (value?: ExtrinsicSignatureV1 | Uint8Array, { isSigned }: ExtrinsicSignatureOptions = {}) { super({ signer: ClassOf('Address'), signature: ClassOf('Signature'), @@ -123,13 +120,15 @@ export default class ExtrinsicSignatureV1 extends Struct implements IExtrinsicSi /** * @description Generate a payload and pplies the signature from a keypair */ - public sign (method: Call, account: IKeyringPair, { blockHash, era, nonce }: SignatureOptions): IExtrinsicSignature { + public sign (method: Call, account: IKeyringPair, { blockHash, era, genesisHash, nonce }: SignatureOptions): IExtrinsicSignature { const signer = createType('Address', account.publicKey); const payload = new ExtrinsicPayload({ - nonce, - method: method.toU8a(), + blockHash, era: era || IMMORTAL_ERA, - blockHash + genesisHash, + method: method.toU8a(), + nonce, + tip: 0 }); const signature = createType('Signature', payload.sign(account)); diff --git a/packages/types/src/primitive/Extrinsic/v2/Extrinsic.spec.ts b/packages/types/src/primitive/Extrinsic/v2/Extrinsic.spec.ts index f08337fc79..26711dd4fb 100644 --- a/packages/types/src/primitive/Extrinsic/v2/Extrinsic.spec.ts +++ b/packages/types/src/primitive/Extrinsic/v2/Extrinsic.spec.ts @@ -41,6 +41,7 @@ describe('ExtrinsicV2', (): void => { extrinsics.balances.transfer(keyring.bob.publicKey, 6969) ).sign(keyring.alice, { blockHash: '0xec7afaf1cca720ce88c1d1b689d81f0583cc15a97d621cf046dd9abf605ef22f', + genesisHash: '0xdcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025b', nonce: 1, tip: 2 }).toHex() diff --git a/packages/types/src/primitive/Extrinsic/v2/Extrinsic.ts b/packages/types/src/primitive/Extrinsic/v2/Extrinsic.ts index c942c19b28..3f470b3d32 100644 --- a/packages/types/src/primitive/Extrinsic/v2/Extrinsic.ts +++ b/packages/types/src/primitive/Extrinsic/v2/Extrinsic.ts @@ -3,6 +3,7 @@ // of the Apache-2.0 license. See the LICENSE file for details. import { ExtrinsicPayloadValue, IExtrinsicImpl, IKeyringPair, SignatureOptions } from '../../../types'; +import { ExtrinsicOptions } from '../types'; import { isU8a } from '@polkadot/util'; @@ -18,17 +19,13 @@ export interface ExtrinsicValueV2 { signature?: ExtrinsicSignature; } -interface ExtrinsicV2Options { - isSigned?: boolean; -} - /** * @name ExtrinsicV2 * @description * The second generation of compact extrinsics */ export default class ExtrinsicV2 extends Struct implements IExtrinsicImpl { - public constructor (value?: Uint8Array | ExtrinsicValueV2 | Call, { isSigned }: ExtrinsicV2Options = {}) { + public constructor (value?: Uint8Array | ExtrinsicValueV2 | Call, { isSigned }: ExtrinsicOptions = {}) { super({ signature: ExtrinsicSignature, method: Call diff --git a/packages/types/src/primitive/Extrinsic/v2/ExtrinsicExtra.ts b/packages/types/src/primitive/Extrinsic/v2/ExtrinsicExtra.ts index d82f19e49d..117db22889 100644 --- a/packages/types/src/primitive/Extrinsic/v2/ExtrinsicExtra.ts +++ b/packages/types/src/primitive/Extrinsic/v2/ExtrinsicExtra.ts @@ -3,7 +3,7 @@ // of the Apache-2.0 license. See the LICENSE file for details. import { Balance, Index } from '../../../interfaces/runtime'; -import { AnyNumber } from '../../../types'; +import { ExtrinsicExtraValue } from '../types'; import { ClassOf } from '../../../codec/createType'; import Compact from '../../../codec/Compact'; @@ -11,19 +11,13 @@ import Struct from '../../../codec/Struct'; import Address from '../../Generic/Address'; import ExtrinsicEra from '../ExtrinsicEra'; -interface ExtrinsicExtraValueV2 { - era?: Uint8Array; - nonce?: AnyNumber; - tip?: AnyNumber; -} - /** * @name ExtrinsicExtraV2 * @description * A container for the extra information in an extrinsic */ export default class ExtrinsicExtraV2 extends Struct { - public constructor (value?: ExtrinsicExtraValueV2 | Uint8Array) { + public constructor (value?: ExtrinsicExtraValue | Uint8Array) { super({ era: ExtrinsicEra, nonce: ClassOf('Compact'), diff --git a/packages/types/src/primitive/Extrinsic/v2/ExtrinsicPayload.ts b/packages/types/src/primitive/Extrinsic/v2/ExtrinsicPayload.ts index 44b724ec79..c8b88e5d53 100644 --- a/packages/types/src/primitive/Extrinsic/v2/ExtrinsicPayload.ts +++ b/packages/types/src/primitive/Extrinsic/v2/ExtrinsicPayload.ts @@ -3,7 +3,7 @@ // of the Apache-2.0 license. See the LICENSE file for details. import { Balance, Hash, Index } from '../../../interfaces/runtime'; -import { AnyNumber, AnyU8a, ExtrinsicPayloadValue, IExtrinsicEra, IKeyringPair, IMethod } from '../../../types'; +import { ExtrinsicPayloadValue, IKeyringPair } from '../../../types'; import { ClassOf } from '../../../codec/createType'; import Compact from '../../../codec/Compact'; @@ -12,14 +12,6 @@ import U8a from '../../../codec/U8a'; import ExtrinsicEra from '../ExtrinsicEra'; import { sign } from '../util'; -export interface ExtrinsicPayloadValueV2 { - blockHash: AnyU8a; - era: AnyU8a | IExtrinsicEra; - method: AnyU8a | IMethod; - nonce: AnyNumber; - tip: AnyNumber; -} - /** * @name ExtrinsicPayloadV2 * @description @@ -27,7 +19,7 @@ export interface ExtrinsicPayloadValueV2 { * on the contents included */ export default class ExtrinsicPayloadV2 extends Struct { - public constructor (value?: ExtrinsicPayloadValue | ExtrinsicPayloadValueV2 | Uint8Array | string) { + public constructor (value?: ExtrinsicPayloadValue | Uint8Array | string) { super({ method: U8a, era: ExtrinsicEra, @@ -44,13 +36,6 @@ export default class ExtrinsicPayloadV2 extends Struct { return this.get('blockHash') as Hash; } - /** - * @description The [[U8a]] contained in the payload - */ - public get method (): U8a { - return this.get('method') as U8a; - } - /** * @description The [[ExtrinsicEra]] */ @@ -58,6 +43,13 @@ export default class ExtrinsicPayloadV2 extends Struct { return this.get('era') as ExtrinsicEra; } + /** + * @description The [[U8a]] contained in the payload + */ + public get method (): U8a { + return this.get('method') as U8a; + } + /** * @description The [[Index]] */ diff --git a/packages/types/src/primitive/Extrinsic/v2/ExtrinsicSignature.ts b/packages/types/src/primitive/Extrinsic/v2/ExtrinsicSignature.ts index 9e44f1dbcd..27614c0c6e 100644 --- a/packages/types/src/primitive/Extrinsic/v2/ExtrinsicSignature.ts +++ b/packages/types/src/primitive/Extrinsic/v2/ExtrinsicSignature.ts @@ -4,6 +4,7 @@ import { Address, Balance, Index, Signature } from '../../../interfaces/runtime'; import { ExtrinsicPayloadValue, IExtrinsicSignature, IKeyringPair, SignatureOptions } from '../../../types'; +import { ExtrinsicSignatureOptions } from '../types'; import createType, { ClassOf } from '../../../codec/createType'; import Compact from '../../../codec/Compact'; @@ -12,11 +13,7 @@ import Call from '../../Generic/Call'; import ExtrinsicEra from '../ExtrinsicEra'; import ExtrinsicPayload from './ExtrinsicPayload'; import { EMPTY_U8A, IMMORTAL_ERA } from '../constants'; -import ExtrinsicExtra from './ExtrinsicExtra'; - -interface ExtrinsicSignatureV2Options { - isSigned?: boolean; -} +import ExtrinsicExtra from '../v2/ExtrinsicExtra'; /** * @name ExtrinsicSignature @@ -24,7 +21,7 @@ interface ExtrinsicSignatureV2Options { * A container for the [[Signature]] associated with a specific [[Extrinsic]] */ export default class ExtrinsicSignatureV2 extends Struct implements IExtrinsicSignature { - public constructor (value: ExtrinsicSignatureV2 | Uint8Array | undefined, { isSigned }: ExtrinsicSignatureV2Options = {}) { + public constructor (value: ExtrinsicSignatureV2 | Uint8Array | undefined, { isSigned }: ExtrinsicSignatureOptions = {}) { super({ signer: ClassOf('Address'), signature: ClassOf('Signature'), @@ -127,11 +124,12 @@ export default class ExtrinsicSignatureV2 extends Struct implements IExtrinsicSi /** * @description Generate a payload and pplies the signature from a keypair */ - public sign (method: Call, account: IKeyringPair, { blockHash, era, nonce, tip }: SignatureOptions): IExtrinsicSignature { + public sign (method: Call, account: IKeyringPair, { blockHash, era, genesisHash, nonce, tip }: SignatureOptions): IExtrinsicSignature { const signer = createType('Address', account.publicKey); const payload = new ExtrinsicPayload({ blockHash, era: era || IMMORTAL_ERA, + genesisHash, method: method.toU8a(), nonce, tip: tip || 0 diff --git a/packages/types/src/primitive/Extrinsic/v3/Extrinsic.spec.ts b/packages/types/src/primitive/Extrinsic/v3/Extrinsic.spec.ts new file mode 100644 index 0000000000..6015125f96 --- /dev/null +++ b/packages/types/src/primitive/Extrinsic/v3/Extrinsic.spec.ts @@ -0,0 +1,61 @@ +// Copyright 2017-2019 @polkadot/types authors & contributors +// This software may be modified and distributed under the terms +// of the Apache-2.0 license. See the LICENSE file for details. + +import extrinsics from '@polkadot/api-metadata/extrinsics/static'; +import testingPairs from '@polkadot/keyring/testingPairs'; + +import Call from '../../Generic/Call'; +import Extrinsic from './Extrinsic'; + +const keyring = testingPairs({ type: 'ed25519' }, false); + +describe('ExtrinsicV3', (): void => { + beforeEach((): void => { + Call.injectMethods(extrinsics); + }); + + it('constructs a sane Uint8Array (default)', (): void => { + expect( + new Extrinsic().toU8a() + ).toEqual(new Uint8Array([0, 0])); + }); + + it('creates a unsigned extrinsic', (): void => { + expect( + new Extrinsic( + extrinsics.balances.transfer(keyring.bob.publicKey, 6969) + ).toHex() + ).toEqual( + '0x' + + '0500' + // balance.transfer + 'ff' + + 'd7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9' + + 'e56c' + ); + }); + + it('creates a signed extrinsic', (): void => { + expect( + new Extrinsic( + extrinsics.balances.transfer(keyring.bob.publicKey, 6969) + ).sign(keyring.alice, { + blockHash: '0xec7afaf1cca720ce88c1d1b689d81f0583cc15a97d621cf046dd9abf605ef22f', + genesisHash: '0xdcd1346701ca8396496e52aa2785b1748deb6db09551b72159dcb3e08991025b', + nonce: 1, + tip: 2 + }).toHex() + ).toEqual( + '0x' + + 'ff' + + 'd172a74cda4c865912c32ba0a80a57ae69abae410e5ccb59dee84e2f4432db4f' + + '2bb401483999053d2d69a4aebefb9682c8710ddd495d1298d4eedd241c73869f' + + '9d32c82dba98b12ef74bea5f987851b592956de3cf3e946533da815e3b6a2904' + + '000408' + // era. nonce, tip + '0500' + + 'ff' + + 'd7568e5f0a7eda67a82691ff379ac4bba4f9c9b859fe779b5d46363b61ad2db9' + + 'e56c' + ); + }); +}); diff --git a/packages/types/src/primitive/Extrinsic/v3/Extrinsic.ts b/packages/types/src/primitive/Extrinsic/v3/Extrinsic.ts new file mode 100644 index 0000000000..4a6d7ca4f7 --- /dev/null +++ b/packages/types/src/primitive/Extrinsic/v3/Extrinsic.ts @@ -0,0 +1,101 @@ +// Copyright 2017-2019 @polkadot/types authors & contributors +// This software may be modified and distributed under the terms +// of the Apache-2.0 license. See the LICENSE file for details. + +import { ExtrinsicPayloadValue, IExtrinsicImpl, IKeyringPair, SignatureOptions } from '../../../types'; +import { ExtrinsicOptions } from '../types'; + +import { isU8a } from '@polkadot/util'; + +import Struct from '../../../codec/Struct'; +import Call from '../../Generic/Call'; +import Address from '../../Generic/Address'; +import ExtrinsicSignature from './ExtrinsicSignature'; + +const TRANSACTION_VERSION = 3; + +export interface ExtrinsicValueV3 { + method?: Call; + signature?: ExtrinsicSignature; +} + +/** + * @name ExtrinsicV3 + * @description + * The second generation of compact extrinsics + */ +export default class ExtrinsicV3 extends Struct implements IExtrinsicImpl { + public constructor (value?: Uint8Array | ExtrinsicValueV3 | Call, { isSigned }: ExtrinsicOptions = {}) { + super({ + signature: ExtrinsicSignature, + method: Call + }, ExtrinsicV3.decodeExtrinsic(value, isSigned)); + } + + public static decodeExtrinsic (value?: Call | Uint8Array | ExtrinsicValueV3, isSigned: boolean = false): ExtrinsicValueV3 { + if (!value) { + return {}; + } else if (value instanceof ExtrinsicV3) { + return value; + } else if (value instanceof Call) { + return { method: value }; + } else if (isU8a(value)) { + // here we decode manually since we need to pull through the version information + const signature = new ExtrinsicSignature(value, { isSigned }); + const method = new Call(value.subarray(signature.encodedLength)); + + return { + method, + signature + }; + } + + return value; + } + + /** + * @description The length of the value when encoded as a Uint8Array + */ + public get encodedLength (): number { + return this.toU8a().length; + } + + /** + * @description The [[Call]] this extrinsic wraps + */ + public get method (): Call { + return this.get('method') as Call; + } + + /** + * @description The [[ExtrinsicSignature]] + */ + public get signature (): ExtrinsicSignature { + return this.get('signature') as ExtrinsicSignature; + } + + /** + * @description The version for the signature + */ + public get version (): number { + return TRANSACTION_VERSION; + } + + /** + * @description Add an [[ExtrinsicSignature]] to the extrinsic (already generated) + */ + public addSignature (signer: Address | Uint8Array | string, signature: Uint8Array | string, payload: ExtrinsicPayloadValue | Uint8Array | string): ExtrinsicV3 { + this.signature.addSignature(signer, signature, payload); + + return this; + } + + /** + * @description Sign the extrinsic with a specific keypair + */ + public sign (account: IKeyringPair, options: SignatureOptions): ExtrinsicV3 { + this.signature.sign(this.method, account, options); + + return this; + } +} diff --git a/packages/types/src/primitive/Extrinsic/v3/ExtrinsicPayload.ts b/packages/types/src/primitive/Extrinsic/v3/ExtrinsicPayload.ts new file mode 100644 index 0000000000..788d8fe442 --- /dev/null +++ b/packages/types/src/primitive/Extrinsic/v3/ExtrinsicPayload.ts @@ -0,0 +1,82 @@ +// Copyright 2017-2019 @polkadot/types authors & contributors +// This software may be modified and distributed under the terms +// of the Apache-2.0 license. See the LICENSE file for details. + +import { Balance, Hash, Index } from '../../../interfaces/runtime'; +import { ExtrinsicPayloadValue, IKeyringPair } from '../../../types'; + +import { ClassOf } from '../../../codec/createType'; +import Compact from '../../../codec/Compact'; +import Struct from '../../../codec/Struct'; +import U8a from '../../../codec/U8a'; +import ExtrinsicEra from '../ExtrinsicEra'; +import { sign } from '../util'; + +/** + * @name ExtrinsicPayloadV3 + * @description + * A signing payload for an [[Extrinsic]]. For the final encoding, it is variable length based + * on the contents included + */ +export default class ExtrinsicPayloadV3 extends Struct { + public constructor (value?: ExtrinsicPayloadValue | Uint8Array | string) { + super({ + method: U8a, + era: ExtrinsicEra, + nonce: ClassOf('Compact'), + tip: ClassOf('Compact'), + genesisHash: ClassOf('Hash'), + blockHash: ClassOf('Hash') + }, value); + } + + /** + * @description The block [[Hash]] the signature applies to (mortal/immortal) + */ + public get blockHash (): Hash { + return this.get('blockHash') as Hash; + } + + /** + * @description The [[ExtrinsicEra]] + */ + public get era (): ExtrinsicEra { + return this.get('era') as ExtrinsicEra; + } + + /** + * @description The genesis [[Hash]] the signature applies to (mortal/immortal) + */ + public get genesisHash (): Hash { + return this.get('genesisHash') as Hash; + } + + /** + * @description The [[U8a]] contained in the payload + */ + public get method (): U8a { + return this.get('method') as U8a; + } + + /** + * @description The [[Index]] + */ + public get nonce (): Compact { + return this.get('nonce') as Compact; + } + + /** + * @description The tip [[Balance]] + */ + public get tip (): Compact { + return this.get('tip') as Compact; + } + + /** + * @description Sign the payload with the keypair + */ + // eslint-disable-next-line @typescript-eslint/no-unused-vars + public sign (signerPair: IKeyringPair): Uint8Array { + return sign(signerPair, this.toU8a()); + } +} diff --git a/packages/types/src/primitive/Extrinsic/v3/ExtrinsicSignature.spec.ts b/packages/types/src/primitive/Extrinsic/v3/ExtrinsicSignature.spec.ts new file mode 100644 index 0000000000..dff5041924 --- /dev/null +++ b/packages/types/src/primitive/Extrinsic/v3/ExtrinsicSignature.spec.ts @@ -0,0 +1,29 @@ +// Copyright 2017-2019 @polkadot/types authors & contributors +// This software may be modified and distributed under the terms +// of the Apache-2.0 license. See the LICENSE file for details. + +import '../../../injector'; + +import ExtrinsicSignature from './ExtrinsicSignature'; + +describe('ExtrinsicSignatureV3', (): void => { + it('encodes to a sane Uint8Array', (): void => { + const u8a = new Uint8Array([ + // signer as an AccountIndex + 0x09, + // signature + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, + // extra stuff + 0x00, // immortal, + 0x04, // nonce, compact + 0x08 // tip, compact + ]); + + expect( + new ExtrinsicSignature(u8a, { isSigned: true }).toU8a() + ).toEqual(u8a); + }); +}); diff --git a/packages/types/src/primitive/Extrinsic/v3/ExtrinsicSignature.ts b/packages/types/src/primitive/Extrinsic/v3/ExtrinsicSignature.ts new file mode 100644 index 0000000000..e446de6470 --- /dev/null +++ b/packages/types/src/primitive/Extrinsic/v3/ExtrinsicSignature.ts @@ -0,0 +1,151 @@ +// Copyright 2017-2019 @polkadot/types authors & contributors +// This software may be modified and distributed under the terms +// of the Apache-2.0 license. See the LICENSE file for details. + +import { Address, Balance, Index, Signature } from '../../../interfaces/runtime'; +import { ExtrinsicPayloadValue, IExtrinsicSignature, IKeyringPair, SignatureOptions } from '../../../types'; +import { ExtrinsicSignatureOptions } from '../types'; + +import createType, { ClassOf } from '../../../codec/createType'; +import Compact from '../../../codec/Compact'; +import Struct from '../../../codec/Struct'; +import Call from '../../Generic/Call'; +import ExtrinsicEra from '../ExtrinsicEra'; +import ExtrinsicPayload from './ExtrinsicPayload'; +import { EMPTY_U8A, IMMORTAL_ERA } from '../constants'; +import ExtrinsicExtra from '../v2/ExtrinsicExtra'; + +/** + * @name ExtrinsicSignatureV3 + * @description + * A container for the [[Signature]] associated with a specific [[Extrinsic]] + */ +export default class ExtrinsicSignatureV3 extends Struct implements IExtrinsicSignature { + public constructor (value: ExtrinsicSignatureV3 | Uint8Array | undefined, { isSigned }: ExtrinsicSignatureOptions = {}) { + super({ + signer: ClassOf('Address'), + signature: ClassOf('Signature'), + extra: ExtrinsicExtra + }, ExtrinsicSignatureV3.decodeExtrinsicSignature(value, isSigned)); + } + + public static decodeExtrinsicSignature (value: ExtrinsicSignatureV3 | Uint8Array | undefined, isSigned: boolean = false): ExtrinsicSignatureV3 | Uint8Array { + if (!value) { + return EMPTY_U8A; + } else if (value instanceof ExtrinsicSignatureV3) { + return value; + } + + return isSigned + ? value + : EMPTY_U8A; + } + + /** + * @description The length of the value when encoded as a Uint8Array + */ + public get encodedLength (): number { + return this.isSigned + ? super.encodedLength + : 0; + } + + /** + * @description `true` if the signature is valid + */ + public get isSigned (): boolean { + return !this.signature.isEmpty; + } + + /** + * @description Returns the extra extrinsic info + */ + public get extra (): ExtrinsicExtra { + return this.get('extra') as ExtrinsicExtra; + } + + /** + * @description The [[ExtrinsicEra]] (mortal or immortal) this signature applies to + */ + public get era (): ExtrinsicEra { + return this.extra.era; + } + + /** + * @description The [[Index]] for the signature + */ + public get nonce (): Compact { + return this.extra.nonce; + } + + /** + * @description The actuall [[Signature]] hash + */ + public get signature (): Signature { + return this.get('signature') as Signature; + } + + /** + * @description The [[Address]] that signed + */ + public get signer (): Address { + return this.get('signer') as Address; + } + + /** + * @description The [[Balance]] tip + */ + public get tip (): Compact { + return this.extra.tip; + } + + private injectSignature (signer: Address, signature: Signature, { era, nonce, tip }: ExtrinsicPayload): IExtrinsicSignature { + this.extra.set('era', era); + this.extra.set('nonce', nonce); + this.extra.set('tip', tip); + + this.set('signer', signer); + this.set('signature', signature); + + return this; + } + + /** + * @description Adds a raw signature + */ + public addSignature (signer: Address | Uint8Array | string, signature: Uint8Array | string, payload: ExtrinsicPayloadValue | Uint8Array | string): IExtrinsicSignature { + return this.injectSignature( + createType('Address', signer), + createType('Signature', signature), + new ExtrinsicPayload(payload) + ); + } + + /** + * @description Generate a payload and pplies the signature from a keypair + */ + public sign (method: Call, account: IKeyringPair, { blockHash, era, genesisHash, nonce, tip }: SignatureOptions): IExtrinsicSignature { + const signer = createType('Address', account.publicKey); + const payload = new ExtrinsicPayload({ + blockHash, + era: era || IMMORTAL_ERA, + genesisHash, + method: method.toU8a(), + nonce, + tip: tip || 0 + }); + const signature = createType('Signature', payload.sign(account)); + + return this.injectSignature(signer, signature, payload); + } + + /** + * @description Encodes the value as a Uint8Array as per the SCALE specifications + * @param isBare true when the value has none of the type-specific prefixes (internal) + */ + public toU8a (isBare?: boolean): Uint8Array { + return this.isSigned + ? super.toU8a(isBare) + : EMPTY_U8A; + } +} diff --git a/packages/types/src/types.ts b/packages/types/src/types.ts index 2c2244f251..4406e4c97e 100644 --- a/packages/types/src/types.ts +++ b/packages/types/src/types.ts @@ -145,6 +145,7 @@ export interface RuntimeVersionInterface { export interface SignatureOptions { blockHash: AnyU8a; era?: IExtrinsicEra; + genesisHash: AnyU8a; nonce: AnyNumber; tip?: AnyNumber; version?: RuntimeVersionInterface; @@ -173,8 +174,10 @@ interface ExtrinsicSignatureBase { } export interface ExtrinsicPayloadValue { - era: IExtrinsicEra | AnyU8a; - method: AnyU8a; + blockHash: AnyU8a; + era: AnyU8a | IExtrinsicEra; + genesisHash: AnyU8a; + method: AnyU8a | IMethod; nonce: AnyNumber; tip: AnyNumber; }