@chainflip/sdk 0.2.16 → 0.2.18

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,7 +1,92 @@
1
- import { __name, isString, Chains, Assets, ChainflipNetworks, 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';
1
+ var __defProp = Object.defineProperty;
2
+ var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
3
+ var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
4
+ var __publicField = (obj, key, value) => {
5
+ __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
6
+ return value;
7
+ };
8
+
9
+ // ../shared/src/enums.ts
10
+ var arrayToMap = /* @__PURE__ */ __name((array) => Object.fromEntries(array.map((key) => [
11
+ key,
12
+ key
13
+ ])), "arrayToMap");
14
+ var Chains = arrayToMap([
15
+ "Bitcoin",
16
+ "Ethereum",
17
+ "Polkadot"
18
+ ]);
19
+ var Assets = arrayToMap([
20
+ "FLIP",
21
+ "USDC",
22
+ "DOT",
23
+ "ETH",
24
+ "BTC"
25
+ ]);
26
+ var ChainflipNetworks = arrayToMap([
27
+ "backspin",
28
+ "sisyphos",
29
+ "perseverance",
30
+ "mainnet"
31
+ ]);
32
+ var isTestnet = /* @__PURE__ */ __name((network) => network !== ChainflipNetworks.mainnet, "isTestnet");
33
+ var assetChains = {
34
+ [Assets.ETH]: Chains.Ethereum,
35
+ [Assets.FLIP]: Chains.Ethereum,
36
+ [Assets.USDC]: Chains.Ethereum,
37
+ [Assets.BTC]: Chains.Bitcoin,
38
+ [Assets.DOT]: Chains.Polkadot
39
+ };
40
+ var assetDecimals = {
41
+ [Assets.DOT]: 10,
42
+ [Assets.ETH]: 18,
43
+ [Assets.FLIP]: 18,
44
+ [Assets.USDC]: 6,
45
+ [Assets.BTC]: 8
46
+ };
47
+ var assetContractIds = {
48
+ // 0 is reservered for particular cross chain messaging scenarios where we want to pass
49
+ // through a message without making a swap.
50
+ [Assets.ETH]: 1,
51
+ [Assets.FLIP]: 2,
52
+ [Assets.USDC]: 3,
53
+ [Assets.DOT]: 4,
54
+ [Assets.BTC]: 5
55
+ };
56
+ var chainAssets = {
57
+ [Chains.Ethereum]: [
58
+ Assets.ETH,
59
+ Assets.USDC,
60
+ Assets.FLIP
61
+ ],
62
+ [Chains.Bitcoin]: [
63
+ Assets.BTC
64
+ ],
65
+ [Chains.Polkadot]: [
66
+ Assets.DOT
67
+ ]
68
+ };
69
+ var chainContractIds = {
70
+ [Chains.Ethereum]: 1,
71
+ [Chains.Polkadot]: 2,
72
+ [Chains.Bitcoin]: 3
73
+ };
74
+
75
+ // ../shared/src/guards.ts
76
+ var isString = /* @__PURE__ */ __name((value) => typeof value === "string", "isString");
77
+ var isNotNullish = /* @__PURE__ */ __name((value) => value !== null && value !== void 0, "isNotNullish");
78
+ function assert(condition, message) {
79
+ if (condition)
80
+ return;
81
+ const error = new Error(message);
82
+ if (error.stack) {
83
+ error.stack = error.stack.replace(/\n.+/, "\n");
84
+ }
85
+ throw error;
86
+ }
87
+ __name(assert, "assert");
88
+ var isTokenSwap = /* @__PURE__ */ __name((params) => params.srcAsset !== Assets.ETH, "isTokenSwap");
89
+ var isTokenCall = /* @__PURE__ */ __name((params) => params.srcAsset !== Assets.ETH, "isTokenCall");
5
90
 
6
91
  // ../../node_modules/.pnpm/zod@3.22.4/node_modules/zod/lib/index.mjs
7
92
  var util;
@@ -503,12 +588,12 @@ var handleResult = /* @__PURE__ */ __name((ctx, result) => {
503
588
  function processCreateParams(params) {
504
589
  if (!params)
505
590
  return {};
506
- const { errorMap: errorMap3, invalid_type_error, required_error, description } = params;
507
- if (errorMap3 && (invalid_type_error || required_error)) {
591
+ const { errorMap: errorMap2, invalid_type_error, required_error, description } = params;
592
+ if (errorMap2 && (invalid_type_error || required_error)) {
508
593
  throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
509
594
  }
510
- if (errorMap3)
511
- return { errorMap: errorMap3, description };
595
+ if (errorMap2)
596
+ return { errorMap: errorMap2, description };
512
597
  const customMap = /* @__PURE__ */ __name((iss, ctx) => {
513
598
  if (iss.code !== "invalid_type")
514
599
  return { message: ctx.defaultError };
@@ -3832,345 +3917,4 @@ var z = /* @__PURE__ */ Object.freeze({
3832
3917
  ZodError
3833
3918
  });
3834
3919
 
3835
- // ../shared/src/validation/segwitAddr.ts
3836
- var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
3837
- var GENERATOR = [
3838
- 996825010,
3839
- 642813549,
3840
- 513874426,
3841
- 1027748829,
3842
- 705979059
3843
- ];
3844
- var Encoding;
3845
- (function(Encoding2) {
3846
- Encoding2["Bech32"] = "bech32";
3847
- Encoding2["Bech32m"] = "bech32m";
3848
- })(Encoding || (Encoding = {}));
3849
- var bech32 = {
3850
- getEncodingConst(enc) {
3851
- if (enc === "bech32")
3852
- return 1;
3853
- if (enc === "bech32m")
3854
- return 734539939;
3855
- return null;
3856
- },
3857
- polymod(values) {
3858
- let chk = 1;
3859
- for (let p = 0; p < values.length; p += 1) {
3860
- const top = chk >> 25;
3861
- chk = (chk & 33554431) << 5 ^ values[p];
3862
- for (let i = 0; i < 5; i += 1) {
3863
- if (top >> i & 1) {
3864
- chk ^= GENERATOR[i];
3865
- }
3866
- }
3867
- }
3868
- return chk;
3869
- },
3870
- hrpExpand(hrp) {
3871
- const ret = [];
3872
- let p;
3873
- for (p = 0; p < hrp.length; p += 1) {
3874
- ret.push(hrp.charCodeAt(p) >> 5);
3875
- }
3876
- ret.push(0);
3877
- for (p = 0; p < hrp.length; p += 1) {
3878
- ret.push(hrp.charCodeAt(p) & 31);
3879
- }
3880
- return ret;
3881
- },
3882
- verifyChecksum(hrp, data, enc) {
3883
- return this.polymod(this.hrpExpand(hrp).concat(data)) === this.getEncodingConst(enc);
3884
- },
3885
- createChecksum(hrp, data, enc) {
3886
- const values = this.hrpExpand(hrp).concat(data).concat([
3887
- 0,
3888
- 0,
3889
- 0,
3890
- 0,
3891
- 0,
3892
- 0
3893
- ]);
3894
- const mod = this.polymod(values) ^ this.getEncodingConst(enc);
3895
- const ret = [];
3896
- for (let p = 0; p < 6; p += 1) {
3897
- ret.push(mod >> 5 * (5 - p) & 31);
3898
- }
3899
- return ret;
3900
- },
3901
- encode(hrp, data, enc) {
3902
- const combined = data.concat(this.createChecksum(hrp, data, enc));
3903
- let ret = `${hrp}1`;
3904
- for (let p = 0; p < combined.length; p += 1) {
3905
- ret += CHARSET.charAt(combined[p]);
3906
- }
3907
- return ret;
3908
- },
3909
- decode(bechString, enc) {
3910
- let p;
3911
- let hasLower = false;
3912
- let hasUpper = false;
3913
- for (p = 0; p < bechString.length; p += 1) {
3914
- if (bechString.charCodeAt(p) < 33 || bechString.charCodeAt(p) > 126) {
3915
- return null;
3916
- }
3917
- if (bechString.charCodeAt(p) >= 97 && bechString.charCodeAt(p) <= 122) {
3918
- hasLower = true;
3919
- }
3920
- if (bechString.charCodeAt(p) >= 65 && bechString.charCodeAt(p) <= 90) {
3921
- hasUpper = true;
3922
- }
3923
- }
3924
- if (hasLower && hasUpper)
3925
- return null;
3926
- const lowercase = bechString.toLowerCase();
3927
- const pos = lowercase.lastIndexOf("1");
3928
- if (pos < 1 || pos + 7 > lowercase.length || lowercase.length > 90) {
3929
- return null;
3930
- }
3931
- const hrp = lowercase.substring(0, pos);
3932
- const data = [];
3933
- for (p = pos + 1; p < lowercase.length; p += 1) {
3934
- const d = CHARSET.indexOf(lowercase.charAt(p));
3935
- if (d === -1)
3936
- return null;
3937
- data.push(d);
3938
- }
3939
- if (!this.verifyChecksum(hrp, data, enc)) {
3940
- return null;
3941
- }
3942
- return {
3943
- hrp,
3944
- data: data.slice(0, data.length - 6)
3945
- };
3946
- }
3947
- };
3948
- var segwitAddress = {
3949
- convertbits(data, frombits, tobits, pad) {
3950
- let acc = 0;
3951
- let bits = 0;
3952
- const ret = [];
3953
- const maxv = (1 << tobits) - 1;
3954
- for (let p = 0; p < data.length; p += 1) {
3955
- const value = data[p];
3956
- if (value < 0 || value >> frombits !== 0) {
3957
- return null;
3958
- }
3959
- acc = acc << frombits | value;
3960
- bits += frombits;
3961
- while (bits >= tobits) {
3962
- bits -= tobits;
3963
- ret.push(acc >> bits & maxv);
3964
- }
3965
- }
3966
- if (pad) {
3967
- if (bits > 0) {
3968
- ret.push(acc << tobits - bits & maxv);
3969
- }
3970
- } else if (bits >= frombits || acc << tobits - bits & maxv) {
3971
- return null;
3972
- }
3973
- return ret;
3974
- },
3975
- decode(hrp, addr) {
3976
- let bech32m = false;
3977
- let dec = bech32.decode(addr, "bech32");
3978
- if (dec === null) {
3979
- dec = bech32.decode(addr, "bech32m");
3980
- bech32m = true;
3981
- }
3982
- if (dec === null || dec.hrp !== hrp || dec.data.length < 1 || dec.data[0] > 16) {
3983
- return null;
3984
- }
3985
- const res = this.convertbits(dec.data.slice(1), 5, 8, false);
3986
- if (res === null || res.length < 2 || res.length > 40) {
3987
- return null;
3988
- }
3989
- if (dec.data[0] === 0 && res.length !== 20 && res.length !== 32) {
3990
- return null;
3991
- }
3992
- if (dec.data[0] === 0 && bech32m) {
3993
- return null;
3994
- }
3995
- if (dec.data[0] !== 0 && !bech32m) {
3996
- return null;
3997
- }
3998
- return {
3999
- version: dec.data[0],
4000
- program: res
4001
- };
4002
- },
4003
- encode(hrp, version, program) {
4004
- let enc = "bech32";
4005
- if (version > 0) {
4006
- enc = "bech32m";
4007
- }
4008
- const ret = bech32.encode(
4009
- hrp,
4010
- // @ts-expect-error can be null
4011
- [
4012
- version
4013
- ].concat(this.convertbits(program, 8, 5, true)),
4014
- enc
4015
- );
4016
- if (this.decode(hrp, ret) === null) {
4017
- return null;
4018
- }
4019
- return ret;
4020
- }
4021
- };
4022
- var isValidSegwitAddress = /* @__PURE__ */ __name((address) => {
4023
- const hrp = /^(bc|tb|bcrt)1/.exec(address)?.[1];
4024
- if (!hrp)
4025
- return false;
4026
- return segwitAddress.decode(hrp, address) !== null;
4027
- }, "isValidSegwitAddress");
4028
-
4029
- // ../shared/src/validation/addressValidation.ts
4030
- var assertArraylikeEqual = /* @__PURE__ */ __name((a, b) => {
4031
- assert(a.length === b.length, "arraylike lengths must be equal");
4032
- for (let i = 0; i < a.length; i += 1) {
4033
- assert(a[i] === b[i], "arraylike elements must be equal");
4034
- }
4035
- }, "assertArraylikeEqual");
4036
- var validateP2PKHOrP2SHAddress = /* @__PURE__ */ __name((address, network) => {
4037
- try {
4038
- const decoded = base58Decode(address);
4039
- assert(decoded.length === 25, "decoded address must be 25 bytes long");
4040
- if (network === "mainnet") {
4041
- assert(decoded[0] === 0 || decoded[0] === 5, "decoded address must start with 0x00 or 0x05");
4042
- } else {
4043
- assert(decoded[0] === 111 || decoded[0] === 196, "decoded address must start with 0x6f or 0xc4");
4044
- }
4045
- const checksum = decoded.slice(-4);
4046
- const doubleHash = ethers.getBytes(ethers.sha256(ethers.sha256(decoded.slice(0, 21))));
4047
- assertArraylikeEqual(checksum, doubleHash.slice(0, 4));
4048
- return true;
4049
- } catch (error) {
4050
- return false;
4051
- }
4052
- }, "validateP2PKHOrP2SHAddress");
4053
- var validateSegwitAddress = /* @__PURE__ */ __name((address, network) => {
4054
- try {
4055
- assert(
4056
- // On mainnet, the address must start with "bc1"
4057
- network === "mainnet" && address.startsWith("bc1") || // on testnet it must start with "tb1"
4058
- network === "testnet" && address.startsWith("tb1") || // on regtest it must start with "bcrt1"
4059
- network === "regtest" && address.startsWith("bcrt1"),
4060
- "address must start with bc1, tb1 or bcrt1"
4061
- );
4062
- return isValidSegwitAddress(address);
4063
- } catch {
4064
- return false;
4065
- }
4066
- }, "validateSegwitAddress");
4067
- var validateBitcoinAddress = /* @__PURE__ */ __name((address, network) => validateP2PKHOrP2SHAddress(address, network) || validateSegwitAddress(address, network), "validateBitcoinAddress");
4068
- var validateBitcoinMainnetAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "mainnet"), "validateBitcoinMainnetAddress");
4069
- var validateBitcoinTestnetAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "testnet"), "validateBitcoinTestnetAddress");
4070
- var validateBitcoinRegtestAddress = /* @__PURE__ */ __name((address) => validateBitcoinAddress(address, "regtest"), "validateBitcoinRegtestAddress");
4071
-
4072
- // ../shared/src/parsers.ts
4073
- var errorMap2 = /* @__PURE__ */ __name((_issue, context) => ({
4074
- message: `received: ${JSON.stringify(context.data)}`
4075
- }), "errorMap");
4076
- var string = z.string({
4077
- errorMap: errorMap2
4078
- });
4079
- z.number({
4080
- errorMap: errorMap2
4081
- });
4082
- var numericString = string.regex(/^[0-9]+$/);
4083
- var hexString = z.custom((val) => typeof val === "string" && /^0x[0-9a-f]+$/i.test(val));
4084
- var hexStringFromNumber = numericString.transform((arg) => `0x${BigInt(arg).toString(16)}`);
4085
- string.regex(/^[0-9a-f]+$/);
4086
- var btcAddress = /* @__PURE__ */ __name((env) => {
4087
- const network = env ?? process.env.CHAINFLIP_NETWORK;
4088
- if (network === "mainnet")
4089
- return string.regex(/^(1|3|bc1)/).refine(validateBitcoinMainnetAddress);
4090
- return z.union([
4091
- string.regex(/^(m|n|2|tb1)/).refine(validateBitcoinTestnetAddress),
4092
- string.regex(/^bcrt1/).refine(validateBitcoinRegtestAddress)
4093
- ]);
4094
- }, "btcAddress");
4095
- var dotAddress = z.union([
4096
- string,
4097
- hexString
4098
- ]).transform((arg) => {
4099
- try {
4100
- if (arg.startsWith("0x")) {
4101
- return encodeAddress(hexToU8a(arg));
4102
- }
4103
- decodeAddress(arg);
4104
- return arg;
4105
- } catch {
4106
- return null;
4107
- }
4108
- }).refine(isString);
4109
- var ethereumAddress = hexString.refine((address) => ethers.isAddress(address));
4110
- numericString.transform((arg) => BigInt(arg));
4111
- var u128 = z.union([
4112
- numericString,
4113
- hexString
4114
- ]).transform((arg) => BigInt(arg));
4115
- var unsignedInteger = z.union([
4116
- u128,
4117
- z.number().transform((n) => BigInt(n))
4118
- ]);
4119
- z.object({
4120
- __kind: z.enum([
4121
- "Usdc",
4122
- "Flip",
4123
- "Dot",
4124
- "Eth",
4125
- "Btc"
4126
- ])
4127
- }).transform(({ __kind }) => __kind.toUpperCase());
4128
- var chainflipChain = z.nativeEnum(Chains);
4129
- var chainflipAsset = z.nativeEnum(Assets);
4130
- z.nativeEnum(ChainflipNetworks);
4131
- z.union([
4132
- z.object({
4133
- __kind: z.literal("CcmPrincipal"),
4134
- value: unsignedInteger
4135
- }).transform(({ value: ccmId }) => ({
4136
- type: "PRINCIPAL",
4137
- ccmId
4138
- })),
4139
- z.object({
4140
- __kind: z.literal("CcmGas"),
4141
- value: unsignedInteger
4142
- }).transform(({ value: ccmId }) => ({
4143
- type: "GAS",
4144
- ccmId
4145
- })),
4146
- z.object({
4147
- __kind: z.literal("Swap")
4148
- }).transform(() => ({
4149
- type: "SWAP"
4150
- }))
4151
- ]);
4152
-
4153
- // ../shared/src/schemas.ts
4154
- z.object({
4155
- srcAsset: chainflipAsset,
4156
- destAsset: chainflipAsset,
4157
- amount: numericString
4158
- });
4159
- var ccmMetadataSchema = z.object({
4160
- gasBudget: numericString,
4161
- message: hexString
4162
- });
4163
- z.object({
4164
- srcAsset: chainflipAsset,
4165
- destAsset: chainflipAsset,
4166
- srcChain: chainflipChain,
4167
- destChain: chainflipChain,
4168
- destAddress: z.string(),
4169
- amount: numericString,
4170
- ccmMetadata: ccmMetadataSchema.optional()
4171
- }).transform(({ amount, ...rest }) => ({
4172
- ...rest,
4173
- expectedDepositAmount: amount
4174
- }));
4175
-
4176
- export { btcAddress, ccmMetadataSchema, chainflipAsset, dotAddress, ethereumAddress, hexString, hexStringFromNumber, numericString, unsignedInteger, z };
3920
+ export { Assets, ChainflipNetworks, Chains, __name, __publicField, assert, assetChains, assetContractIds, assetDecimals, chainAssets, chainContractIds, isNotNullish, isString, isTestnet, isTokenCall, isTokenSwap, z };
@@ -1,6 +1,123 @@
1
- import { __name, __publicField, ChainflipNetworks, Assets, assert } from './chunk-NX4K76K7.mjs';
1
+ import { z, ChainflipNetworks, __name, __publicField, assert, Assets } from './chunk-6B4B7WKD.mjs';
2
+ import axios from 'axios';
2
3
  import { Interface, Contract } from 'ethers';
3
4
 
5
+ var numberOrHex = z.union([
6
+ z.string(),
7
+ z.number()
8
+ ]).transform((str) => BigInt(str));
9
+ var camelCase = /* @__PURE__ */ __name((str) => str.replace(/_([a-z])/g, (_, char) => char.toUpperCase()), "camelCase");
10
+ var camelCaseKeys = /* @__PURE__ */ __name((obj) => {
11
+ if (typeof obj !== "object" || obj === null)
12
+ return obj;
13
+ return Object.fromEntries(Object.entries(obj).map(([key, value]) => [
14
+ camelCase(key),
15
+ camelCaseKeys(value)
16
+ ]));
17
+ }, "camelCaseKeys");
18
+ var RPC_URLS = {
19
+ [ChainflipNetworks.backspin]: "https://backspin-rpc.staging",
20
+ [ChainflipNetworks.sisyphos]: "https://sisyphos.chainflip.xyz",
21
+ [ChainflipNetworks.perseverance]: "https://perseverance.chainflip.xyz",
22
+ [ChainflipNetworks.mainnet]: "https://mainnet-rpc.chainflip.io"
23
+ };
24
+ var createRequest = /* @__PURE__ */ __name((method, responseParser, paramsParser) => async (urlOrNetwork, params) => {
25
+ const url = "network" in urlOrNetwork ? RPC_URLS[urlOrNetwork.network] : urlOrNetwork.rpcUrl;
26
+ const { data } = await axios.post(url, {
27
+ jsonrpc: "2.0",
28
+ method,
29
+ params: paramsParser?.parse(params),
30
+ id: 1
31
+ });
32
+ const result = responseParser.safeParse(data.result);
33
+ if (result.success) {
34
+ return camelCaseKeys(result.data);
35
+ }
36
+ throw new Error(`RPC request "${method}" failed`, {
37
+ cause: data.error
38
+ });
39
+ }, "createRequest");
40
+ var fundingEnvironment = z.object({
41
+ redemption_tax: numberOrHex,
42
+ minimum_funding_amount: numberOrHex
43
+ });
44
+ var getFundingEnvironment = createRequest("cf_funding_environment", fundingEnvironment);
45
+ var chainAssetMap = /* @__PURE__ */ __name((parser) => z.object({
46
+ Bitcoin: z.object({
47
+ BTC: parser
48
+ }),
49
+ Ethereum: z.object({
50
+ ETH: parser,
51
+ USDC: parser,
52
+ FLIP: parser
53
+ }),
54
+ Polkadot: z.object({
55
+ DOT: parser
56
+ })
57
+ }), "chainAssetMap");
58
+ var chainAssetNumberMap = chainAssetMap(numberOrHex);
59
+ var swappingEnvironment = z.object({
60
+ minimum_swap_amounts: chainAssetNumberMap
61
+ });
62
+ createRequest("cf_swapping_environment", swappingEnvironment);
63
+ var ingressEgressEnvironment = z.object({
64
+ minimum_deposit_amounts: chainAssetNumberMap
65
+ });
66
+ createRequest("cf_ingress_egress_environment", ingressEgressEnvironment);
67
+ var rpcAsset = z.union([
68
+ z.literal("BTC"),
69
+ z.object({
70
+ chain: z.literal("Bitcoin"),
71
+ asset: z.literal("BTC")
72
+ }),
73
+ z.literal("DOT"),
74
+ z.object({
75
+ chain: z.literal("Polkadot"),
76
+ asset: z.literal("DOT")
77
+ }),
78
+ z.literal("FLIP"),
79
+ z.object({
80
+ chain: z.literal("Ethereum"),
81
+ asset: z.literal("FLIP")
82
+ }),
83
+ z.literal("ETH"),
84
+ z.object({
85
+ chain: z.literal("Ethereum"),
86
+ asset: z.literal("ETH")
87
+ }),
88
+ z.literal("USDC"),
89
+ z.object({
90
+ chain: z.literal("Ethereum"),
91
+ asset: z.literal("USDC")
92
+ })
93
+ ]);
94
+ var poolInfo = z.object({
95
+ limit_order_fee_hundredth_pips: z.number(),
96
+ range_order_fee_hundredth_pips: z.number(),
97
+ pair_asset: rpcAsset
98
+ });
99
+ var feesInfo = z.object({
100
+ Bitcoin: z.object({
101
+ BTC: poolInfo
102
+ }),
103
+ Ethereum: z.object({
104
+ ETH: poolInfo,
105
+ FLIP: poolInfo
106
+ }),
107
+ Polkadot: z.object({
108
+ DOT: poolInfo
109
+ })
110
+ });
111
+ var poolsEnvironment = z.object({
112
+ fees: feesInfo
113
+ });
114
+ createRequest("cf_pool_info", poolsEnvironment);
115
+ var getEnvironment = createRequest("cf_environment", z.object({
116
+ ingress_egress: ingressEgressEnvironment,
117
+ swapping: swappingEnvironment,
118
+ funding: fundingEnvironment,
119
+ pools: poolsEnvironment
120
+ }));
4
121
  var _abi = [
5
122
  {
6
123
  inputs: [
@@ -1981,26 +2098,6 @@ var Vault__factory = _Vault__factory;
1981
2098
  ({
1982
2099
  [ChainflipNetworks.perseverance]: 100
1983
2100
  });
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
2101
  var GOERLI_USDC_CONTRACT_ADDRESS = "0x07865c6E87B9F70255377e024ace6630C1Eaa37F";
2005
2102
  var ADDRESSES = {
2006
2103
  [ChainflipNetworks.backspin]: {
@@ -2066,4 +2163,4 @@ var getFlipBalance = /* @__PURE__ */ __name(async (network, signer) => {
2066
2163
  return flip.balanceOf(await signer.getAddress());
2067
2164
  }, "getFlipBalance");
2068
2165
 
2069
- export { StateChainGateway__factory, Vault__factory, approve, checkAllowance, extractOverrides, getFlipBalance, getMinimumDepositAmount, getMinimumSwapAmount, getStateChainGatewayContractAddress, getTokenContractAddress, getVaultManagerContractAddress };
2166
+ export { StateChainGateway__factory, Vault__factory, approve, checkAllowance, extractOverrides, getEnvironment, getFlipBalance, getFundingEnvironment, getStateChainGatewayContractAddress, getTokenContractAddress, getVaultManagerContractAddress };
@@ -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 };