ox 0.14.28 → 0.14.30

package/tempo/e2e.test.ts

@@ -87,6 +87,7 @@ test('behavior: default (secp256k1)', async () => {
       from,
       keyAuthorization: __,
       nonce,
+      gasPrice,
       maxFeePerGas,
       maxPriorityFeePerGas,
       signature,
@@ -100,6 +101,7 @@ test('behavior: default (secp256k1)', async () => {
     expect(chainId).toBe(chainId)
     expect(hash).toBe(receipt.transactionHash)
     expect(from).toBe(address)
+    expect(gasPrice).toBeDefined()
     expect(maxFeePerGas).toBeDefined()
     expect(maxPriorityFeePerGas).toBeDefined()
     expect(nonce).toBeDefined()
@@ -119,7 +121,6 @@ test('behavior: default (secp256k1)', async () => {
         "data": undefined,
         "feePayerSignature": null,
         "gas": 500000n,
-        "gasPrice": 20000000000n,
         "nonceKey": 0n,
         "type": "tempo",
         "validAfter": null,
@@ -133,6 +134,7 @@ test('behavior: default (secp256k1)', async () => {
     blockNumber,
     blockHash,
     cumulativeGasUsed,
+    effectiveGasPrice,
     feePayer,
     feeToken: _,
     from,
@@ -147,6 +149,7 @@ test('behavior: default (secp256k1)', async () => {
   expect(blockNumber).toBeDefined()
   expect(blockHash).toBeDefined()
   expect(cumulativeGasUsed).toBeDefined()
+  expect(effectiveGasPrice).toBeDefined()
   expect(feePayer).toBeDefined()
   expect(from).toBe(address)
   expect(gasUsed).toBeDefined()
@@ -159,7 +162,6 @@ test('behavior: default (secp256k1)', async () => {
       "blobGasPrice": undefined,
       "blobGasUsed": undefined,
       "contractAddress": null,
-      "effectiveGasPrice": 20000000000n,
       "status": "success",
       "to": "0x0000000000000000000000000000000000000000",
       "type": "0x76",
@@ -298,6 +300,7 @@ test('behavior: default (p256)', async () => {
       keyAuthorization: __,
       hash,
       nonce,
+      gasPrice,
       maxFeePerGas,
       maxPriorityFeePerGas,
       signature,
@@ -312,6 +315,7 @@ test('behavior: default (p256)', async () => {
     expect(from).toBe(address)
     expect(hash).toBe(receipt.transactionHash)
     expect(nonce).toBeDefined()
+    expect(gasPrice).toBeDefined()
     expect(maxFeePerGas).toBeDefined()
     expect(maxPriorityFeePerGas).toBeDefined()
     expect(signature).toBeDefined()
@@ -330,7 +334,6 @@ test('behavior: default (p256)', async () => {
         "data": undefined,
         "feePayerSignature": null,
         "gas": 500000n,
-        "gasPrice": 20000000000n,
         "nonceKey": 0n,
         "type": "tempo",
         "validAfter": null,
@@ -344,6 +347,7 @@ test('behavior: default (p256)', async () => {
     blockNumber,
     blockHash,
     cumulativeGasUsed,
+    effectiveGasPrice,
     feePayer,
     feeToken: _,
     from,
@@ -358,6 +362,7 @@ test('behavior: default (p256)', async () => {
   expect(blockNumber).toBeDefined()
   expect(blockHash).toBeDefined()
   expect(cumulativeGasUsed).toBeDefined()
+  expect(effectiveGasPrice).toBeDefined()
   expect(feePayer).toBeDefined()
   expect(from).toBe(address)
   expect(gasUsed).toBeDefined()
@@ -370,7 +375,6 @@ test('behavior: default (p256)', async () => {
       "blobGasPrice": undefined,
       "blobGasUsed": undefined,
       "contractAddress": null,
-      "effectiveGasPrice": 20000000000n,
       "status": "success",
       "to": "0x0000000000000000000000000000000000000000",
       "type": "0x76",
@@ -441,6 +445,7 @@ test('behavior: default (p256 - webcrypto)', async () => {
       keyAuthorization: __,
       hash,
       nonce,
+      gasPrice,
       maxFeePerGas,
       maxPriorityFeePerGas,
       signature,
@@ -455,6 +460,7 @@ test('behavior: default (p256 - webcrypto)', async () => {
     expect(from).toBeDefined()
     expect(hash).toBe(receipt.transactionHash)
     expect(nonce).toBeDefined()
+    expect(gasPrice).toBeDefined()
     expect(maxFeePerGas).toBeDefined()
     expect(maxPriorityFeePerGas).toBeDefined()
     expect(signature).toBeDefined()
@@ -473,7 +479,6 @@ test('behavior: default (p256 - webcrypto)', async () => {
         "data": undefined,
         "feePayerSignature": null,
         "gas": 500000n,
-        "gasPrice": 20000000000n,
         "nonceKey": 0n,
         "type": "tempo",
         "validAfter": null,
@@ -487,6 +492,7 @@ test('behavior: default (p256 - webcrypto)', async () => {
     blockNumber,
     blockHash,
     cumulativeGasUsed,
+    effectiveGasPrice,
     feePayer,
     feeToken: _,
     from,
@@ -501,6 +507,7 @@ test('behavior: default (p256 - webcrypto)', async () => {
   expect(blockNumber).toBeDefined()
   expect(blockHash).toBeDefined()
   expect(cumulativeGasUsed).toBeDefined()
+  expect(effectiveGasPrice).toBeDefined()
   expect(feePayer).toBeDefined()
   expect(from).toBeDefined()
   expect(gasUsed).toBeDefined()
@@ -513,7 +520,6 @@ test('behavior: default (p256 - webcrypto)', async () => {
       "blobGasPrice": undefined,
       "blobGasUsed": undefined,
       "contractAddress": null,
-      "effectiveGasPrice": 20000000000n,
       "status": "success",
       "to": "0x0000000000000000000000000000000000000000",
       "type": "0x76",
@@ -591,6 +597,7 @@ test('behavior: default (webauthn)', async () => {
       keyAuthorization: __,
       hash,
       nonce,
+      gasPrice,
       maxFeePerGas,
       maxPriorityFeePerGas,
       transactionIndex,
@@ -605,6 +612,7 @@ test('behavior: default (webauthn)', async () => {
     expect(from).toBeDefined()
     expect(hash).toBe(receipt.transactionHash)
     expect(nonce).toBeDefined()
+    expect(gasPrice).toBeDefined()
     expect(maxFeePerGas).toBeDefined()
     expect(maxPriorityFeePerGas).toBeDefined()
     expect(signature).toBeDefined()
@@ -623,7 +631,6 @@ test('behavior: default (webauthn)', async () => {
         "data": undefined,
         "feePayerSignature": null,
         "gas": 500000n,
-        "gasPrice": 20000000000n,
         "nonceKey": 0n,
         "type": "tempo",
         "validAfter": null,
@@ -637,6 +644,7 @@ test('behavior: default (webauthn)', async () => {
     blockNumber,
     blockHash,
     cumulativeGasUsed,
+    effectiveGasPrice,
     feePayer,
     feeToken: _,
     from,
@@ -651,6 +659,7 @@ test('behavior: default (webauthn)', async () => {
   expect(blockNumber).toBeDefined()
   expect(blockHash).toBeDefined()
   expect(cumulativeGasUsed).toBeDefined()
+  expect(effectiveGasPrice).toBeDefined()
   expect(feePayer).toBeDefined()
   expect(from).toBe(address)
   expect(gasUsed).toBeDefined()
@@ -663,7 +672,6 @@ test('behavior: default (webauthn)', async () => {
       "blobGasPrice": undefined,
       "blobGasUsed": undefined,
       "contractAddress": null,
-      "effectiveGasPrice": 20000000000n,
       "status": "success",
       "to": "0x0000000000000000000000000000000000000000",
       "type": "0x76",
@@ -745,6 +753,7 @@ test('behavior: feePayerSignature (user → feePayer)', async () => {
       blockNumber,
       blockHash,
       cumulativeGasUsed,
+      effectiveGasPrice,
       feePayer,
       feeToken: _,
       from,
@@ -759,6 +768,7 @@ test('behavior: feePayerSignature (user → feePayer)', async () => {
     expect(blockNumber).toBeDefined()
     expect(blockHash).toBeDefined()
     expect(cumulativeGasUsed).toBeDefined()
+    expect(effectiveGasPrice).toBeDefined()
     expect(feePayer).toBe(feePayerAddress)
     expect(from).toBe(senderAddress)
     expect(gasUsed).toBeDefined()
@@ -771,7 +781,6 @@ test('behavior: feePayerSignature (user → feePayer)', async () => {
         "blobGasPrice": undefined,
         "blobGasUsed": undefined,
         "contractAddress": null,
-        "effectiveGasPrice": 20000000000n,
         "status": "success",
         "to": "0x0000000000000000000000000000000000000000",
         "type": "0x76",
@@ -1019,6 +1028,7 @@ describe('behavior: keyAuthorization', () => {
       blockNumber,
       blockHash,
       cumulativeGasUsed,
+      effectiveGasPrice,
       feePayer,
       feeToken,
       from,
@@ -1033,6 +1043,7 @@ describe('behavior: keyAuthorization', () => {
     expect(blockNumber).toBeDefined()
     expect(blockHash).toBeDefined()
     expect(cumulativeGasUsed).toBeDefined()
+    expect(effectiveGasPrice).toBeDefined()
     expect(feeToken).toBeDefined()
     expect(feePayer).toBeDefined()
     expect(gasUsed).toBeDefined()
@@ -1046,7 +1057,6 @@ describe('behavior: keyAuthorization', () => {
         "blobGasPrice": undefined,
         "blobGasUsed": undefined,
         "contractAddress": null,
-        "effectiveGasPrice": 20000000000n,
         "status": "success",
         "to": "0x0000000000000000000000000000000000000000",
         "type": "0x76",
@@ -1238,6 +1248,7 @@ describe('behavior: keyAuthorization', () => {
       blockNumber,
       blockHash,
       cumulativeGasUsed,
+      effectiveGasPrice,
       feePayer,
       feeToken,
       from,
@@ -1252,6 +1263,7 @@ describe('behavior: keyAuthorization', () => {
     expect(blockNumber).toBeDefined()
     expect(blockHash).toBeDefined()
     expect(cumulativeGasUsed).toBeDefined()
+    expect(effectiveGasPrice).toBeDefined()
     expect(feePayer).toBeDefined()
     expect(feeToken).toBeDefined()
     expect(from).toBeDefined()
@@ -1265,7 +1277,6 @@ describe('behavior: keyAuthorization', () => {
         "blobGasPrice": undefined,
         "blobGasUsed": undefined,
         "contractAddress": null,
-        "effectiveGasPrice": 20000000000n,
         "status": "success",
         "to": "0x0000000000000000000000000000000000000000",
         "type": "0x76",
@@ -3015,9 +3026,9 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
       return { address, privateKey } as const
     })
 
-    const config = MultisigConfig.from({
+    const genesisConfig = MultisigConfig.from({
       // A fresh random salt yields a distinct account each run, exercising the
-      // salt-inclusive config-ID derivation against the node.
+      // salt-inclusive account derivation against the node.
       salt: Hex.random(32),
       threshold,
       owners: ownerKeys.map((key) => ({
@@ -3025,10 +3036,9 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
         weight: 1,
       })),
     })
-    const configId = MultisigConfig.toId(config)
-    const account = MultisigConfig.getAddress({ configId })
+    const account = MultisigConfig.getAddress(genesisConfig)
 
-    return { account, config, configId, ownerKeys } as const
+    return { account, genesisConfig, ownerKeys } as const
   }
 
   // Signs the multisig owner digest with the provided owner keys, returning
@@ -3036,32 +3046,26 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
   // address (required by the node: "recovered owners must be strictly
   // ascending").
   function approve(parameters: {
-    account: Address.Address
-    configId: Hex.Hex
+    genesisConfig: MultisigConfig.Config
     payload: Hex.Hex
     signers: readonly { privateKey: Hex.Hex }[]
   }) {
-    const { account, configId, payload, signers } = parameters
-    const digest = MultisigConfig.getSignPayload({
-      account,
-      configId,
-      payload,
-    })
+    const { genesisConfig, payload, signers } = parameters
+    const digest = MultisigConfig.getSignPayload({ payload, genesisConfig })
     const signatures = signers.map((signer) =>
       SignatureEnvelope.from(
         Secp256k1.sign({ payload: digest, privateKey: signer.privateKey }),
       ),
     )
     return SignatureEnvelope.sortMultisigApprovals({
-      account,
-      configId,
+      genesisConfig,
       payload,
       signatures,
     })
   }
 
   test('behavior: bootstrap + spend (2-of-3 secp256k1)', async () => {
-    const { account, config, configId, ownerKeys } = setup({
+    const { account, genesisConfig, ownerKeys } = setup({
       count: 3,
       threshold: 2,
     })
@@ -3083,15 +3087,12 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
 
     const bootstrap_signed = TxEnvelopeTempo.serialize(bootstrap, {
       signature: SignatureEnvelope.from({
-        type: 'multisig',
-        account,
-        configId,
-        // The bootstrap config is carried by the signature `init`.
-        init: config,
+        genesisConfig,
+        // Initialize multisig.
+        init: true,
         // Approve with 2 of the 3 owners to satisfy the threshold.
         signatures: approve({
-          account,
-          configId,
+          genesisConfig,
           payload: TxEnvelopeTempo.getSignPayload(bootstrap),
           signers: [ownerKeys[0]!, ownerKeys[1]!],
         }),
@@ -3121,7 +3122,7 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
       // The bootstrap config is carried by the multisig signature `init`.
       expect(
         (response.signature as SignatureEnvelope.Multisig | undefined)?.init,
-      ).toEqual(config)
+      ).toEqual(genesisConfig)
     }
 
     // Spend (subsequent transaction): no signature `init`, nonce 1, uses the
@@ -3143,13 +3144,10 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
 
     const spend_signed = TxEnvelopeTempo.serialize(spend, {
       signature: SignatureEnvelope.from({
-        type: 'multisig',
-        account,
-        configId,
+        genesisConfig,
         // A different 2-of-3 subset still authorizes the transaction.
         signatures: approve({
-          account,
-          configId,
+          genesisConfig,
           payload: TxEnvelopeTempo.getSignPayload(spend),
           signers: [ownerKeys[1]!, ownerKeys[2]!],
         }),
@@ -3168,7 +3166,7 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
   })
 
   test('behavior: rejects below-threshold approvals', async () => {
-    const { account, config, configId, ownerKeys } = setup({
+    const { account, genesisConfig, ownerKeys } = setup({
       count: 3,
       threshold: 2,
     })
@@ -3187,15 +3185,12 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
 
     const serialized_signed = TxEnvelopeTempo.serialize(bootstrap, {
       signature: SignatureEnvelope.from({
-        type: 'multisig',
-        account,
-        configId,
-        // The bootstrap config is carried by the signature `init`.
-        init: config,
+        genesisConfig,
+        // Opt into bootstrap: writes `genesisConfig` into the signature `init`.
+        init: true,
         // Only one approval — below the threshold of 2.
         signatures: approve({
-          account,
-          configId,
+          genesisConfig,
           payload: TxEnvelopeTempo.getSignPayload(bootstrap),
           signers: [ownerKeys[0]!],
         }),
@@ -3209,4 +3204,224 @@ describe.skip('behavior: multisig (TIP-1061)', () => {
       }),
     ).rejects.toThrow()
   })
+
+  test('behavior: keychain access key (authorize via AccountKeychain + spend)', async () => {
+    const { account, genesisConfig, ownerKeys } = setup({
+      count: 2,
+      threshold: 2,
+    })
+
+    await fundAddress(client, { address: account })
+
+    // Fresh secp256k1 access key for the multisig account.
+    const access = (() => {
+      const privateKey = Secp256k1.randomPrivateKey()
+      const address = Address.fromPublicKey(
+        Secp256k1.getPublicKey({ privateKey }),
+      )
+      return { address, privateKey } as const
+    })()
+
+    // Bootstrap the multisig (nonce 0).
+    const bootstrap = TxEnvelopeTempo.from({
+      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+      chainId,
+      feeToken: '0x20c0000000000000000000000000000000000001',
+      nonce: 0n,
+      gas: 2_000_000n,
+      maxFeePerGas: Value.fromGwei('20'),
+      maxPriorityFeePerGas: Value.fromGwei('10'),
+    })
+
+    const bootstrap_signed = TxEnvelopeTempo.serialize(bootstrap, {
+      signature: SignatureEnvelope.from({
+        genesisConfig,
+        init: true,
+        signatures: approve({
+          genesisConfig,
+          payload: TxEnvelopeTempo.getSignPayload(bootstrap),
+          signers: ownerKeys,
+        }),
+      }),
+    })
+
+    const bootstrap_receipt = (await client
+      .request({
+        method: 'eth_sendRawTransactionSync',
+        params: [bootstrap_signed],
+      })
+      .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
+    expect(bootstrap_receipt.status).toBe('success')
+
+    // Authorize the access key (nonce 1): multisig transactions cannot carry
+    // a TIP-1049 `keyAuthorization`, so the multisig account calls the
+    // AccountKeychain precompile's `authorizeKey` directly.
+    const authorizeKey = AbiFunction.from(
+      'function authorizeKey(address keyId, uint8 signatureType, (uint64 expiry, bool enforceLimits, (address token, uint256 amount, uint64 period)[] limits, bool allowAnyCalls, (address target, (bytes4 selector, address[] recipients)[] selectorRules)[] allowedCalls) config)',
+    )
+
+    const authorize = TxEnvelopeTempo.from({
+      calls: [
+        {
+          to: '0xaaaaaaaa00000000000000000000000000000000',
+          data: AbiFunction.encodeData(authorizeKey, [
+            access.address,
+            0, // secp256k1
+            {
+              expiry: 18446744073709551615n, // u64 max (never expires)
+              enforceLimits: false,
+              limits: [],
+              allowAnyCalls: true,
+              allowedCalls: [],
+            },
+          ]),
+        },
+      ],
+      chainId,
+      feeToken: '0x20c0000000000000000000000000000000000001',
+      nonce: 1n,
+      gas: 2_000_000n,
+      maxFeePerGas: Value.fromGwei('20'),
+      maxPriorityFeePerGas: Value.fromGwei('10'),
+    })
+
+    const authorize_signed = TxEnvelopeTempo.serialize(authorize, {
+      signature: SignatureEnvelope.from({
+        genesisConfig,
+        signatures: approve({
+          genesisConfig,
+          payload: TxEnvelopeTempo.getSignPayload(authorize),
+          signers: ownerKeys,
+        }),
+      }),
+    })
+
+    const authorize_receipt = (await client
+      .request({
+        method: 'eth_sendRawTransactionSync',
+        params: [authorize_signed],
+      })
+      .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
+    expect(authorize_receipt.status).toBe('success')
+    expect(authorize_receipt.from).toBe(account)
+
+    // Spend with the access key (nonce 2): outer keychain signature with the
+    // multisig account as `userAddress` — no owner approvals involved.
+    const nonce = await getTransactionCount(client, {
+      address: account,
+      blockTag: 'pending',
+    })
+
+    const spend = TxEnvelopeTempo.from({
+      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+      chainId,
+      feeToken: '0x20c0000000000000000000000000000000000001',
+      nonce: BigInt(nonce),
+      gas: 2_000_000n,
+      maxFeePerGas: Value.fromGwei('20'),
+      maxPriorityFeePerGas: Value.fromGwei('10'),
+    })
+
+    const spend_signature = Secp256k1.sign({
+      payload: TxEnvelopeTempo.getSignPayload(spend, { from: account }),
+      privateKey: access.privateKey,
+    })
+
+    const spend_signed = TxEnvelopeTempo.serialize(spend, {
+      signature: SignatureEnvelope.from({
+        userAddress: account,
+        inner: SignatureEnvelope.from(spend_signature),
+        type: 'keychain',
+      }),
+    })
+
+    const spend_receipt = (await client
+      .request({
+        method: 'eth_sendRawTransactionSync',
+        params: [spend_signed],
+      })
+      .then((tx) => TransactionReceipt.fromRpc(tx as any)))!
+    expect(spend_receipt.status).toBe('success')
+    expect(spend_receipt.from).toBe(account)
+
+    {
+      const response = await client
+        .request({
+          method: 'eth_getTransactionByHash',
+          params: [spend_receipt.transactionHash],
+        })
+        .then((tx) => Transaction.fromRpc(tx as any))
+      if (!response) throw new Error()
+      expect(response.from).toBe(account)
+      expect(response.signature?.type).toBe('keychain')
+      expect(
+        (response.signature as SignatureEnvelope.Keychain | undefined)
+          ?.userAddress,
+      ).toBe(account)
+    }
+  })
+
+  test('behavior: rejects `keyAuthorization` on multisig transactions', async () => {
+    const { account, genesisConfig, ownerKeys } = setup({
+      count: 1,
+      threshold: 1,
+    })
+
+    await fundAddress(client, { address: account })
+
+    const access = (() => {
+      const privateKey = Secp256k1.randomPrivateKey()
+      const address = Address.fromPublicKey(
+        Secp256k1.getPublicKey({ privateKey }),
+      )
+      return { address, privateKey } as const
+    })()
+
+    // TIP-1049 key authorizations are only valid on primitive/keychain
+    // transactions; multisig accounts must call the AccountKeychain
+    // precompile instead.
+    const keyAuth = KeyAuthorization.from({
+      address: access.address,
+      chainId: BigInt(chainId),
+      type: 'secp256k1',
+    })
+    const keyAuth_signed = KeyAuthorization.from(keyAuth, {
+      signature: SignatureEnvelope.from(
+        Secp256k1.sign({
+          payload: KeyAuthorization.getSignPayload(keyAuth),
+          privateKey: ownerKeys[0]!.privateKey,
+        }),
+      ),
+    })
+
+    const bootstrap = TxEnvelopeTempo.from({
+      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+      chainId,
+      feeToken: '0x20c0000000000000000000000000000000000001',
+      keyAuthorization: keyAuth_signed,
+      nonce: 0n,
+      gas: 2_000_000n,
+      maxFeePerGas: Value.fromGwei('20'),
+      maxPriorityFeePerGas: Value.fromGwei('10'),
+    })
+
+    const serialized_signed = TxEnvelopeTempo.serialize(bootstrap, {
+      signature: SignatureEnvelope.from({
+        genesisConfig,
+        init: true,
+        signatures: approve({
+          genesisConfig,
+          payload: TxEnvelopeTempo.getSignPayload(bootstrap),
+          signers: ownerKeys,
+        }),
+      }),
+    })
+
+    await expect(
+      client.request({
+        method: 'eth_sendRawTransactionSync',
+        params: [serialized_signed],
+      }),
+    ).rejects.toThrow()
+  })
 })

package/tempo/index.ts

@@ -105,8 +105,8 @@ export * as KeyAuthorization from './KeyAuthorization.js'
 /**
  * Native multisig account utilities (TIP-1061).
  *
- * Derives stable multisig account addresses and permanent config IDs from a weighted
- * owner configuration, and computes the owner approval digest that owners sign.
+ * Derives stable multisig account addresses from a weighted owner
+ * configuration, and computes the owner approval digest that owners sign.
  *
  * [TIP-1061](https://tips.sh/1061)
  *
@@ -114,7 +114,7 @@ export * as KeyAuthorization from './KeyAuthorization.js'
  * ```ts twoslash
  * import { MultisigConfig } from 'ox/tempo'
  *
- * const config = MultisigConfig.from({
+ * const genesisConfig = MultisigConfig.from({
  *   threshold: 2,
  *   owners: [
  *     { owner: '0x1111111111111111111111111111111111111111', weight: 1 },
@@ -122,7 +122,7 @@ export * as KeyAuthorization from './KeyAuthorization.js'
  *   ],
  * })
  *
- * const account = MultisigConfig.getAddress({ config })
+ * const account = MultisigConfig.getAddress(genesisConfig)
  * ```
  *
  * @category Reference

package/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '0.14.28'
+export const version = '0.14.30'