@chainflip/sdk 0.2.15 → 0.2.17

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.
@@ -1,14 +1,10 @@
1
- import { z, chainflipAsset, numericString, hexString, btcAddress, ccmMetadataSchema, hexStringFromNumber, dotAddress, unsignedInteger } from './chunk-DGDQYRRV.mjs';
1
+ import { chainflipAssetAndChain, numericString, hexString, btcAddress, ccmMetadataSchema, hexStringFromNumber, dotAddress, unsignedInteger, camelToSnakeCase } from './chunk-5DBPJECX.mjs';
2
2
  import { isNotNullish, __name, Assets } from './chunk-NX4K76K7.mjs';
3
3
  import { u8aToHex } from '@polkadot/util';
4
4
  import { decodeAddress } from '@polkadot/util-crypto';
5
5
  import axios from 'axios';
6
+ import { z } from 'zod';
6
7
 
7
- // ../shared/src/strings.ts
8
- var camelToSnakeCase = /* @__PURE__ */ __name((str) => str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`), "camelToSnakeCase");
9
- var transformAsset = /* @__PURE__ */ __name((asset) => asset[0] + asset.slice(1).toLowerCase(), "transformAsset");
10
-
11
- // ../shared/src/broker.ts
12
8
  var transformObjToSnakeCase = /* @__PURE__ */ __name((obj) => {
13
9
  if (!obj)
14
10
  return void 0;
@@ -40,8 +36,8 @@ var rpcResult = z.union([
40
36
  ]);
41
37
  var requestValidators = {
42
38
  requestSwapDepositAddress: z.tuple([
43
- chainflipAsset.transform(transformAsset),
44
- chainflipAsset.transform(transformAsset),
39
+ chainflipAssetAndChain,
40
+ chainflipAssetAndChain,
45
41
  z.union([
46
42
  numericString,
47
43
  hexString,
@@ -95,8 +91,14 @@ var makeRpcRequest = /* @__PURE__ */ __name(async (url, method, ...params) => {
95
91
  return responseValidators[method].parse(result.result);
96
92
  }, "makeRpcRequest");
97
93
  async function requestSwapDepositAddress(swapRequest, opts) {
98
- const { srcAsset, destAsset, destAddress } = swapRequest;
99
- return makeRpcRequest(opts.url, "requestSwapDepositAddress", srcAsset, destAsset, submitAddress(destAsset, destAddress), opts.commissionBps, swapRequest.ccmMetadata && {
94
+ const { srcAsset, srcChain, destAsset, destChain, destAddress } = swapRequest;
95
+ return makeRpcRequest(opts.url, "requestSwapDepositAddress", {
96
+ asset: srcAsset,
97
+ chain: srcChain
98
+ }, {
99
+ asset: destAsset,
100
+ chain: destChain
101
+ }, submitAddress(destAsset, destAddress), opts.commissionBps, swapRequest.ccmMetadata && {
100
102
  ...swapRequest.ccmMetadata,
101
103
  cfParameters: void 0
102
104
  });
@@ -1,6 +1,124 @@
1
- import { __name, __publicField, ChainflipNetworks, Assets, assert } from './chunk-NX4K76K7.mjs';
1
+ import { ChainflipNetworks, __name, __publicField, assert, Assets } from './chunk-NX4K76K7.mjs';
2
+ import axios from 'axios';
3
+ import { z } from 'zod';
2
4
  import { Interface, Contract } from 'ethers';
3
5
 
6
+ var numberOrHex = z.union([
7
+ z.string(),
8
+ z.number()
9
+ ]).transform((str) => BigInt(str));
10
+ var camelCase = /* @__PURE__ */ __name((str) => str.replace(/_([a-z])/g, (_, char) => char.toUpperCase()), "camelCase");
11
+ var camelCaseKeys = /* @__PURE__ */ __name((obj) => {
12
+ if (typeof obj !== "object" || obj === null)
13
+ return obj;
14
+ return Object.fromEntries(Object.entries(obj).map(([key, value]) => [
15
+ camelCase(key),
16
+ camelCaseKeys(value)
17
+ ]));
18
+ }, "camelCaseKeys");
19
+ var RPC_URLS = {
20
+ [ChainflipNetworks.backspin]: "https://backspin-rpc.staging",
21
+ [ChainflipNetworks.sisyphos]: "https://sisyphos.chainflip.xyz",
22
+ [ChainflipNetworks.perseverance]: "https://perseverance.chainflip.xyz",
23
+ [ChainflipNetworks.mainnet]: "https://mainnet-rpc.chainflip.io"
24
+ };
25
+ var createRequest = /* @__PURE__ */ __name((method, responseParser, paramsParser) => async (urlOrNetwork, params) => {
26
+ const url = "network" in urlOrNetwork ? RPC_URLS[urlOrNetwork.network] : urlOrNetwork.rpcUrl;
27
+ const { data } = await axios.post(url, {
28
+ jsonrpc: "2.0",
29
+ method,
30
+ params: paramsParser?.parse(params),
31
+ id: 1
32
+ });
33
+ const result = responseParser.safeParse(data.result);
34
+ if (result.success) {
35
+ return camelCaseKeys(result.data);
36
+ }
37
+ throw new Error(`RPC request "${method}" failed`, {
38
+ cause: data.error
39
+ });
40
+ }, "createRequest");
41
+ var fundingEnvironment = z.object({
42
+ redemption_tax: numberOrHex,
43
+ minimum_funding_amount: numberOrHex
44
+ });
45
+ var getFundingEnvironment = createRequest("cf_funding_environment", fundingEnvironment);
46
+ var chainAssetMap = /* @__PURE__ */ __name((parser) => z.object({
47
+ Bitcoin: z.object({
48
+ BTC: parser
49
+ }),
50
+ Ethereum: z.object({
51
+ ETH: parser,
52
+ USDC: parser,
53
+ FLIP: parser
54
+ }),
55
+ Polkadot: z.object({
56
+ DOT: parser
57
+ })
58
+ }), "chainAssetMap");
59
+ var chainAssetNumberMap = chainAssetMap(numberOrHex);
60
+ var swappingEnvironment = z.object({
61
+ minimum_swap_amounts: chainAssetNumberMap
62
+ });
63
+ createRequest("cf_swapping_environment", swappingEnvironment);
64
+ var ingressEgressEnvironment = z.object({
65
+ minimum_deposit_amounts: chainAssetNumberMap
66
+ });
67
+ createRequest("cf_ingress_egress_environment", ingressEgressEnvironment);
68
+ var rpcAsset = z.union([
69
+ z.literal("BTC"),
70
+ z.object({
71
+ chain: z.literal("Bitcoin"),
72
+ asset: z.literal("BTC")
73
+ }),
74
+ z.literal("DOT"),
75
+ z.object({
76
+ chain: z.literal("Polkadot"),
77
+ asset: z.literal("DOT")
78
+ }),
79
+ z.literal("FLIP"),
80
+ z.object({
81
+ chain: z.literal("Ethereum"),
82
+ asset: z.literal("FLIP")
83
+ }),
84
+ z.literal("ETH"),
85
+ z.object({
86
+ chain: z.literal("Ethereum"),
87
+ asset: z.literal("ETH")
88
+ }),
89
+ z.literal("USDC"),
90
+ z.object({
91
+ chain: z.literal("Ethereum"),
92
+ asset: z.literal("USDC")
93
+ })
94
+ ]);
95
+ var poolInfo = z.object({
96
+ limit_order_fee_hundredth_pips: z.number(),
97
+ range_order_fee_hundredth_pips: z.number(),
98
+ pair_asset: rpcAsset
99
+ });
100
+ var feesInfo = z.object({
101
+ Bitcoin: z.object({
102
+ BTC: poolInfo
103
+ }),
104
+ Ethereum: z.object({
105
+ ETH: poolInfo,
106
+ FLIP: poolInfo
107
+ }),
108
+ Polkadot: z.object({
109
+ DOT: poolInfo
110
+ })
111
+ });
112
+ var poolsEnvironment = z.object({
113
+ fees: feesInfo
114
+ });
115
+ createRequest("cf_pool_info", poolsEnvironment);
116
+ var getEnvironment = createRequest("cf_environment", z.object({
117
+ ingress_egress: ingressEgressEnvironment,
118
+ swapping: swappingEnvironment,
119
+ funding: fundingEnvironment,
120
+ pools: poolsEnvironment
121
+ }));
4
122
  var _abi = [
5
123
  {
6
124
  inputs: [
@@ -1981,26 +2099,6 @@ var Vault__factory = _Vault__factory;
1981
2099
  ({
1982
2100
  [ChainflipNetworks.perseverance]: 100
1983
2101
  });
1984
- var MINIMUM_DEPOSIT_AMOUNTS = {
1985
- [ChainflipNetworks.perseverance]: {
1986
- [Assets.ETH]: "0",
1987
- [Assets.FLIP]: "0",
1988
- [Assets.USDC]: "0",
1989
- [Assets.BTC]: "0",
1990
- [Assets.DOT]: "10000000000"
1991
- }
1992
- };
1993
- var getMinimumDepositAmount = /* @__PURE__ */ __name((network, asset) => MINIMUM_DEPOSIT_AMOUNTS[network]?.[asset] ?? "0", "getMinimumDepositAmount");
1994
- var MINIMUM_SWAP_AMOUNTS = {
1995
- [ChainflipNetworks.perseverance]: {
1996
- [Assets.ETH]: "580000000000000",
1997
- [Assets.FLIP]: "1000000000000000000",
1998
- [Assets.USDC]: "1000000",
1999
- [Assets.BTC]: "1000",
2000
- [Assets.DOT]: "2000000000"
2001
- }
2002
- };
2003
- var getMinimumSwapAmount = /* @__PURE__ */ __name((network, asset) => MINIMUM_SWAP_AMOUNTS[network]?.[asset] ?? "0", "getMinimumSwapAmount");
2004
2102
  var GOERLI_USDC_CONTRACT_ADDRESS = "0x07865c6E87B9F70255377e024ace6630C1Eaa37F";
2005
2103
  var ADDRESSES = {
2006
2104
  [ChainflipNetworks.backspin]: {
@@ -2066,4 +2164,4 @@ var getFlipBalance = /* @__PURE__ */ __name(async (network, signer) => {
2066
2164
  return flip.balanceOf(await signer.getAddress());
2067
2165
  }, "getFlipBalance");
2068
2166
 
2069
- export { StateChainGateway__factory, Vault__factory, approve, checkAllowance, extractOverrides, getFlipBalance, getMinimumDepositAmount, getMinimumSwapAmount, getStateChainGatewayContractAddress, getTokenContractAddress, getVaultManagerContractAddress };
2167
+ export { StateChainGateway__factory, Vault__factory, approve, checkAllowance, extractOverrides, getEnvironment, getFlipBalance, getFundingEnvironment, getStateChainGatewayContractAddress, getTokenContractAddress, getVaultManagerContractAddress };
@@ -0,0 +1,459 @@
1
+ import { isString, Chains, Assets, assetChains, ChainflipNetworks, __name, assert } from './chunk-NX4K76K7.mjs';
2
+ import { hexToU8a } from '@polkadot/util';
3
+ import { encodeAddress, decodeAddress, base58Decode } from '@polkadot/util-crypto';
4
+ import * as ethers from 'ethers';
5
+ import { z } from 'zod';
6
+
7
+ // ../shared/src/validation/segwitAddr.ts
8
+ var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
9
+ var GENERATOR = [
10
+ 996825010,
11
+ 642813549,
12
+ 513874426,
13
+ 1027748829,
14
+ 705979059
15
+ ];
16
+ var Encoding;
17
+ (function(Encoding2) {
18
+ Encoding2["Bech32"] = "bech32";
19
+ Encoding2["Bech32m"] = "bech32m";
20
+ })(Encoding || (Encoding = {}));
21
+ var bech32 = {
22
+ getEncodingConst(enc) {
23
+ if (enc === "bech32")
24
+ return 1;
25
+ if (enc === "bech32m")
26
+ return 734539939;
27
+ return null;
28
+ },
29
+ polymod(values) {
30
+ let chk = 1;
31
+ for (let p = 0; p < values.length; p += 1) {
32
+ const top = chk >> 25;
33
+ chk = (chk & 33554431) << 5 ^ values[p];
34
+ for (let i = 0; i < 5; i += 1) {
35
+ if (top >> i & 1) {
36
+ chk ^= GENERATOR[i];
37
+ }
38
+ }
39
+ }
40
+ return chk;
41
+ },
42
+ hrpExpand(hrp) {
43
+ const ret = [];
44
+ let p;
45
+ for (p = 0; p < hrp.length; p += 1) {
46
+ ret.push(hrp.charCodeAt(p) >> 5);
47
+ }
48
+ ret.push(0);
49
+ for (p = 0; p < hrp.length; p += 1) {
50
+ ret.push(hrp.charCodeAt(p) & 31);
51
+ }
52
+ return ret;
53
+ },
54
+ verifyChecksum(hrp, data, enc) {
55
+ return this.polymod(this.hrpExpand(hrp).concat(data)) === this.getEncodingConst(enc);
56
+ },
57
+ createChecksum(hrp, data, enc) {
58
+ const values = this.hrpExpand(hrp).concat(data).concat([
59
+ 0,
60
+ 0,
61
+ 0,
62
+ 0,
63
+ 0,
64
+ 0
65
+ ]);
66
+ const mod = this.polymod(values) ^ this.getEncodingConst(enc);
67
+ const ret = [];
68
+ for (let p = 0; p < 6; p += 1) {
69
+ ret.push(mod >> 5 * (5 - p) & 31);
70
+ }
71
+ return ret;
72
+ },
73
+ encode(hrp, data, enc) {
74
+ const combined = data.concat(this.createChecksum(hrp, data, enc));
75
+ let ret = `${hrp}1`;
76
+ for (let p = 0; p < combined.length; p += 1) {
77
+ ret += CHARSET.charAt(combined[p]);
78
+ }
79
+ return ret;
80
+ },
81
+ decode(bechString, enc) {
82
+ let p;
83
+ let hasLower = false;
84
+ let hasUpper = false;
85
+ for (p = 0; p < bechString.length; p += 1) {
86
+ if (bechString.charCodeAt(p) < 33 || bechString.charCodeAt(p) > 126) {
87
+ return null;
88
+ }
89
+ if (bechString.charCodeAt(p) >= 97 && bechString.charCodeAt(p) <= 122) {
90
+ hasLower = true;
91
+ }
92
+ if (bechString.charCodeAt(p) >= 65 && bechString.charCodeAt(p) <= 90) {
93
+ hasUpper = true;
94
+ }
95
+ }
96
+ if (hasLower && hasUpper)
97
+ return null;
98
+ const lowercase = bechString.toLowerCase();
99
+ const pos = lowercase.lastIndexOf("1");
100
+ if (pos < 1 || pos + 7 > lowercase.length || lowercase.length > 90) {
101
+ return null;
102
+ }
103
+ const hrp = lowercase.substring(0, pos);
104
+ const data = [];
105
+ for (p = pos + 1; p < lowercase.length; p += 1) {
106
+ const d = CHARSET.indexOf(lowercase.charAt(p));
107
+ if (d === -1)
108
+ return null;
109
+ data.push(d);
110
+ }
111
+ if (!this.verifyChecksum(hrp, data, enc)) {
112
+ return null;
113
+ }
114
+ return {
115
+ hrp,
116
+ data: data.slice(0, data.length - 6)
117
+ };
118
+ }
119
+ };
120
+ var segwitAddress = {
121
+ convertbits(data, frombits, tobits, pad) {
122
+ let acc = 0;
123
+ let bits = 0;
124
+ const ret = [];
125
+ const maxv = (1 << tobits) - 1;
126
+ for (let p = 0; p < data.length; p += 1) {
127
+ const value = data[p];
128
+ if (value < 0 || value >> frombits !== 0) {
129
+ return null;
130
+ }
131
+ acc = acc << frombits | value;
132
+ bits += frombits;
133
+ while (bits >= tobits) {
134
+ bits -= tobits;
135
+ ret.push(acc >> bits & maxv);
136
+ }
137
+ }
138
+ if (pad) {
139
+ if (bits > 0) {
140
+ ret.push(acc << tobits - bits & maxv);
141
+ }
142
+ } else if (bits >= frombits || acc << tobits - bits & maxv) {
143
+ return null;
144
+ }
145
+ return ret;
146
+ },
147
+ decode(hrp, addr) {
148
+ let bech32m = false;
149
+ let dec = bech32.decode(addr, "bech32");
150
+ if (dec === null) {
151
+ dec = bech32.decode(addr, "bech32m");
152
+ bech32m = true;
153
+ }
154
+ if (dec === null || dec.hrp !== hrp || dec.data.length < 1 || dec.data[0] > 16) {
155
+ return null;
156
+ }
157
+ const res = this.convertbits(dec.data.slice(1), 5, 8, false);
158
+ if (res === null || res.length < 2 || res.length > 40) {
159
+ return null;
160
+ }
161
+ if (dec.data[0] === 0 && res.length !== 20 && res.length !== 32) {
162
+ return null;
163
+ }
164
+ if (dec.data[0] === 0 && bech32m) {
165
+ return null;
166
+ }
167
+ if (dec.data[0] !== 0 && !bech32m) {
168
+ return null;
169
+ }
170
+ return {
171
+ version: dec.data[0],
172
+ program: res
173
+ };
174
+ },
175
+ encode(hrp, version, program) {
176
+ let enc = "bech32";
177
+ if (version > 0) {
178
+ enc = "bech32m";
179
+ }
180
+ const ret = bech32.encode(
181
+ hrp,
182
+ // @ts-expect-error can be null
183
+ [
184
+ version
185
+ ].concat(this.convertbits(program, 8, 5, true)),
186
+ enc
187
+ );
188
+ if (this.decode(hrp, ret) === null) {
189
+ return null;
190
+ }
191
+ return ret;
192
+ }
193
+ };
194
+ var isValidSegwitAddress = /* @__PURE__ */ __name((address) => {
195
+ const hrp = /^(bc|tb|bcrt)1/.exec(address)?.[1];
196
+ if (!hrp)
197
+ return false;
198
+ return segwitAddress.decode(hrp, address) !== null;
199
+ }, "isValidSegwitAddress");
200
+
201
+ // ../shared/src/validation/addressValidation.ts
202
+ var assertArraylikeEqual = /* @__PURE__ */ __name((a, b) => {
203
+ assert(a.length === b.length, "arraylike lengths must be equal");
204
+ for (let i = 0; i < a.length; i += 1) {
205
+ assert(a[i] === b[i], "arraylike elements must be equal");
206
+ }
207
+ }, "assertArraylikeEqual");
208
+ var validateP2PKHOrP2SHAddress = /* @__PURE__ */ __name((address, network) => {
209
+ try {
210
+ const decoded = base58Decode(address);
211
+ assert(decoded.length === 25, "decoded address must be 25 bytes long");
212
+ if (network === "mainnet") {
213
+ assert(decoded[0] === 0 || decoded[0] === 5, "decoded address must start with 0x00 or 0x05");
214
+ } else {
215
+ assert(decoded[0] === 111 || decoded[0] === 196, "decoded address must start with 0x6f or 0xc4");
216
+ }
217
+ const checksum = decoded.slice(-4);
218
+ const doubleHash = ethers.getBytes(ethers.sha256(ethers.sha256(decoded.slice(0, 21))));
219
+ assertArraylikeEqual(checksum, doubleHash.slice(0, 4));
220
+ return true;
221
+ } catch (error) {
222
+ return false;
223
+ }
224
+ }, "validateP2PKHOrP2SHAddress");
225
+ var validateSegwitAddress = /* @__PURE__ */ __name((address, network) => {
226
+ try {
227
+ assert(
228
+ // On mainnet, the address must start with "bc1"
229
+ network === "mainnet" && address.startsWith("bc1") || // on testnet it must start with "tb1"
230
+ network === "testnet" && address.startsWith("tb1") || // on regtest it must start with "bcrt1"
231
+ network === "regtest" && address.startsWith("bcrt1"),
232
+ "address must start with bc1, tb1 or bcrt1"
233
+ );
234
+ return isValidSegwitAddress(address);
235
+ } catch {
236
+ return false;
237
+ }
238
+ }, "validateSegwitAddress");
239
+ var validateBitcoinAddress = /* @__PURE__ */ __name((address, network) => validateP2PKHOrP2SHAddress(address, network) || validateSegwitAddress(address, network), "validateBitcoinAddress");
240
+ var validateBitcoinMainnetAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "mainnet"), "validateBitcoinMainnetAddress");
241
+ var validateBitcoinTestnetAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "testnet"), "validateBitcoinTestnetAddress");
242
+ var validateBitcoinRegtestAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "regtest"), "validateBitcoinRegtestAddress");
243
+
244
+ // ../shared/src/parsers.ts
245
+ var safeStringify = /* @__PURE__ */ __name((obj) => JSON.stringify(obj, (key, value) => typeof value === "bigint" ? value.toString() : value), "safeStringify");
246
+ var errorMap = /* @__PURE__ */ __name((_issue, context) => ({
247
+ message: `received: ${safeStringify(context.data)}`
248
+ }), "errorMap");
249
+ var string = z.string({
250
+ errorMap
251
+ });
252
+ var number = z.number({
253
+ errorMap
254
+ });
255
+ var numericString = string.regex(/^[0-9]+$/);
256
+ var hexString = z.custom((val) => typeof val === "string" && /^0x[0-9a-f]+$/i.test(val));
257
+ var hexStringFromNumber = numericString.transform((arg) => `0x${BigInt(arg).toString(16)}`);
258
+ string.regex(/^[0-9a-f]+$/);
259
+ var btcAddress = /* @__PURE__ */ __name((env) => {
260
+ const network = env ?? process.env.CHAINFLIP_NETWORK;
261
+ if (network === "mainnet")
262
+ return string.regex(/^(1|3|bc1)/).refine(validateBitcoinMainnetAddress);
263
+ return z.union([
264
+ string.regex(/^(m|n|2|tb1)/).refine(validateBitcoinTestnetAddress),
265
+ string.regex(/^bcrt1/).refine(validateBitcoinRegtestAddress)
266
+ ]);
267
+ }, "btcAddress");
268
+ var dotAddress = z.union([
269
+ string,
270
+ hexString
271
+ ]).transform((arg) => {
272
+ try {
273
+ if (arg.startsWith("0x")) {
274
+ return encodeAddress(hexToU8a(arg));
275
+ }
276
+ decodeAddress(arg);
277
+ return arg;
278
+ } catch {
279
+ return null;
280
+ }
281
+ }).refine(isString);
282
+ var ethereumAddress = hexString.refine((address) => ethers.isAddress(address));
283
+ numericString.transform((arg) => BigInt(arg));
284
+ var u128 = z.union([
285
+ numericString,
286
+ hexString
287
+ ]).transform((arg) => BigInt(arg));
288
+ var unsignedInteger = z.union([
289
+ u128,
290
+ z.number().transform((n) => BigInt(n))
291
+ ]);
292
+ z.object({
293
+ __kind: z.enum([
294
+ "Usdc",
295
+ "Flip",
296
+ "Dot",
297
+ "Eth",
298
+ "Btc"
299
+ ])
300
+ }).transform(({ __kind }) => __kind.toUpperCase());
301
+ var transformAsset = /* @__PURE__ */ __name((asset) => ({
302
+ asset,
303
+ chain: assetChains[asset]
304
+ }), "transformAsset");
305
+ var chainflipChain = z.nativeEnum(Chains);
306
+ var chainflipAsset = z.nativeEnum(Assets);
307
+ var chainflipAssetAndChain = z.union([
308
+ chainflipAsset.transform(transformAsset),
309
+ z.object({
310
+ asset: z.nativeEnum(Assets),
311
+ chain: z.nativeEnum(Chains)
312
+ })
313
+ ]).superRefine((obj, ctx) => {
314
+ if (assetChains[obj.asset] !== obj.chain) {
315
+ ctx.addIssue({
316
+ code: z.ZodIssueCode.custom,
317
+ message: `asset ${obj.asset} does not belong to chain ${obj.chain}`,
318
+ path: []
319
+ });
320
+ }
321
+ return z.NEVER;
322
+ });
323
+ z.nativeEnum(ChainflipNetworks);
324
+ z.union([
325
+ z.object({
326
+ __kind: z.literal("CcmPrincipal"),
327
+ value: unsignedInteger
328
+ }).transform(({ value: ccmId }) => ({
329
+ type: "PRINCIPAL",
330
+ ccmId
331
+ })),
332
+ z.object({
333
+ __kind: z.literal("CcmGas"),
334
+ value: unsignedInteger
335
+ }).transform(({ value: ccmId }) => ({
336
+ type: "GAS",
337
+ ccmId
338
+ })),
339
+ z.object({
340
+ __kind: z.literal("Swap")
341
+ }).transform(() => ({
342
+ type: "SWAP"
343
+ }))
344
+ ]);
345
+
346
+ // ../shared/src/strings.ts
347
+ var camelToSnakeCase = /* @__PURE__ */ __name((str) => str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`), "camelToSnakeCase");
348
+ var channelIdRegex = /^(?<issuedBlock>\d+)-(?<srcChain>[a-z]+)-(?<channelId>\d+)$/i;
349
+ z.object({
350
+ srcAsset: chainflipAssetAndChain,
351
+ destAsset: chainflipAssetAndChain,
352
+ amount: numericString
353
+ });
354
+ var ccmMetadataSchema = z.object({
355
+ gasBudget: numericString,
356
+ message: hexString
357
+ });
358
+ z.object({
359
+ srcAsset: chainflipAsset,
360
+ destAsset: chainflipAsset,
361
+ srcChain: chainflipChain,
362
+ destChain: chainflipChain,
363
+ destAddress: z.string(),
364
+ amount: numericString,
365
+ ccmMetadata: ccmMetadataSchema.optional()
366
+ }).transform(({ amount, ...rest }) => ({
367
+ ...rest,
368
+ expectedDepositAmount: amount
369
+ }));
370
+ var depositChannelIdRegex = z.string().regex(channelIdRegex);
371
+ var swapIdRegex = z.string().regex(/^\d+$/i);
372
+ var txHashRegex = z.string().regex(/^0x[a-f\d]+$/i);
373
+ var swapStatusId = z.union([
374
+ depositChannelIdRegex,
375
+ swapIdRegex,
376
+ txHashRegex
377
+ ]);
378
+ z.object({
379
+ id: swapStatusId
380
+ });
381
+ var swapState = z.enum([
382
+ "AWAITING_DEPOSIT",
383
+ "DEPOSIT_RECEIVED",
384
+ "SWAP_EXECUTED",
385
+ "EGRESS_SCHEDULED",
386
+ "BROADCAST_REQUESTED",
387
+ "BROADCAST_ABORTED",
388
+ "COMPLETE"
389
+ ]);
390
+ var baseSwapResponseSchema = z.object({
391
+ srcChain: chainflipChain,
392
+ destChain: chainflipChain,
393
+ srcAsset: chainflipAsset,
394
+ destAsset: chainflipAsset,
395
+ destAddress: string.optional(),
396
+ depositAddress: string.optional(),
397
+ depositChannelCreatedAt: number.optional(),
398
+ expectedDepositAmount: string.optional(),
399
+ depositChannelExpiryBlock: z.bigint().optional().nullable(),
400
+ estimatedDepositChannelExpiryTime: number.optional(),
401
+ isDepositChannelExpired: z.boolean(),
402
+ ccmDepositReceivedBlockIndex: string.optional().nullable(),
403
+ ccmMetadata: z.object({
404
+ gasBudget: string,
405
+ message: string.nullable()
406
+ }).optional().nullable()
407
+ });
408
+ var awaitingState = baseSwapResponseSchema.extend({
409
+ state: swapState.refine((state) => state === swapState.Enum.AWAITING_DEPOSIT),
410
+ depositAmount: string.optional(),
411
+ depositTransactionHash: string.optional(),
412
+ depositTransactionConfirmations: number.optional()
413
+ });
414
+ var depositReceivedState = awaitingState.extend({
415
+ state: swapState.refine((state) => state === swapState.Enum.DEPOSIT_RECEIVED),
416
+ swapId: string,
417
+ depositAmount: string,
418
+ depositReceivedAt: number,
419
+ depositReceivedBlockIndex: string
420
+ });
421
+ var swapExecutedState = depositReceivedState.extend({
422
+ state: swapState.refine((state) => state === swapState.Enum.SWAP_EXECUTED),
423
+ intermediateAmount: string.optional(),
424
+ swapExecutedAt: number,
425
+ swapExecutedBlockIndex: string
426
+ });
427
+ var egressScheduledState = swapExecutedState.extend({
428
+ state: swapState.refine((state) => state === swapState.Enum.EGRESS_SCHEDULED),
429
+ egressAmount: string,
430
+ egressScheduledAt: number,
431
+ egressScheduledBlockIndex: string
432
+ });
433
+ var broadcastRequestedState = egressScheduledState.extend({
434
+ state: swapState.refine((state) => state === swapState.Enum.BROADCAST_REQUESTED),
435
+ broadcastRequestedAt: number,
436
+ broadcastRequestedBlockIndex: string
437
+ });
438
+ var broadcastAbortedState = broadcastRequestedState.extend({
439
+ state: swapState.refine((state) => state === swapState.Enum.BROADCAST_ABORTED),
440
+ broadcastAbortedAt: number,
441
+ broadcastAbortedBlockIndex: string
442
+ });
443
+ var broadcastSucceededState = broadcastRequestedState.extend({
444
+ state: swapState.refine((state) => state === swapState.Enum.COMPLETE),
445
+ swapExecutedBlockIndex: string,
446
+ broadcastSucceededAt: number,
447
+ broadcastSucceededBlockIndex: string
448
+ });
449
+ z.union([
450
+ awaitingState,
451
+ depositReceivedState,
452
+ swapExecutedState,
453
+ egressScheduledState,
454
+ broadcastRequestedState,
455
+ broadcastAbortedState,
456
+ broadcastSucceededState
457
+ ]);
458
+
459
+ export { btcAddress, camelToSnakeCase, ccmMetadataSchema, chainflipAssetAndChain, dotAddress, ethereumAddress, hexString, hexStringFromNumber, numericString, unsignedInteger };
@@ -11,10 +11,13 @@ type PendingRedemption = {
11
11
  type FundingSDKOption = {
12
12
  network?: Exclude<ChainflipNetwork, 'mainnet'>;
13
13
  signer: Signer;
14
+ rpcUrl?: string;
14
15
  };
15
16
  type TransactionHash = `0x${string}`;
16
17
  declare class FundingSDK {
17
18
  private readonly options;
19
+ private readonly rpcConfig;
20
+ private redemptionTax?;
18
21
  constructor(options: FundingSDKOption);
19
22
  fundStateChainAccount(accountId: `0x${string}`, amount: bigint, txOpts?: TransactionOptions): Promise<TransactionHash>;
20
23
  executeRedemption(accountId: `0x${string}`, txOpts?: TransactionOptions): Promise<TransactionHash>;
@@ -23,6 +26,7 @@ declare class FundingSDK {
23
26
  getFlipBalance(): Promise<bigint>;
24
27
  getPendingRedemption(accountId: `0x${string}`): Promise<PendingRedemption | undefined>;
25
28
  approveStateChainGateway(amount: bigint, txOpts?: TransactionOptions): Promise<TransactionHash | null>;
29
+ getRedemptionTax(): Promise<bigint>;
26
30
  }
27
31
 
28
32
  export { FundingSDK, FundingSDKOption, PendingRedemption };
package/dist/funding.d.ts CHANGED
@@ -11,10 +11,13 @@ type PendingRedemption = {
11
11
  type FundingSDKOption = {
12
12
  network?: Exclude<ChainflipNetwork, 'mainnet'>;
13
13
  signer: Signer;
14
+ rpcUrl?: string;
14
15
  };
15
16
  type TransactionHash = `0x${string}`;
16
17
  declare class FundingSDK {
17
18
  private readonly options;
19
+ private readonly rpcConfig;
20
+ private redemptionTax?;
18
21
  constructor(options: FundingSDKOption);
19
22
  fundStateChainAccount(accountId: `0x${string}`, amount: bigint, txOpts?: TransactionOptions): Promise<TransactionHash>;
20
23
  executeRedemption(accountId: `0x${string}`, txOpts?: TransactionOptions): Promise<TransactionHash>;
@@ -23,6 +26,7 @@ declare class FundingSDK {
23
26
  getFlipBalance(): Promise<bigint>;
24
27
  getPendingRedemption(accountId: `0x${string}`): Promise<PendingRedemption | undefined>;
25
28
  approveStateChainGateway(amount: bigint, txOpts?: TransactionOptions): Promise<TransactionHash | null>;
29
+ getRedemptionTax(): Promise<bigint>;
26
30
  }
27
31
 
28
32
  export { FundingSDK, FundingSDKOption, PendingRedemption };