@chainflip/sdk 0.1.11 → 0.1.13

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/dist/funding.js CHANGED
@@ -928,11 +928,9 @@ var fundStateChainAccount = /* @__PURE__ */ __name(async (accountId, amount, opt
928
928
  });
929
929
  return transaction.wait(1);
930
930
  }, "fundStateChainAccount");
931
- var executeRedemption = /* @__PURE__ */ __name(async (accountId, { nonce, ...options }) => {
931
+ var executeRedemption = /* @__PURE__ */ __name(async (accountId, options) => {
932
932
  const stateChainGateway = getStateChainGateway(options);
933
- const transaction = await stateChainGateway.executeRedemption(accountId, {
934
- nonce
935
- });
933
+ const transaction = await stateChainGateway.executeRedemption(accountId, options);
936
934
  return transaction.wait(1);
937
935
  }, "executeRedemption");
938
936
  var getMinimumFunding = /* @__PURE__ */ __name((options) => {
package/dist/funding.mjs CHANGED
@@ -32,11 +32,9 @@ var fundStateChainAccount = /* @__PURE__ */ __name(async (accountId, amount, opt
32
32
  });
33
33
  return transaction.wait(1);
34
34
  }, "fundStateChainAccount");
35
- var executeRedemption = /* @__PURE__ */ __name(async (accountId, { nonce, ...options }) => {
35
+ var executeRedemption = /* @__PURE__ */ __name(async (accountId, options) => {
36
36
  const stateChainGateway = getStateChainGateway(options);
37
- const transaction = await stateChainGateway.executeRedemption(accountId, {
38
- nonce
39
- });
37
+ const transaction = await stateChainGateway.executeRedemption(accountId, options);
40
38
  return transaction.wait(1);
41
39
  }, "executeRedemption");
42
40
  var getMinimumFunding = /* @__PURE__ */ __name((options) => {
package/dist/swap.d.ts CHANGED
@@ -1,4 +1,4 @@
1
- import { Signer } from 'ethers';
1
+ import ethers, { Signer } from 'ethers';
2
2
  import { C as Chain, c as chainAssets, A as Asset, a as ChainflipNetwork } from './enums-d5fa72fa.js';
3
3
  export { d as Assets, e as ChainflipNetworks, b as Chains, f as assetChains, h as assetContractIds, g as assetDecimals, i as chainContractIds } from './enums-d5fa72fa.js';
4
4
  import { z } from 'zod';
@@ -88,8 +88,124 @@ declare const tokenSwapParamsSchema: z.ZodUnion<[z.ZodObject<{
88
88
  destAddress: string;
89
89
  destAsset: "BTC";
90
90
  }>]>;
91
- type TokenSwapParams = z.infer<typeof tokenSwapParamsSchema>;
92
- declare const executeSwapParamsSchema: z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
91
+ declare const executeSwapParamsSchema: z.ZodUnion<[z.ZodObject<{
92
+ amount: z.ZodUnion<[z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, z.ZodBigInt]>;
93
+ srcChain: z.ZodLiteral<"Ethereum">;
94
+ srcAsset: z.ZodLiteral<"ETH">;
95
+ destChain: z.ZodLiteral<"Ethereum">;
96
+ destAddress: z.ZodEffects<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, `0x${string}`, `0x${string}`>;
97
+ destAsset: z.ZodUnion<[z.ZodLiteral<"FLIP">, z.ZodLiteral<"USDC">]>;
98
+ ccmMetadata: z.ZodObject<{
99
+ message: z.ZodString;
100
+ gasBudget: z.ZodString;
101
+ }, "strip", z.ZodTypeAny, {
102
+ message: string;
103
+ gasBudget: string;
104
+ }, {
105
+ message: string;
106
+ gasBudget: string;
107
+ }>;
108
+ }, "strip", z.ZodTypeAny, {
109
+ amount: string | bigint;
110
+ srcChain: "Ethereum";
111
+ srcAsset: "ETH";
112
+ destChain: "Ethereum";
113
+ destAddress: `0x${string}`;
114
+ destAsset: "FLIP" | "USDC";
115
+ ccmMetadata: {
116
+ message: string;
117
+ gasBudget: string;
118
+ };
119
+ }, {
120
+ amount: string | bigint;
121
+ srcChain: "Ethereum";
122
+ srcAsset: "ETH";
123
+ destChain: "Ethereum";
124
+ destAddress: `0x${string}`;
125
+ destAsset: "FLIP" | "USDC";
126
+ ccmMetadata: {
127
+ message: string;
128
+ gasBudget: string;
129
+ };
130
+ }>, z.ZodUnion<[z.ZodObject<{
131
+ amount: z.ZodUnion<[z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, z.ZodBigInt]>;
132
+ srcChain: z.ZodLiteral<"Ethereum">;
133
+ destChain: z.ZodLiteral<"Ethereum">;
134
+ destAddress: z.ZodEffects<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, `0x${string}`, `0x${string}`>;
135
+ srcAsset: z.ZodLiteral<"FLIP">;
136
+ destAsset: z.ZodUnion<[z.ZodLiteral<"USDC">, z.ZodLiteral<"ETH">]>;
137
+ ccmMetadata: z.ZodObject<{
138
+ message: z.ZodString;
139
+ gasBudget: z.ZodString;
140
+ }, "strip", z.ZodTypeAny, {
141
+ message: string;
142
+ gasBudget: string;
143
+ }, {
144
+ message: string;
145
+ gasBudget: string;
146
+ }>;
147
+ }, "strip", z.ZodTypeAny, {
148
+ amount: string | bigint;
149
+ srcChain: "Ethereum";
150
+ srcAsset: "FLIP";
151
+ destChain: "Ethereum";
152
+ destAddress: `0x${string}`;
153
+ destAsset: "USDC" | "ETH";
154
+ ccmMetadata: {
155
+ message: string;
156
+ gasBudget: string;
157
+ };
158
+ }, {
159
+ amount: string | bigint;
160
+ srcChain: "Ethereum";
161
+ srcAsset: "FLIP";
162
+ destChain: "Ethereum";
163
+ destAddress: `0x${string}`;
164
+ destAsset: "USDC" | "ETH";
165
+ ccmMetadata: {
166
+ message: string;
167
+ gasBudget: string;
168
+ };
169
+ }>, z.ZodObject<{
170
+ amount: z.ZodUnion<[z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, z.ZodBigInt]>;
171
+ srcChain: z.ZodLiteral<"Ethereum">;
172
+ destChain: z.ZodLiteral<"Ethereum">;
173
+ destAddress: z.ZodEffects<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, `0x${string}`, `0x${string}`>;
174
+ srcAsset: z.ZodLiteral<"USDC">;
175
+ destAsset: z.ZodUnion<[z.ZodLiteral<"FLIP">, z.ZodLiteral<"ETH">]>;
176
+ ccmMetadata: z.ZodObject<{
177
+ message: z.ZodString;
178
+ gasBudget: z.ZodString;
179
+ }, "strip", z.ZodTypeAny, {
180
+ message: string;
181
+ gasBudget: string;
182
+ }, {
183
+ message: string;
184
+ gasBudget: string;
185
+ }>;
186
+ }, "strip", z.ZodTypeAny, {
187
+ amount: string | bigint;
188
+ srcChain: "Ethereum";
189
+ srcAsset: "USDC";
190
+ destChain: "Ethereum";
191
+ destAddress: `0x${string}`;
192
+ destAsset: "FLIP" | "ETH";
193
+ ccmMetadata: {
194
+ message: string;
195
+ gasBudget: string;
196
+ };
197
+ }, {
198
+ amount: string | bigint;
199
+ srcChain: "Ethereum";
200
+ srcAsset: "USDC";
201
+ destChain: "Ethereum";
202
+ destAddress: `0x${string}`;
203
+ destAsset: "FLIP" | "ETH";
204
+ ccmMetadata: {
205
+ message: string;
206
+ gasBudget: string;
207
+ };
208
+ }>]>, z.ZodUnion<[z.ZodObject<{
93
209
  amount: z.ZodUnion<[z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, z.ZodBigInt]>;
94
210
  srcChain: z.ZodLiteral<"Ethereum">;
95
211
  srcAsset: z.ZodLiteral<"ETH">;
@@ -238,113 +354,8 @@ declare const executeSwapParamsSchema: z.ZodUnion<[z.ZodUnion<[z.ZodObject<{
238
354
  destAsset: "BTC";
239
355
  }>]>]>;
240
356
  type ExecuteSwapParams = z.infer<typeof executeSwapParamsSchema>;
241
- declare const executeCallParamsSchema: z.ZodUnion<[z.ZodObject<{
242
- amount: z.ZodUnion<[z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, z.ZodBigInt]>;
243
- srcChain: z.ZodLiteral<"Ethereum">;
244
- srcAsset: z.ZodLiteral<"ETH">;
245
- destChain: z.ZodLiteral<"Ethereum">;
246
- destAddress: z.ZodEffects<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, `0x${string}`, `0x${string}`>;
247
- destAsset: z.ZodUnion<[z.ZodLiteral<"FLIP">, z.ZodLiteral<"USDC">]>;
248
- message: z.ZodString;
249
- gasBudget: z.ZodString;
250
- }, "strip", z.ZodTypeAny, {
251
- amount: string | bigint;
252
- message: string;
253
- srcChain: "Ethereum";
254
- srcAsset: "ETH";
255
- destChain: "Ethereum";
256
- destAddress: `0x${string}`;
257
- destAsset: "FLIP" | "USDC";
258
- gasBudget: string;
259
- }, {
260
- amount: string | bigint;
261
- message: string;
262
- srcChain: "Ethereum";
263
- srcAsset: "ETH";
264
- destChain: "Ethereum";
265
- destAddress: `0x${string}`;
266
- destAsset: "FLIP" | "USDC";
267
- gasBudget: string;
268
- }>, z.ZodUnion<[z.ZodObject<{
269
- amount: z.ZodUnion<[z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, z.ZodBigInt]>;
270
- srcChain: z.ZodLiteral<"Ethereum">;
271
- destChain: z.ZodLiteral<"Ethereum">;
272
- destAddress: z.ZodEffects<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, `0x${string}`, `0x${string}`>;
273
- srcAsset: z.ZodLiteral<"FLIP">;
274
- destAsset: z.ZodUnion<[z.ZodLiteral<"USDC">, z.ZodLiteral<"ETH">]>;
275
- ccmMetadata: z.ZodObject<{
276
- message: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
277
- gasBudget: z.ZodString;
278
- }, "strip", z.ZodTypeAny, {
279
- message: `0x${string}`;
280
- gasBudget: string;
281
- }, {
282
- message: `0x${string}`;
283
- gasBudget: string;
284
- }>;
285
- }, "strip", z.ZodTypeAny, {
286
- amount: string | bigint;
287
- srcChain: "Ethereum";
288
- srcAsset: "FLIP";
289
- destChain: "Ethereum";
290
- destAddress: `0x${string}`;
291
- destAsset: "USDC" | "ETH";
292
- ccmMetadata: {
293
- message: `0x${string}`;
294
- gasBudget: string;
295
- };
296
- }, {
297
- amount: string | bigint;
298
- srcChain: "Ethereum";
299
- srcAsset: "FLIP";
300
- destChain: "Ethereum";
301
- destAddress: `0x${string}`;
302
- destAsset: "USDC" | "ETH";
303
- ccmMetadata: {
304
- message: `0x${string}`;
305
- gasBudget: string;
306
- };
307
- }>, z.ZodObject<{
308
- amount: z.ZodUnion<[z.ZodString, z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, z.ZodBigInt]>;
309
- srcChain: z.ZodLiteral<"Ethereum">;
310
- destChain: z.ZodLiteral<"Ethereum">;
311
- destAddress: z.ZodEffects<z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, `0x${string}`, `0x${string}`>;
312
- srcAsset: z.ZodLiteral<"USDC">;
313
- destAsset: z.ZodUnion<[z.ZodLiteral<"FLIP">, z.ZodLiteral<"ETH">]>;
314
- ccmMetadata: z.ZodObject<{
315
- message: z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>;
316
- gasBudget: z.ZodString;
317
- }, "strip", z.ZodTypeAny, {
318
- message: `0x${string}`;
319
- gasBudget: string;
320
- }, {
321
- message: `0x${string}`;
322
- gasBudget: string;
323
- }>;
324
- }, "strip", z.ZodTypeAny, {
325
- amount: string | bigint;
326
- srcChain: "Ethereum";
327
- srcAsset: "USDC";
328
- destChain: "Ethereum";
329
- destAddress: `0x${string}`;
330
- destAsset: "FLIP" | "ETH";
331
- ccmMetadata: {
332
- message: `0x${string}`;
333
- gasBudget: string;
334
- };
335
- }, {
336
- amount: string | bigint;
337
- srcChain: "Ethereum";
338
- srcAsset: "USDC";
339
- destChain: "Ethereum";
340
- destAddress: `0x${string}`;
341
- destAsset: "FLIP" | "ETH";
342
- ccmMetadata: {
343
- message: `0x${string}`;
344
- gasBudget: string;
345
- };
346
- }>]>]>;
347
- type ExecuteCallParams = z.infer<typeof executeCallParamsSchema>;
357
+ type TokenSwapParams = z.infer<typeof tokenSwapParamsSchema>;
358
+ type Overrides = Omit<ethers.providers.TransactionRequest, 'to' | 'data' | 'value' | 'from'>;
348
359
 
349
360
  declare const ccmMetadataSchema: z.ZodObject<{
350
361
  gasBudget: z.ZodUnion<[z.ZodType<`0x${string}`, z.ZodTypeDef, `0x${string}`>, z.ZodNumber]>;
@@ -537,11 +548,8 @@ declare class SwapSDK {
537
548
  getQuote(quoteRequest: QuoteRequest, options?: RequestOptions): Promise<QuoteResponse>;
538
549
  requestDepositAddress(depositAddressRequest: DepositAddressRequest, options?: RequestOptions): Promise<DepositAddressResponse>;
539
550
  getStatus(swapStatusRequest: SwapStatusRequest, options?: RequestOptions): Promise<SwapStatusResponse>;
540
- executeSwap(params: ExecuteSwapParams): Promise<TransactionHash>;
541
- executeCall(params: ExecuteCallParams): Promise<TransactionHash>;
542
- approveVault(params: Pick<TokenSwapParams, 'srcAsset' | 'amount'>, options?: {
543
- nonce?: bigint | number | string;
544
- }): Promise<TransactionHash | null>;
551
+ executeSwap(params: ExecuteSwapParams, overrides?: Overrides): Promise<TransactionHash>;
552
+ approveVault(params: Pick<TokenSwapParams, 'srcAsset' | 'amount'>, overrides?: Overrides): Promise<TransactionHash | null>;
545
553
  }
546
554
 
547
555
  export { Asset, AssetData, Chain, ChainData, ChainflipNetwork, DepositAddressRequest, DepositAddressResponse, QuoteRequest, QuoteResponse, SDKOptions, SwapSDK, SwapStatusRequest, SwapStatusResponse, chainAssets };
package/dist/swap.js CHANGED
@@ -1854,17 +1854,8 @@ var tokenSwapParamsSchema = zod.z.union([
1854
1854
  srcAsset: erc20
1855
1855
  })
1856
1856
  ]);
1857
- var executeSwapParamsSchema = zod.z.union([
1858
- nativeSwapParamsSchema,
1859
- tokenSwapParamsSchema
1860
- ]);
1861
- var nativeCallParamsSchema = ethereumBase.extend({
1862
- destAsset: erc20,
1863
- message: zod.z.string(),
1864
- gasBudget: numericString
1865
- });
1866
1857
  var ccmMetadataSchema = zod.z.object({
1867
- message: hexString,
1858
+ message: zod.z.string(),
1868
1859
  gasBudget: numericString
1869
1860
  });
1870
1861
  var tokenCallParamsSchema = zod.z.union([
@@ -1885,85 +1876,78 @@ var tokenCallParamsSchema = zod.z.union([
1885
1876
  ccmMetadata: ccmMetadataSchema
1886
1877
  })
1887
1878
  ]);
1888
- var executeCallParamsSchema = zod.z.union([
1879
+ var nativeCallParamsSchema = ethereumBase.extend({
1880
+ destAsset: erc20,
1881
+ ccmMetadata: ccmMetadataSchema
1882
+ });
1883
+ var executeSwapParamsSchema = zod.z.union([
1884
+ // call schemas needs to precede swap schemas
1889
1885
  nativeCallParamsSchema,
1890
- tokenCallParamsSchema
1886
+ tokenCallParamsSchema,
1887
+ nativeSwapParamsSchema,
1888
+ tokenSwapParamsSchema
1891
1889
  ]);
1892
1890
  var executeOptionsSchema = zod.z.intersection(zod.z.object({
1893
- signer: zod.z.instanceof(ethers.Signer),
1894
- nonce: zod.z.union([
1895
- zod.z.number(),
1896
- zod.z.bigint(),
1897
- zod.z.string()
1898
- ]).optional()
1899
- }), zod.z.union([
1891
+ signer: zod.z.instanceof(ethers.Signer)
1892
+ }).passthrough(), zod.z.union([
1900
1893
  zod.z.object({
1901
1894
  network: chainflipNetwork
1902
- }),
1895
+ }).passthrough(),
1903
1896
  zod.z.object({
1904
1897
  network: zod.z.literal("localnet"),
1905
1898
  vaultContractAddress: zod.z.string(),
1906
1899
  srcTokenContractAddress: zod.z.string().optional()
1907
- })
1900
+ }).passthrough()
1908
1901
  ]));
1909
1902
 
1910
1903
  // ../shared/src/vault/executeSwap.ts
1911
- var swapNative = /* @__PURE__ */ __name(async ({ destChain, destAsset, destAddress, amount }, { nonce, ...opts }) => {
1912
- const vaultContractAddress = opts.network === "localnet" ? opts.vaultContractAddress : getVaultManagerContractAddress(opts.network);
1913
- const vault = Vault__factory.connect(vaultContractAddress, opts.signer);
1904
+ var swapNative = /* @__PURE__ */ __name(async ({ destChain, destAsset, destAddress, amount }, { network, vaultContractAddress: address, signer, ...opts }) => {
1905
+ const vaultContractAddress = network === "localnet" ? address : getVaultManagerContractAddress(network);
1906
+ const vault = Vault__factory.connect(vaultContractAddress, signer);
1914
1907
  const transaction = await vault.xSwapNative(chainContractIds[destChain], destAddress, assetContractIds[destAsset], [], {
1915
1908
  value: amount,
1916
- nonce
1909
+ ...opts
1917
1910
  });
1918
1911
  return transaction.wait(1);
1919
1912
  }, "swapNative");
1920
- var swapToken = /* @__PURE__ */ __name(async (params, opts) => {
1921
- const vaultContractAddress = opts.network === "localnet" ? opts.vaultContractAddress : getVaultManagerContractAddress(opts.network);
1922
- const erc20Address = opts.network === "localnet" ? opts.srcTokenContractAddress : getTokenContractAddress(params.srcAsset, opts.network);
1913
+ var swapToken = /* @__PURE__ */ __name(async (params, { network, vaultContractAddress: vaultAddress, srcTokenContractAddress: tokenAddress, signer, ...opts }) => {
1914
+ const vaultContractAddress = network === "localnet" ? vaultAddress : getVaultManagerContractAddress(network);
1915
+ const erc20Address = network === "localnet" ? tokenAddress : getTokenContractAddress(params.srcAsset, network);
1923
1916
  assert(erc20Address !== void 0, "Missing ERC20 contract address");
1924
- const { isAllowable } = await checkAllowance(params.amount, vaultContractAddress, erc20Address, opts.signer);
1917
+ const { isAllowable } = await checkAllowance(params.amount, vaultContractAddress, erc20Address, signer);
1925
1918
  assert(isAllowable, "Swap amount exceeds allowance");
1926
- const vault = Vault__factory.connect(vaultContractAddress, opts.signer);
1927
- const transaction = await vault.xSwapToken(chainContractIds[params.destChain], params.destAddress, assetContractIds[params.destAsset], erc20Address, params.amount, [], {
1928
- nonce: opts.nonce
1929
- });
1919
+ const vault = Vault__factory.connect(vaultContractAddress, signer);
1920
+ const transaction = await vault.xSwapToken(chainContractIds[params.destChain], params.destAddress, assetContractIds[params.destAsset], erc20Address, params.amount, [], opts);
1930
1921
  return transaction.wait(1);
1931
1922
  }, "swapToken");
1932
- var executeSwap = /* @__PURE__ */ __name(async (params, options) => {
1933
- const parsedParams = executeSwapParamsSchema.parse(params);
1934
- const opts = executeOptionsSchema.parse(options);
1935
- return isTokenSwap(parsedParams) ? swapToken(parsedParams, opts) : swapNative(parsedParams, opts);
1936
- }, "executeSwap");
1937
- var executeSwap_default = executeSwap;
1938
-
1939
- // ../shared/src/vault/executeCall.ts
1940
- var callNative = /* @__PURE__ */ __name(async (params, { nonce, ...opts }) => {
1941
- const vaultContractAddress = opts.network === "localnet" ? opts.vaultContractAddress : getVaultManagerContractAddress(opts.network);
1942
- const vault = Vault__factory.connect(vaultContractAddress, opts.signer);
1943
- const transaction = await vault.xCallNative(chainContractIds[params.destChain], params.destAddress, assetContractIds[params.destAsset], params.message, params.gasBudget, [], {
1923
+ var callNative = /* @__PURE__ */ __name(async (params, { network, vaultContractAddress: vaultAddress, signer, ...opts }) => {
1924
+ const vaultContractAddress = network === "localnet" ? vaultAddress : getVaultManagerContractAddress(network);
1925
+ const vault = Vault__factory.connect(vaultContractAddress, signer);
1926
+ const transaction = await vault.xCallNative(chainContractIds[params.destChain], params.destAddress, assetContractIds[params.destAsset], params.ccmMetadata.message, params.ccmMetadata.gasBudget, [], {
1944
1927
  value: params.amount,
1945
- nonce
1928
+ ...opts
1946
1929
  });
1947
1930
  return transaction.wait(1);
1948
1931
  }, "callNative");
1949
- var callToken = /* @__PURE__ */ __name(async (params, { signer, ...opts }) => {
1950
- const vaultContractAddress = opts.network === "localnet" ? opts.vaultContractAddress : getVaultManagerContractAddress(opts.network);
1951
- const erc20Address = opts.network === "localnet" ? opts.srcTokenContractAddress : getTokenContractAddress(params.srcAsset, opts.network);
1932
+ var callToken = /* @__PURE__ */ __name(async (params, { signer, network, vaultContractAddress: vaultAddress, srcTokenContractAddress: tokenAddress, ...opts }) => {
1933
+ const vaultContractAddress = network === "localnet" ? vaultAddress : getVaultManagerContractAddress(network);
1934
+ const erc20Address = network === "localnet" ? tokenAddress : getTokenContractAddress(params.srcAsset, network);
1952
1935
  assert(erc20Address !== void 0, "Missing ERC20 contract address");
1953
1936
  const { isAllowable } = await checkAllowance(params.amount, vaultContractAddress, erc20Address, signer);
1954
1937
  assert(isAllowable, "Swap amount exceeds allowance");
1955
1938
  const vault = Vault__factory.connect(vaultContractAddress, signer);
1956
- const transaction = await vault.xCallToken(chainContractIds[params.destChain], params.destAddress, assetContractIds[params.destAsset], params.ccmMetadata?.gasBudget, params.ccmMetadata?.message, erc20Address, params.amount, [], {
1957
- nonce: opts.nonce
1958
- });
1939
+ const transaction = await vault.xCallToken(chainContractIds[params.destChain], params.destAddress, assetContractIds[params.destAsset], params.ccmMetadata.message, params.ccmMetadata.gasBudget, erc20Address, params.amount, [], opts);
1959
1940
  return transaction.wait(1);
1960
1941
  }, "callToken");
1961
- var executeCall = /* @__PURE__ */ __name(async (params, options) => {
1962
- const parsedParams = executeCallParamsSchema.parse(params);
1942
+ var executeSwap = /* @__PURE__ */ __name(async (params, options) => {
1943
+ const parsedParams = executeSwapParamsSchema.parse(params);
1963
1944
  const opts = executeOptionsSchema.parse(options);
1964
- return isTokenCall(parsedParams) ? callToken(parsedParams, opts) : callNative(parsedParams, opts);
1965
- }, "executeCall");
1966
- var executeCall_default = executeCall;
1945
+ if ("ccmMetadata" in parsedParams) {
1946
+ return isTokenCall(parsedParams) ? callToken(parsedParams, opts) : callNative(parsedParams, opts);
1947
+ }
1948
+ return isTokenSwap(parsedParams) ? swapToken(parsedParams, opts) : swapNative(parsedParams, opts);
1949
+ }, "executeSwap");
1950
+ var executeSwap_default = executeSwap;
1967
1951
 
1968
1952
  // ../shared/src/vault/approval.ts
1969
1953
  var checkVaultAllowance = /* @__PURE__ */ __name((params, opts) => {
@@ -2170,30 +2154,23 @@ var SwapSDK = class {
2170
2154
  getStatus(swapStatusRequest, options = {}) {
2171
2155
  return ApiService_default.getStatus(this.baseUrl, swapStatusRequest, options);
2172
2156
  }
2173
- async executeSwap(params) {
2157
+ async executeSwap(params, overrides = {}) {
2174
2158
  assert(this.signer, "No signer provided");
2175
2159
  const receipt = await executeSwap_default(params, {
2160
+ ...overrides,
2176
2161
  network: this.network,
2177
2162
  signer: this.signer
2178
2163
  });
2179
2164
  return receipt.transactionHash;
2180
2165
  }
2181
- async executeCall(params) {
2182
- assert(this.signer, "No signer provided");
2183
- const receipt = await executeCall_default(params, {
2184
- network: this.network,
2185
- signer: this.signer
2186
- });
2187
- return receipt.transactionHash;
2188
- }
2189
- async approveVault(params, options = {}) {
2166
+ async approveVault(params, overrides = {}) {
2190
2167
  if (!("srcAsset" in params))
2191
2168
  return null;
2192
2169
  assert(this.signer, "No signer provided");
2193
2170
  const receipt = await approveVault(params, {
2194
2171
  signer: this.signer,
2195
2172
  network: this.network,
2196
- ...options
2173
+ ...overrides
2197
2174
  });
2198
2175
  return receipt && receipt.transactionHash;
2199
2176
  }
package/dist/swap.mjs CHANGED
@@ -1,4 +1,4 @@
1
- import { isString, Chains, Assets, ChainflipNetworks, __name, assert, getVaultManagerContractAddress, approve, isTokenSwap, isTokenCall, getTokenContractAddress, checkAllowance, Vault__factory, chainContractIds, assetContractIds, assetDecimals, isTestnet } from './chunk-CMPMNSTZ.mjs';
1
+ import { isString, Chains, Assets, ChainflipNetworks, __name, assert, getVaultManagerContractAddress, approve, isTokenCall, isTokenSwap, getTokenContractAddress, checkAllowance, Vault__factory, chainContractIds, assetContractIds, assetDecimals, isTestnet } from './chunk-CMPMNSTZ.mjs';
2
2
  export { Assets, ChainflipNetworks, Chains, assetChains, assetContractIds, assetDecimals, chainAssets, chainContractIds } from './chunk-CMPMNSTZ.mjs';
3
3
  import { encodeAddress, decodeAddress } from '@polkadot/util-crypto';
4
4
  import * as ethers from 'ethers';
@@ -387,17 +387,8 @@ var tokenSwapParamsSchema = z.union([
387
387
  srcAsset: erc20
388
388
  })
389
389
  ]);
390
- var executeSwapParamsSchema = z.union([
391
- nativeSwapParamsSchema,
392
- tokenSwapParamsSchema
393
- ]);
394
- var nativeCallParamsSchema = ethereumBase.extend({
395
- destAsset: erc20,
396
- message: z.string(),
397
- gasBudget: numericString
398
- });
399
390
  var ccmMetadataSchema = z.object({
400
- message: hexString,
391
+ message: z.string(),
401
392
  gasBudget: numericString
402
393
  });
403
394
  var tokenCallParamsSchema = z.union([
@@ -418,85 +409,78 @@ var tokenCallParamsSchema = z.union([
418
409
  ccmMetadata: ccmMetadataSchema
419
410
  })
420
411
  ]);
421
- var executeCallParamsSchema = z.union([
412
+ var nativeCallParamsSchema = ethereumBase.extend({
413
+ destAsset: erc20,
414
+ ccmMetadata: ccmMetadataSchema
415
+ });
416
+ var executeSwapParamsSchema = z.union([
417
+ // call schemas needs to precede swap schemas
422
418
  nativeCallParamsSchema,
423
- tokenCallParamsSchema
419
+ tokenCallParamsSchema,
420
+ nativeSwapParamsSchema,
421
+ tokenSwapParamsSchema
424
422
  ]);
425
423
  var executeOptionsSchema = z.intersection(z.object({
426
- signer: z.instanceof(Signer),
427
- nonce: z.union([
428
- z.number(),
429
- z.bigint(),
430
- z.string()
431
- ]).optional()
432
- }), z.union([
424
+ signer: z.instanceof(Signer)
425
+ }).passthrough(), z.union([
433
426
  z.object({
434
427
  network: chainflipNetwork
435
- }),
428
+ }).passthrough(),
436
429
  z.object({
437
430
  network: z.literal("localnet"),
438
431
  vaultContractAddress: z.string(),
439
432
  srcTokenContractAddress: z.string().optional()
440
- })
433
+ }).passthrough()
441
434
  ]));
442
435
 
443
436
  // ../shared/src/vault/executeSwap.ts
444
- var swapNative = /* @__PURE__ */ __name(async ({ destChain, destAsset, destAddress, amount }, { nonce, ...opts }) => {
445
- const vaultContractAddress = opts.network === "localnet" ? opts.vaultContractAddress : getVaultManagerContractAddress(opts.network);
446
- const vault = Vault__factory.connect(vaultContractAddress, opts.signer);
437
+ var swapNative = /* @__PURE__ */ __name(async ({ destChain, destAsset, destAddress, amount }, { network, vaultContractAddress: address, signer, ...opts }) => {
438
+ const vaultContractAddress = network === "localnet" ? address : getVaultManagerContractAddress(network);
439
+ const vault = Vault__factory.connect(vaultContractAddress, signer);
447
440
  const transaction = await vault.xSwapNative(chainContractIds[destChain], destAddress, assetContractIds[destAsset], [], {
448
441
  value: amount,
449
- nonce
442
+ ...opts
450
443
  });
451
444
  return transaction.wait(1);
452
445
  }, "swapNative");
453
- var swapToken = /* @__PURE__ */ __name(async (params, opts) => {
454
- const vaultContractAddress = opts.network === "localnet" ? opts.vaultContractAddress : getVaultManagerContractAddress(opts.network);
455
- const erc20Address = opts.network === "localnet" ? opts.srcTokenContractAddress : getTokenContractAddress(params.srcAsset, opts.network);
446
+ var swapToken = /* @__PURE__ */ __name(async (params, { network, vaultContractAddress: vaultAddress, srcTokenContractAddress: tokenAddress, signer, ...opts }) => {
447
+ const vaultContractAddress = network === "localnet" ? vaultAddress : getVaultManagerContractAddress(network);
448
+ const erc20Address = network === "localnet" ? tokenAddress : getTokenContractAddress(params.srcAsset, network);
456
449
  assert(erc20Address !== void 0, "Missing ERC20 contract address");
457
- const { isAllowable } = await checkAllowance(params.amount, vaultContractAddress, erc20Address, opts.signer);
450
+ const { isAllowable } = await checkAllowance(params.amount, vaultContractAddress, erc20Address, signer);
458
451
  assert(isAllowable, "Swap amount exceeds allowance");
459
- const vault = Vault__factory.connect(vaultContractAddress, opts.signer);
460
- const transaction = await vault.xSwapToken(chainContractIds[params.destChain], params.destAddress, assetContractIds[params.destAsset], erc20Address, params.amount, [], {
461
- nonce: opts.nonce
462
- });
452
+ const vault = Vault__factory.connect(vaultContractAddress, signer);
453
+ const transaction = await vault.xSwapToken(chainContractIds[params.destChain], params.destAddress, assetContractIds[params.destAsset], erc20Address, params.amount, [], opts);
463
454
  return transaction.wait(1);
464
455
  }, "swapToken");
465
- var executeSwap = /* @__PURE__ */ __name(async (params, options) => {
466
- const parsedParams = executeSwapParamsSchema.parse(params);
467
- const opts = executeOptionsSchema.parse(options);
468
- return isTokenSwap(parsedParams) ? swapToken(parsedParams, opts) : swapNative(parsedParams, opts);
469
- }, "executeSwap");
470
- var executeSwap_default = executeSwap;
471
-
472
- // ../shared/src/vault/executeCall.ts
473
- var callNative = /* @__PURE__ */ __name(async (params, { nonce, ...opts }) => {
474
- const vaultContractAddress = opts.network === "localnet" ? opts.vaultContractAddress : getVaultManagerContractAddress(opts.network);
475
- const vault = Vault__factory.connect(vaultContractAddress, opts.signer);
476
- const transaction = await vault.xCallNative(chainContractIds[params.destChain], params.destAddress, assetContractIds[params.destAsset], params.message, params.gasBudget, [], {
456
+ var callNative = /* @__PURE__ */ __name(async (params, { network, vaultContractAddress: vaultAddress, signer, ...opts }) => {
457
+ const vaultContractAddress = network === "localnet" ? vaultAddress : getVaultManagerContractAddress(network);
458
+ const vault = Vault__factory.connect(vaultContractAddress, signer);
459
+ const transaction = await vault.xCallNative(chainContractIds[params.destChain], params.destAddress, assetContractIds[params.destAsset], params.ccmMetadata.message, params.ccmMetadata.gasBudget, [], {
477
460
  value: params.amount,
478
- nonce
461
+ ...opts
479
462
  });
480
463
  return transaction.wait(1);
481
464
  }, "callNative");
482
- var callToken = /* @__PURE__ */ __name(async (params, { signer, ...opts }) => {
483
- const vaultContractAddress = opts.network === "localnet" ? opts.vaultContractAddress : getVaultManagerContractAddress(opts.network);
484
- const erc20Address = opts.network === "localnet" ? opts.srcTokenContractAddress : getTokenContractAddress(params.srcAsset, opts.network);
465
+ var callToken = /* @__PURE__ */ __name(async (params, { signer, network, vaultContractAddress: vaultAddress, srcTokenContractAddress: tokenAddress, ...opts }) => {
466
+ const vaultContractAddress = network === "localnet" ? vaultAddress : getVaultManagerContractAddress(network);
467
+ const erc20Address = network === "localnet" ? tokenAddress : getTokenContractAddress(params.srcAsset, network);
485
468
  assert(erc20Address !== void 0, "Missing ERC20 contract address");
486
469
  const { isAllowable } = await checkAllowance(params.amount, vaultContractAddress, erc20Address, signer);
487
470
  assert(isAllowable, "Swap amount exceeds allowance");
488
471
  const vault = Vault__factory.connect(vaultContractAddress, signer);
489
- const transaction = await vault.xCallToken(chainContractIds[params.destChain], params.destAddress, assetContractIds[params.destAsset], params.ccmMetadata?.gasBudget, params.ccmMetadata?.message, erc20Address, params.amount, [], {
490
- nonce: opts.nonce
491
- });
472
+ const transaction = await vault.xCallToken(chainContractIds[params.destChain], params.destAddress, assetContractIds[params.destAsset], params.ccmMetadata.message, params.ccmMetadata.gasBudget, erc20Address, params.amount, [], opts);
492
473
  return transaction.wait(1);
493
474
  }, "callToken");
494
- var executeCall = /* @__PURE__ */ __name(async (params, options) => {
495
- const parsedParams = executeCallParamsSchema.parse(params);
475
+ var executeSwap = /* @__PURE__ */ __name(async (params, options) => {
476
+ const parsedParams = executeSwapParamsSchema.parse(params);
496
477
  const opts = executeOptionsSchema.parse(options);
497
- return isTokenCall(parsedParams) ? callToken(parsedParams, opts) : callNative(parsedParams, opts);
498
- }, "executeCall");
499
- var executeCall_default = executeCall;
478
+ if ("ccmMetadata" in parsedParams) {
479
+ return isTokenCall(parsedParams) ? callToken(parsedParams, opts) : callNative(parsedParams, opts);
480
+ }
481
+ return isTokenSwap(parsedParams) ? swapToken(parsedParams, opts) : swapNative(parsedParams, opts);
482
+ }, "executeSwap");
483
+ var executeSwap_default = executeSwap;
500
484
 
501
485
  // ../shared/src/vault/approval.ts
502
486
  var checkVaultAllowance = /* @__PURE__ */ __name((params, opts) => {
@@ -703,30 +687,23 @@ var SwapSDK = class {
703
687
  getStatus(swapStatusRequest, options = {}) {
704
688
  return ApiService_default.getStatus(this.baseUrl, swapStatusRequest, options);
705
689
  }
706
- async executeSwap(params) {
690
+ async executeSwap(params, overrides = {}) {
707
691
  assert(this.signer, "No signer provided");
708
692
  const receipt = await executeSwap_default(params, {
693
+ ...overrides,
709
694
  network: this.network,
710
695
  signer: this.signer
711
696
  });
712
697
  return receipt.transactionHash;
713
698
  }
714
- async executeCall(params) {
715
- assert(this.signer, "No signer provided");
716
- const receipt = await executeCall_default(params, {
717
- network: this.network,
718
- signer: this.signer
719
- });
720
- return receipt.transactionHash;
721
- }
722
- async approveVault(params, options = {}) {
699
+ async approveVault(params, overrides = {}) {
723
700
  if (!("srcAsset" in params))
724
701
  return null;
725
702
  assert(this.signer, "No signer provided");
726
703
  const receipt = await approveVault(params, {
727
704
  signer: this.signer,
728
705
  network: this.network,
729
- ...options
706
+ ...overrides
730
707
  });
731
708
  return receipt && receipt.transactionHash;
732
709
  }
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@chainflip/sdk",
3
- "version": "0.1.11",
3
+ "version": "0.1.13",
4
4
  "description": "",
5
5
  "exports": {
6
6
  "./swap": {