@effect-blockchain/starknet 0.0.0-stage → 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +12 -2
- package/dist/StarknetAddress.d.ts +29 -0
- package/dist/StarknetAddress.d.ts.map +1 -0
- package/dist/StarknetAddress.js +29 -0
- package/dist/StarknetAddress.js.map +1 -0
- package/dist/StarknetBlock.d.ts +49 -0
- package/dist/StarknetBlock.d.ts.map +1 -0
- package/dist/StarknetBlock.js +52 -0
- package/dist/StarknetBlock.js.map +1 -0
- package/dist/StarknetEvent.d.ts +34 -0
- package/dist/StarknetEvent.d.ts.map +1 -0
- package/dist/StarknetEvent.js +39 -0
- package/dist/StarknetEvent.js.map +1 -0
- package/dist/StarknetIndexer.d.ts +157 -0
- package/dist/StarknetIndexer.d.ts.map +1 -0
- package/dist/StarknetIndexer.js +245 -0
- package/dist/StarknetIndexer.js.map +1 -0
- package/dist/StarknetNetwork.d.ts +72 -0
- package/dist/StarknetNetwork.d.ts.map +1 -0
- package/dist/StarknetNetwork.js +83 -0
- package/dist/StarknetNetwork.js.map +1 -0
- package/dist/StarknetRelayer.d.ts +273 -0
- package/dist/StarknetRelayer.d.ts.map +1 -0
- package/dist/StarknetRelayer.js +352 -0
- package/dist/StarknetRelayer.js.map +1 -0
- package/dist/StarknetRpc.d.ts +306 -0
- package/dist/StarknetRpc.d.ts.map +1 -0
- package/dist/StarknetRpc.js +281 -0
- package/dist/StarknetRpc.js.map +1 -0
- package/dist/StarknetSigner.d.ts +75 -0
- package/dist/StarknetSigner.d.ts.map +1 -0
- package/dist/StarknetSigner.js +84 -0
- package/dist/StarknetSigner.js.map +1 -0
- package/dist/StarknetTransaction.d.ts +74 -0
- package/dist/StarknetTransaction.d.ts.map +1 -0
- package/dist/StarknetTransaction.js +2 -0
- package/dist/StarknetTransaction.js.map +1 -0
- package/dist/StarknetTransactionHash.d.ts +22 -0
- package/dist/StarknetTransactionHash.d.ts.map +1 -0
- package/dist/StarknetTransactionHash.js +22 -0
- package/dist/StarknetTransactionHash.js.map +1 -0
- package/dist/index.d.ts +44 -0
- package/dist/index.d.ts.map +1 -0
- package/dist/index.js +45 -0
- package/dist/index.js.map +1 -0
- package/dist/internal/PaddedFelt.d.ts +2 -0
- package/dist/internal/PaddedFelt.d.ts.map +1 -0
- package/dist/internal/PaddedFelt.js +15 -0
- package/dist/internal/PaddedFelt.js.map +1 -0
- package/dist/internal/confirmations.d.ts +2 -0
- package/dist/internal/confirmations.d.ts.map +1 -0
- package/dist/internal/confirmations.js +13 -0
- package/dist/internal/confirmations.js.map +1 -0
- package/dist/internal/rpcMethods.d.ts +2 -0
- package/dist/internal/rpcMethods.d.ts.map +1 -0
- package/dist/internal/rpcMethods.js +225 -0
- package/dist/internal/rpcMethods.js.map +1 -0
- package/dist/internal/transactionHash.d.ts +2 -0
- package/dist/internal/transactionHash.d.ts.map +1 -0
- package/dist/internal/transactionHash.js +60 -0
- package/dist/internal/transactionHash.js.map +1 -0
- package/package.json +66 -3
- package/src/StarknetAddress.ts +42 -0
- package/src/StarknetBlock.ts +54 -0
- package/src/StarknetEvent.ts +45 -0
- package/src/StarknetIndexer.ts +363 -0
- package/src/StarknetNetwork.ts +107 -0
- package/src/StarknetRelayer.ts +437 -0
- package/src/StarknetRpc.ts +524 -0
- package/src/StarknetSigner.ts +115 -0
- package/src/StarknetTransaction.ts +68 -0
- package/src/StarknetTransactionHash.ts +31 -0
- package/src/index.ts +55 -0
- package/src/internal/PaddedFelt.ts +18 -0
- package/src/internal/confirmations.ts +17 -0
- package/src/internal/rpcMethods.ts +224 -0
- package/src/internal/transactionHash.ts +64 -0
|
@@ -0,0 +1,68 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The Starknet V3 transactions an account sends: an `INVOKE` of its `__execute__` entrypoint and the `DEPLOY_ACCOUNT`
|
|
3
|
+
* of its own contract.
|
|
4
|
+
*
|
|
5
|
+
* Fees are paid in STRK. Nonce and fee data availability modes are `L1`, and paymaster and account deployment data
|
|
6
|
+
* are empty: these are the only values the protocol accepts. Felts are 0x-prefixed hexadecimal strings.
|
|
7
|
+
*
|
|
8
|
+
* @since 0.2.0
|
|
9
|
+
*/
|
|
10
|
+
import type { StarknetAddress } from "./StarknetAddress.ts"
|
|
11
|
+
import type { StarknetChainId } from "./StarknetNetwork.ts"
|
|
12
|
+
|
|
13
|
+
/**
|
|
14
|
+
* The most a V3 transaction pays for each resource: `maxAmount` units at `maxPricePerUnit` FRI (10^-18 STRK) at most.
|
|
15
|
+
*
|
|
16
|
+
* @since 0.2.0
|
|
17
|
+
* @category models
|
|
18
|
+
*/
|
|
19
|
+
export interface StarknetResourceBounds {
|
|
20
|
+
readonly l1Gas: { readonly maxAmount: bigint; readonly maxPricePerUnit: bigint }
|
|
21
|
+
readonly l1DataGas: { readonly maxAmount: bigint; readonly maxPricePerUnit: bigint }
|
|
22
|
+
readonly l2Gas: { readonly maxAmount: bigint; readonly maxPricePerUnit: bigint }
|
|
23
|
+
}
|
|
24
|
+
|
|
25
|
+
/**
|
|
26
|
+
* An `INVOKE` V3 transaction: `calldata` is the calldata of the `__execute__` entrypoint of `senderAddress`, and
|
|
27
|
+
* `signature` the felts its `__validate__` entrypoint checks.
|
|
28
|
+
*
|
|
29
|
+
* @since 0.2.0
|
|
30
|
+
* @category models
|
|
31
|
+
*/
|
|
32
|
+
export interface StarknetInvokeTransaction {
|
|
33
|
+
readonly type: "INVOKE"
|
|
34
|
+
readonly chainId: StarknetChainId
|
|
35
|
+
readonly senderAddress: StarknetAddress
|
|
36
|
+
readonly calldata: ReadonlyArray<string>
|
|
37
|
+
readonly nonce: bigint
|
|
38
|
+
readonly resourceBounds: StarknetResourceBounds
|
|
39
|
+
readonly tip: bigint
|
|
40
|
+
readonly signature: ReadonlyArray<string>
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
/**
|
|
44
|
+
* A `DEPLOY_ACCOUNT` V3 transaction: deploys the account contract of class `classHash` at the address its class hash,
|
|
45
|
+
* salt and constructor calldata determine. That address pays the fee, so it holds STRK before the deployment.
|
|
46
|
+
*
|
|
47
|
+
* @since 0.2.0
|
|
48
|
+
* @category models
|
|
49
|
+
*/
|
|
50
|
+
export interface StarknetDeployAccountTransaction {
|
|
51
|
+
readonly type: "DEPLOY_ACCOUNT"
|
|
52
|
+
readonly chainId: StarknetChainId
|
|
53
|
+
readonly classHash: string
|
|
54
|
+
readonly contractAddressSalt: string
|
|
55
|
+
readonly constructorCalldata: ReadonlyArray<string>
|
|
56
|
+
readonly nonce: bigint
|
|
57
|
+
readonly resourceBounds: StarknetResourceBounds
|
|
58
|
+
readonly tip: bigint
|
|
59
|
+
readonly signature: ReadonlyArray<string>
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
/**
|
|
63
|
+
* A signed transaction, as `starknet_addInvokeTransaction` and `starknet_addDeployAccountTransaction` take it.
|
|
64
|
+
*
|
|
65
|
+
* @since 0.2.0
|
|
66
|
+
* @category models
|
|
67
|
+
*/
|
|
68
|
+
export type StarknetTransaction = StarknetInvokeTransaction | StarknetDeployAccountTransaction
|
|
@@ -0,0 +1,31 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Starknet transaction hashes.
|
|
3
|
+
*
|
|
4
|
+
* @since 0.1.0
|
|
5
|
+
*/
|
|
6
|
+
import * as Schema from "effect/Schema"
|
|
7
|
+
import { PaddedFelt } from "./internal/PaddedFelt.ts"
|
|
8
|
+
|
|
9
|
+
/**
|
|
10
|
+
* A Starknet transaction hash: `0x` followed by 64 lowercase hex digits.
|
|
11
|
+
*
|
|
12
|
+
* Decoding lowercases the input and left-pads it with zeros, so `"0xc9"` decodes
|
|
13
|
+
* to `"0x00…00c9"`.
|
|
14
|
+
*
|
|
15
|
+
* @since 0.1.0
|
|
16
|
+
* @category schemas
|
|
17
|
+
*/
|
|
18
|
+
export const StarknetTransactionHash = PaddedFelt.pipe(
|
|
19
|
+
Schema.brand("StarknetTransactionHash"),
|
|
20
|
+
Schema.annotate({
|
|
21
|
+
identifier: "StarknetTransactionHash",
|
|
22
|
+
title: "Starknet transaction hash",
|
|
23
|
+
description: "a valid Starknet transaction hash, starting with 0x and followed by 64 hexadecimal characters"
|
|
24
|
+
})
|
|
25
|
+
)
|
|
26
|
+
|
|
27
|
+
/**
|
|
28
|
+
* @since 0.1.0
|
|
29
|
+
* @category models
|
|
30
|
+
*/
|
|
31
|
+
export type StarknetTransactionHash = typeof StarknetTransactionHash.Type
|
package/src/index.ts
ADDED
|
@@ -0,0 +1,55 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* @since 0.1.0
|
|
3
|
+
*/
|
|
4
|
+
|
|
5
|
+
// @barrel: Auto-generated exports. Do not edit manually.
|
|
6
|
+
|
|
7
|
+
/**
|
|
8
|
+
* @since 0.1.0
|
|
9
|
+
*/
|
|
10
|
+
export * as StarknetAddress from "./StarknetAddress.ts"
|
|
11
|
+
|
|
12
|
+
/**
|
|
13
|
+
* @since 0.1.0
|
|
14
|
+
*/
|
|
15
|
+
export * as StarknetBlock from "./StarknetBlock.ts"
|
|
16
|
+
|
|
17
|
+
/**
|
|
18
|
+
* @since 0.1.0
|
|
19
|
+
*/
|
|
20
|
+
export * as StarknetEvent from "./StarknetEvent.ts"
|
|
21
|
+
|
|
22
|
+
/**
|
|
23
|
+
* @since 0.1.0
|
|
24
|
+
*/
|
|
25
|
+
export * as StarknetIndexer from "./StarknetIndexer.ts"
|
|
26
|
+
|
|
27
|
+
/**
|
|
28
|
+
* @since 0.1.0
|
|
29
|
+
*/
|
|
30
|
+
export * as StarknetNetwork from "./StarknetNetwork.ts"
|
|
31
|
+
|
|
32
|
+
/**
|
|
33
|
+
* @since 0.2.0
|
|
34
|
+
*/
|
|
35
|
+
export * as StarknetRelayer from "./StarknetRelayer.ts"
|
|
36
|
+
|
|
37
|
+
/**
|
|
38
|
+
* @since 0.1.0
|
|
39
|
+
*/
|
|
40
|
+
export * as StarknetRpc from "./StarknetRpc.ts"
|
|
41
|
+
|
|
42
|
+
/**
|
|
43
|
+
* @since 0.2.0
|
|
44
|
+
*/
|
|
45
|
+
export * as StarknetSigner from "./StarknetSigner.ts"
|
|
46
|
+
|
|
47
|
+
/**
|
|
48
|
+
* @since 0.2.0
|
|
49
|
+
*/
|
|
50
|
+
export * as StarknetTransaction from "./StarknetTransaction.ts"
|
|
51
|
+
|
|
52
|
+
/**
|
|
53
|
+
* @since 0.1.0
|
|
54
|
+
*/
|
|
55
|
+
export * as StarknetTransactionHash from "./StarknetTransactionHash.ts"
|
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
import { identity } from "effect/Function"
|
|
2
|
+
import * as Schema from "effect/Schema"
|
|
3
|
+
import * as SchemaTransformation from "effect/SchemaTransformation"
|
|
4
|
+
|
|
5
|
+
const padFelt = (hex: string): string => `0x${(hex.startsWith("0x") ? hex.slice(2) : hex).padStart(64, "0")}`
|
|
6
|
+
|
|
7
|
+
/**
|
|
8
|
+
* A field element as a hex string: accepts 1 to 64 hex digits with an optional
|
|
9
|
+
* `0x` prefix in any case, decodes to `0x` + 64 lowercase hex digits.
|
|
10
|
+
*
|
|
11
|
+
* @internal
|
|
12
|
+
*/
|
|
13
|
+
export const PaddedFelt = Schema.String.pipe(
|
|
14
|
+
Schema.check(Schema.isPattern(/^(0x)?[0-9a-fA-F]{1,64}$/u)),
|
|
15
|
+
Schema.decodeTo(Schema.String, SchemaTransformation.toLowerCase()),
|
|
16
|
+
Schema.decodeTo(Schema.String, SchemaTransformation.transform({ decode: padFelt, encode: identity })),
|
|
17
|
+
Schema.check(Schema.isPattern(/^0x[0-9a-f]{64}$/u))
|
|
18
|
+
)
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
import * as BigInt_ from "effect/BigInt"
|
|
2
|
+
import * as Effect from "effect/Effect"
|
|
3
|
+
import * as StarknetNetwork from "../StarknetNetwork.ts"
|
|
4
|
+
import type * as StarknetRpc from "../StarknetRpc.ts"
|
|
5
|
+
|
|
6
|
+
/**
|
|
7
|
+
* The head block number minus `confirmations` (the network's default when unset), never below 0.
|
|
8
|
+
*
|
|
9
|
+
* @internal
|
|
10
|
+
*/
|
|
11
|
+
export const lastConfirmedBlock = (
|
|
12
|
+
rpc: StarknetRpc.StarknetRpc["Service"],
|
|
13
|
+
confirmations: number | undefined
|
|
14
|
+
): Effect.Effect<bigint, StarknetRpc.StarknetRpcError> => {
|
|
15
|
+
const depth = BigInt(confirmations ?? StarknetNetwork.defaultConfirmations(rpc.network))
|
|
16
|
+
return Effect.map(rpc.blockNumber, (head) => BigInt_.max(head - depth, BigInt(0)))
|
|
17
|
+
}
|
|
@@ -0,0 +1,224 @@
|
|
|
1
|
+
import * as JsonRpc from "@effect-blockchain/core/JsonRpc"
|
|
2
|
+
import { identity } from "effect/Function"
|
|
3
|
+
import * as Option from "effect/Option"
|
|
4
|
+
import * as Predicate from "effect/Predicate"
|
|
5
|
+
import * as Schema from "effect/Schema"
|
|
6
|
+
import * as SchemaTransformation from "effect/SchemaTransformation"
|
|
7
|
+
import { StarknetAddress } from "../StarknetAddress.ts"
|
|
8
|
+
import { StarknetBlock } from "../StarknetBlock.ts"
|
|
9
|
+
import { StarknetEvent } from "../StarknetEvent.ts"
|
|
10
|
+
import { StarknetTransactionHash } from "../StarknetTransactionHash.ts"
|
|
11
|
+
import { PaddedFelt } from "./PaddedFelt.ts"
|
|
12
|
+
|
|
13
|
+
// by-name params: every method sends an object, `{}` when it takes none
|
|
14
|
+
const make = <Params, Result>(method: JsonRpc.Method<Params, Result>): JsonRpc.Method<Params, Result> => method
|
|
15
|
+
|
|
16
|
+
const NoParams = Schema.Struct({})
|
|
17
|
+
|
|
18
|
+
const decodeShortString = (felt: string) => {
|
|
19
|
+
const hex = BigInt(felt).toString(16)
|
|
20
|
+
return hex.padStart(hex.length + hex.length % 2, "0").replace(
|
|
21
|
+
/../g,
|
|
22
|
+
(byte) => String.fromCharCode(parseInt(byte, 16))
|
|
23
|
+
)
|
|
24
|
+
}
|
|
25
|
+
|
|
26
|
+
const encodeShortString = (text: string) =>
|
|
27
|
+
`0x${Array.from(text, (char) => char.charCodeAt(0).toString(16).padStart(2, "0")).join("")}`
|
|
28
|
+
|
|
29
|
+
// a chain ID is a short string encoded as a felt: "0x534e5f4d41494e" is "SN_MAIN"
|
|
30
|
+
const ShortStringFromFelt = Schema.String.check(Schema.isPattern(/^0x[0-9a-fA-F]{1,64}$/)).pipe(
|
|
31
|
+
Schema.decodeTo(
|
|
32
|
+
Schema.String,
|
|
33
|
+
SchemaTransformation.transform({ decode: decodeShortString, encode: encodeShortString })
|
|
34
|
+
)
|
|
35
|
+
)
|
|
36
|
+
|
|
37
|
+
// params accept any felt (`0x1`), results are normalized to 64 digits
|
|
38
|
+
const Felt = Schema.toEncoded(PaddedFelt)
|
|
39
|
+
|
|
40
|
+
const BlockId = Schema.Struct({ block_number: JsonRpc.BigIntFromInt })
|
|
41
|
+
|
|
42
|
+
/** @internal */
|
|
43
|
+
export const chainId = make({ name: "starknet_chainId", params: NoParams, result: ShortStringFromFelt })
|
|
44
|
+
|
|
45
|
+
/** @internal */
|
|
46
|
+
export const blockNumber = make({ name: "starknet_blockNumber", params: NoParams, result: JsonRpc.BigIntFromInt })
|
|
47
|
+
|
|
48
|
+
/** @internal */
|
|
49
|
+
export const getBlockWithTxHashes = make({
|
|
50
|
+
name: "starknet_getBlockWithTxHashes",
|
|
51
|
+
params: Schema.Struct({ block_id: BlockId }),
|
|
52
|
+
// a pre-confirmed block has no block hash and does not decode
|
|
53
|
+
result: StarknetBlock
|
|
54
|
+
})
|
|
55
|
+
|
|
56
|
+
/** @internal */
|
|
57
|
+
export const call = make({
|
|
58
|
+
name: "starknet_call",
|
|
59
|
+
params: Schema.Struct({
|
|
60
|
+
request: Schema.Struct({
|
|
61
|
+
contract_address: StarknetAddress,
|
|
62
|
+
entry_point_selector: Felt,
|
|
63
|
+
calldata: Schema.Array(Felt)
|
|
64
|
+
}),
|
|
65
|
+
block_id: BlockId
|
|
66
|
+
}),
|
|
67
|
+
result: Schema.Array(PaddedFelt)
|
|
68
|
+
})
|
|
69
|
+
|
|
70
|
+
/** @internal */
|
|
71
|
+
export const getEvents = make({
|
|
72
|
+
name: "starknet_getEvents",
|
|
73
|
+
params: Schema.Struct({
|
|
74
|
+
filter: Schema.Struct({
|
|
75
|
+
address: StarknetAddress,
|
|
76
|
+
from_block: BlockId,
|
|
77
|
+
to_block: BlockId,
|
|
78
|
+
keys: Schema.optionalKey(Schema.Array(Schema.Array(Felt))),
|
|
79
|
+
chunk_size: Schema.Int,
|
|
80
|
+
continuation_token: Schema.optionalKey(Schema.String)
|
|
81
|
+
})
|
|
82
|
+
}),
|
|
83
|
+
result: Schema.Struct({
|
|
84
|
+
events: Schema.Array(StarknetEvent),
|
|
85
|
+
continuation_token: Schema.optionalKey(Schema.String)
|
|
86
|
+
})
|
|
87
|
+
})
|
|
88
|
+
|
|
89
|
+
/** @internal */
|
|
90
|
+
export const getTransactionStatus = make({
|
|
91
|
+
name: "starknet_getTransactionStatus",
|
|
92
|
+
params: Schema.Struct({ transaction_hash: StarknetTransactionHash }),
|
|
93
|
+
result: Schema.Struct({
|
|
94
|
+
finalityStatus: Schema.Literals(["RECEIVED", "CANDIDATE", "PRE_CONFIRMED", "ACCEPTED_ON_L2", "ACCEPTED_ON_L1"]),
|
|
95
|
+
executionStatus: Schema.optionalKey(Schema.Literals(["SUCCEEDED", "REVERTED"])),
|
|
96
|
+
// starknet-devnet 0.7.1 answers `"failure_reason": null` for a transaction that did not revert
|
|
97
|
+
failureReason: Schema.optionalKey(Schema.NullOr(Schema.String)).pipe(
|
|
98
|
+
Schema.decodeTo(
|
|
99
|
+
Schema.optionalKey(Schema.String),
|
|
100
|
+
SchemaTransformation.transformOptional<string, string | null>({
|
|
101
|
+
decode: Option.filter(Predicate.isNotNull),
|
|
102
|
+
encode: identity
|
|
103
|
+
})
|
|
104
|
+
)
|
|
105
|
+
)
|
|
106
|
+
}).pipe(
|
|
107
|
+
Schema.encodeKeys({
|
|
108
|
+
finalityStatus: "finality_status",
|
|
109
|
+
executionStatus: "execution_status",
|
|
110
|
+
failureReason: "failure_reason"
|
|
111
|
+
})
|
|
112
|
+
)
|
|
113
|
+
})
|
|
114
|
+
|
|
115
|
+
/** @internal */
|
|
116
|
+
export const getTransactionReceipt = make({
|
|
117
|
+
name: "starknet_getTransactionReceipt",
|
|
118
|
+
params: Schema.Struct({ transaction_hash: StarknetTransactionHash }),
|
|
119
|
+
// a pre-confirmed receipt has no block hash and does not decode
|
|
120
|
+
result: Schema.Struct({
|
|
121
|
+
transactionHash: StarknetTransactionHash,
|
|
122
|
+
blockNumber: JsonRpc.BigIntFromInt,
|
|
123
|
+
blockHash: PaddedFelt,
|
|
124
|
+
events: Schema.Array(
|
|
125
|
+
Schema.Struct({ fromAddress: StarknetAddress, keys: Schema.Array(PaddedFelt), data: Schema.Array(PaddedFelt) })
|
|
126
|
+
.pipe(Schema.encodeKeys({ fromAddress: "from_address" }))
|
|
127
|
+
)
|
|
128
|
+
}).pipe(
|
|
129
|
+
Schema.encodeKeys({ transactionHash: "transaction_hash", blockNumber: "block_number", blockHash: "block_hash" })
|
|
130
|
+
)
|
|
131
|
+
})
|
|
132
|
+
|
|
133
|
+
// a felt holding an integer: a nonce, an amount of gas, a price
|
|
134
|
+
const BigIntFromFelt = Schema.String.check(Schema.isPattern(/^0x[0-9a-fA-F]{1,64}$/)).pipe(
|
|
135
|
+
Schema.decodeTo(
|
|
136
|
+
Schema.BigInt,
|
|
137
|
+
SchemaTransformation.transform({ decode: BigInt, encode: (value) => `0x${value.toString(16)}` })
|
|
138
|
+
)
|
|
139
|
+
)
|
|
140
|
+
|
|
141
|
+
const BlockTag = Schema.Literals(["latest", "pre_confirmed"])
|
|
142
|
+
|
|
143
|
+
const ResourceBound = Schema.Struct({ max_amount: BigIntFromFelt, max_price_per_unit: BigIntFromFelt })
|
|
144
|
+
|
|
145
|
+
const v3 = {
|
|
146
|
+
version: Schema.Literal("0x3"),
|
|
147
|
+
signature: Schema.Array(Felt),
|
|
148
|
+
nonce: BigIntFromFelt,
|
|
149
|
+
resource_bounds: Schema.Struct({ l1_gas: ResourceBound, l2_gas: ResourceBound, l1_data_gas: ResourceBound }),
|
|
150
|
+
tip: BigIntFromFelt,
|
|
151
|
+
paymaster_data: Schema.Tuple([]),
|
|
152
|
+
nonce_data_availability_mode: Schema.Literal("L1"),
|
|
153
|
+
fee_data_availability_mode: Schema.Literal("L1")
|
|
154
|
+
}
|
|
155
|
+
|
|
156
|
+
const InvokeTransaction = Schema.Struct({
|
|
157
|
+
type: Schema.Literal("INVOKE"),
|
|
158
|
+
sender_address: StarknetAddress,
|
|
159
|
+
calldata: Schema.Array(Felt),
|
|
160
|
+
account_deployment_data: Schema.Tuple([]),
|
|
161
|
+
...v3
|
|
162
|
+
})
|
|
163
|
+
|
|
164
|
+
const DeployAccountTransaction = Schema.Struct({
|
|
165
|
+
type: Schema.Literal("DEPLOY_ACCOUNT"),
|
|
166
|
+
class_hash: Felt,
|
|
167
|
+
contract_address_salt: Felt,
|
|
168
|
+
constructor_calldata: Schema.Array(Felt),
|
|
169
|
+
...v3
|
|
170
|
+
})
|
|
171
|
+
|
|
172
|
+
/** @internal */
|
|
173
|
+
export const getNonce = make({
|
|
174
|
+
name: "starknet_getNonce",
|
|
175
|
+
params: Schema.Struct({ block_id: BlockTag, contract_address: StarknetAddress }),
|
|
176
|
+
result: BigIntFromFelt
|
|
177
|
+
})
|
|
178
|
+
|
|
179
|
+
/** @internal */
|
|
180
|
+
export const estimateFee = make({
|
|
181
|
+
name: "starknet_estimateFee",
|
|
182
|
+
params: Schema.Struct({
|
|
183
|
+
request: Schema.NonEmptyArray(Schema.Union([InvokeTransaction, DeployAccountTransaction])),
|
|
184
|
+
simulation_flags: Schema.Array(Schema.Literal("SKIP_VALIDATE")),
|
|
185
|
+
block_id: BlockTag
|
|
186
|
+
}),
|
|
187
|
+
result: Schema.NonEmptyArray(
|
|
188
|
+
Schema.Struct({
|
|
189
|
+
l1GasConsumed: BigIntFromFelt,
|
|
190
|
+
l1GasPrice: BigIntFromFelt,
|
|
191
|
+
l1DataGasConsumed: BigIntFromFelt,
|
|
192
|
+
l1DataGasPrice: BigIntFromFelt,
|
|
193
|
+
l2GasConsumed: BigIntFromFelt,
|
|
194
|
+
l2GasPrice: BigIntFromFelt,
|
|
195
|
+
overallFee: BigIntFromFelt
|
|
196
|
+
}).pipe(Schema.encodeKeys({
|
|
197
|
+
l1GasConsumed: "l1_gas_consumed",
|
|
198
|
+
l1GasPrice: "l1_gas_price",
|
|
199
|
+
l1DataGasConsumed: "l1_data_gas_consumed",
|
|
200
|
+
l1DataGasPrice: "l1_data_gas_price",
|
|
201
|
+
l2GasConsumed: "l2_gas_consumed",
|
|
202
|
+
l2GasPrice: "l2_gas_price",
|
|
203
|
+
overallFee: "overall_fee"
|
|
204
|
+
}))
|
|
205
|
+
)
|
|
206
|
+
})
|
|
207
|
+
|
|
208
|
+
/** @internal */
|
|
209
|
+
export const addInvokeTransaction = make({
|
|
210
|
+
name: "starknet_addInvokeTransaction",
|
|
211
|
+
params: Schema.Struct({ invoke_transaction: InvokeTransaction }),
|
|
212
|
+
result: Schema.Struct({ transactionHash: StarknetTransactionHash }).pipe(
|
|
213
|
+
Schema.encodeKeys({ transactionHash: "transaction_hash" })
|
|
214
|
+
)
|
|
215
|
+
})
|
|
216
|
+
|
|
217
|
+
/** @internal */
|
|
218
|
+
export const addDeployAccountTransaction = make({
|
|
219
|
+
name: "starknet_addDeployAccountTransaction",
|
|
220
|
+
params: Schema.Struct({ deploy_account_transaction: DeployAccountTransaction }),
|
|
221
|
+
result: Schema.Struct({ transactionHash: StarknetTransactionHash, contractAddress: StarknetAddress }).pipe(
|
|
222
|
+
Schema.encodeKeys({ transactionHash: "transaction_hash", contractAddress: "contract_address" })
|
|
223
|
+
)
|
|
224
|
+
})
|
|
@@ -0,0 +1,64 @@
|
|
|
1
|
+
import * as Schema from "effect/Schema"
|
|
2
|
+
import { constants, EDAMode, hash } from "starknet"
|
|
3
|
+
import { StarknetAddress } from "../StarknetAddress.ts"
|
|
4
|
+
import type { StarknetDeployAccountTransaction, StarknetInvokeTransaction } from "../StarknetTransaction.ts"
|
|
5
|
+
import { StarknetTransactionHash } from "../StarknetTransactionHash.ts"
|
|
6
|
+
|
|
7
|
+
/**
|
|
8
|
+
* The address a `DEPLOY_ACCOUNT` transaction deploys to. Throws on a value that is not a felt.
|
|
9
|
+
*
|
|
10
|
+
* @internal
|
|
11
|
+
*/
|
|
12
|
+
export const deployAddress = (
|
|
13
|
+
transaction: Pick<StarknetDeployAccountTransaction, "classHash" | "contractAddressSalt" | "constructorCalldata">
|
|
14
|
+
): StarknetAddress =>
|
|
15
|
+
Schema.decodeSync(StarknetAddress)(
|
|
16
|
+
// an account deploys itself: the deployer address is 0
|
|
17
|
+
hash.calculateContractAddressFromHash(
|
|
18
|
+
transaction.contractAddressSalt,
|
|
19
|
+
transaction.classHash,
|
|
20
|
+
[...transaction.constructorCalldata],
|
|
21
|
+
0
|
|
22
|
+
)
|
|
23
|
+
)
|
|
24
|
+
|
|
25
|
+
/**
|
|
26
|
+
* The V3 transaction hash (Poseidon), which is what an account signs. Throws on a value that is not a felt.
|
|
27
|
+
*
|
|
28
|
+
* @internal
|
|
29
|
+
*/
|
|
30
|
+
export const transactionHash = (
|
|
31
|
+
transaction: Omit<StarknetInvokeTransaction, "signature"> | Omit<StarknetDeployAccountTransaction, "signature">
|
|
32
|
+
): StarknetTransactionHash => {
|
|
33
|
+
const { l1DataGas, l1Gas, l2Gas } = transaction.resourceBounds
|
|
34
|
+
const common = {
|
|
35
|
+
version: "0x3" as const,
|
|
36
|
+
chainId: constants.StarknetChainId[transaction.chainId],
|
|
37
|
+
nonce: transaction.nonce,
|
|
38
|
+
nonceDataAvailabilityMode: EDAMode.L1,
|
|
39
|
+
feeDataAvailabilityMode: EDAMode.L1,
|
|
40
|
+
resourceBounds: {
|
|
41
|
+
l1_gas: { max_amount: l1Gas.maxAmount, max_price_per_unit: l1Gas.maxPricePerUnit },
|
|
42
|
+
l2_gas: { max_amount: l2Gas.maxAmount, max_price_per_unit: l2Gas.maxPricePerUnit },
|
|
43
|
+
l1_data_gas: { max_amount: l1DataGas.maxAmount, max_price_per_unit: l1DataGas.maxPricePerUnit }
|
|
44
|
+
},
|
|
45
|
+
tip: transaction.tip,
|
|
46
|
+
paymasterData: []
|
|
47
|
+
}
|
|
48
|
+
return Schema.decodeSync(StarknetTransactionHash)(
|
|
49
|
+
transaction.type === "INVOKE"
|
|
50
|
+
? hash.calculateInvokeTransactionHash({
|
|
51
|
+
...common,
|
|
52
|
+
senderAddress: transaction.senderAddress,
|
|
53
|
+
compiledCalldata: [...transaction.calldata],
|
|
54
|
+
accountDeploymentData: []
|
|
55
|
+
})
|
|
56
|
+
: hash.calculateDeployAccountTransactionHash({
|
|
57
|
+
...common,
|
|
58
|
+
contractAddress: deployAddress(transaction),
|
|
59
|
+
classHash: transaction.classHash,
|
|
60
|
+
compiledConstructorCalldata: [...transaction.constructorCalldata],
|
|
61
|
+
salt: transaction.contractAddressSalt
|
|
62
|
+
})
|
|
63
|
+
)
|
|
64
|
+
}
|