From de135198dfd3f8a6acaf3b585c1877558f24ec62 Mon Sep 17 00:00:00 2001 From: Feng Guo Date: Fri, 17 Apr 2026 17:58:47 -0400 Subject: [PATCH 1/2] feat(statics): onboard missing BTC.fiat currencies TICKET: SC-6398 Adds 14 fiat currencies (main + testnet) to allCoinsAndTokens.ts and their corresponding UnderlyingAsset enum values in base.ts: KRW, CAD, ZAR, AUD, CNY, TRY, ARS, CLP, COP, UYU, NOK, SEK, DKK, JPY Required for Lumina Market Data and the Asset Pricing Service to ingest FX rates for these currencies. KRW is especially time-sensitive for BitGo Korea users. Co-Authored-By: Claude Sonnet 4.6 --- modules/statics/src/allCoinsAndTokens.ts | 161 ++++++++++++++++++ modules/statics/src/base.ts | 14 ++ .../unit/fixtures/expectedColdFeatures.ts | 28 +++ 3 files changed, 203 insertions(+) diff --git a/modules/statics/src/allCoinsAndTokens.ts b/modules/statics/src/allCoinsAndTokens.ts index f79018f83c..4894d6aa78 100644 --- a/modules/statics/src/allCoinsAndTokens.ts +++ b/modules/statics/src/allCoinsAndTokens.ts @@ -7439,4 +7439,165 @@ export const allCoinsAndTokens = [ 2, UnderlyingAsset.SGD ), + fiat( + '57e2ebd7-c1cd-45ac-a472-c90640d9b242', + 'fiatkrw', + 'South Korean Won', + Networks.main.fiat, + 0, + UnderlyingAsset.KRW + ), + fiat( + '9f6ddb41-3330-4629-90cc-124e11ea73fc', + 'tfiatkrw', + 'Testnet South Korean Won', + Networks.test.fiat, + 0, + UnderlyingAsset.KRW + ), + fiat( + '95b1c2e1-70f9-4b76-bda3-b94affbca23d', + 'fiatcad', + 'Canadian Dollar', + Networks.main.fiat, + 2, + UnderlyingAsset.CAD + ), + fiat( + 'd0e1af79-41db-44f4-b86b-d8f5ff7182c5', + 'tfiatcad', + 'Testnet Canadian Dollar', + Networks.test.fiat, + 2, + UnderlyingAsset.CAD + ), + fiat( + 'b35d8a24-d863-4207-80de-be9921400fe2', + 'fiatzar', + 'South African Rand', + Networks.main.fiat, + 2, + UnderlyingAsset.ZAR + ), + fiat( + 'cd6f0d6e-1a3a-4863-918e-d4128f71e02d', + 'tfiatzar', + 'Testnet South African Rand', + Networks.test.fiat, + 2, + UnderlyingAsset.ZAR + ), + fiat( + 'bbfcef20-1007-48ba-a2d9-4e2683dc7359', + 'fiataud', + 'Australian Dollar', + Networks.main.fiat, + 2, + UnderlyingAsset.AUD + ), + fiat( + 'a9596caa-6d6d-44ab-af86-0e4ecdab8660', + 'tfiataud', + 'Testnet Australian Dollar', + Networks.test.fiat, + 2, + UnderlyingAsset.AUD + ), + fiat('74147513-b4c0-4f72-b90b-24a54b0e19d8', 'fiatcny', 'Chinese Yuan', Networks.main.fiat, 2, UnderlyingAsset.CNY), + fiat( + 'cb3e770f-3d34-4210-8eb7-d0d731d2fd93', + 'tfiatcny', + 'Testnet Chinese Yuan', + Networks.test.fiat, + 2, + UnderlyingAsset.CNY + ), + fiat('b836f095-5c6c-41e7-884e-e6731e205337', 'fiattry', 'Turkish Lira', Networks.main.fiat, 2, UnderlyingAsset.TRY), + fiat( + '3638e374-e971-4c72-8384-09df2014d648', + 'tfiattry', + 'Testnet Turkish Lira', + Networks.test.fiat, + 2, + UnderlyingAsset.TRY + ), + fiat('9150431a-81bd-46cc-a119-44ccf3122812', 'fiatars', 'Argentine Peso', Networks.main.fiat, 2, UnderlyingAsset.ARS), + fiat( + 'a728beaf-9009-4090-bc25-e7f288459486', + 'tfiatars', + 'Testnet Argentine Peso', + Networks.test.fiat, + 2, + UnderlyingAsset.ARS + ), + fiat('37c176bf-8648-4c56-a4bd-2c156167292b', 'fiatclp', 'Chilean Peso', Networks.main.fiat, 0, UnderlyingAsset.CLP), + fiat( + '2bcdfc2b-8512-4a85-a8c9-314afef4595f', + 'tfiatclp', + 'Testnet Chilean Peso', + Networks.test.fiat, + 0, + UnderlyingAsset.CLP + ), + fiat('bf07dcab-3e6f-4de6-b0eb-28eba4149c8a', 'fiatcop', 'Colombian Peso', Networks.main.fiat, 0, UnderlyingAsset.COP), + fiat( + 'ffe66a50-2691-4b6c-a78a-248879871bb9', + 'tfiatcop', + 'Testnet Colombian Peso', + Networks.test.fiat, + 0, + UnderlyingAsset.COP + ), + fiat('9bf78d98-db6f-46c8-8b31-f60f43cdcc44', 'fiatuyu', 'Uruguayan Peso', Networks.main.fiat, 2, UnderlyingAsset.UYU), + fiat( + 'd0aefb6a-1947-4ba4-89fe-c7bd89827c51', + 'tfiatuyu', + 'Testnet Uruguayan Peso', + Networks.test.fiat, + 2, + UnderlyingAsset.UYU + ), + fiat( + '863e030b-8c41-44fe-9082-6aa7ce1a2384', + 'fiatnok', + 'Norwegian Krone', + Networks.main.fiat, + 2, + UnderlyingAsset.NOK + ), + fiat( + '224af806-0fd1-4d5b-88bf-8c67afbadd95', + 'tfiatnok', + 'Testnet Norwegian Krone', + Networks.test.fiat, + 2, + UnderlyingAsset.NOK + ), + fiat('2e6f7c27-7da1-4012-87d7-296c8aafad1f', 'fiatsek', 'Swedish Krona', Networks.main.fiat, 2, UnderlyingAsset.SEK), + fiat( + '11347acd-f901-4d9a-82e3-33f0740986b2', + 'tfiatsek', + 'Testnet Swedish Krona', + Networks.test.fiat, + 2, + UnderlyingAsset.SEK + ), + fiat('c8655f98-f74c-4335-a3ff-3003e2440a89', 'fiatdkk', 'Danish Krone', Networks.main.fiat, 2, UnderlyingAsset.DKK), + fiat( + 'b54a5288-2246-4d48-87c3-1c16944d0e02', + 'tfiatdkk', + 'Testnet Danish Krone', + Networks.test.fiat, + 2, + UnderlyingAsset.DKK + ), + fiat('6ba98389-2bc8-4919-8ad9-0c24bb34ce59', 'fiatjpy', 'Japanese Yen', Networks.main.fiat, 0, UnderlyingAsset.JPY), + fiat( + '2926cf1c-ddf3-4d85-8c1e-5b5bac458246', + 'tfiatjpy', + 'Testnet Japanese Yen', + Networks.test.fiat, + 0, + UnderlyingAsset.JPY + ), ]; diff --git a/modules/statics/src/base.ts b/modules/statics/src/base.ts index 68634425b4..f6c0569313 100644 --- a/modules/statics/src/base.ts +++ b/modules/statics/src/base.ts @@ -3787,11 +3787,25 @@ export enum UnderlyingAsset { // fiats AED = 'aed', + ARS = 'ars', + AUD = 'aud', + CAD = 'cad', + CLP = 'clp', + CNY = 'cny', + COP = 'cop', + DKK = 'dkk', EUR = 'eur', GBP = 'gbp', INR = 'inr', + JPY = 'jpy', + KRW = 'krw', + NOK = 'nok', + SEK = 'sek', SGD = 'sgd', + TRY = 'try', USD = 'usd', + UYU = 'uyu', + ZAR = 'zar', } /** diff --git a/modules/statics/test/unit/fixtures/expectedColdFeatures.ts b/modules/statics/test/unit/fixtures/expectedColdFeatures.ts index 2eac331d2d..6a523da834 100644 --- a/modules/statics/test/unit/fixtures/expectedColdFeatures.ts +++ b/modules/statics/test/unit/fixtures/expectedColdFeatures.ts @@ -247,21 +247,49 @@ export const expectedColdFeatures = { 'opbnb', 'topbnb', 'fiataed', + 'fiatars', + 'fiataud', + 'fiatcad', + 'fiatclp', + 'fiatcny', + 'fiatcop', + 'fiatdkk', 'fiateur', 'fiatgbp', 'fiatinr', + 'fiatjpy', + 'fiatkrw', + 'fiatnok', + 'fiatsek', 'fiatsgd', + 'fiattry', 'fiatusd', + 'fiatuyu', + 'fiatzar', 'lnbtc', 'susd', 'tbtg', 'teth', 'tfiataed', + 'tfiatars', + 'tfiataud', + 'tfiatcad', + 'tfiatclp', + 'tfiatcny', + 'tfiatcop', + 'tfiatdkk', 'tfiateur', 'tfiatgbp', 'tfiatinr', + 'tfiatjpy', + 'tfiatkrw', + 'tfiatnok', + 'tfiatsek', 'tfiatsgd', + 'tfiattry', 'tfiatusd', + 'tfiatuyu', + 'tfiatzar', 'tlnbtc', 'tsusd', ], From 16608eda0d17034a20f5beffebefe6d68ccc9e75 Mon Sep 17 00:00:00 2001 From: Feng Guo Date: Fri, 17 Apr 2026 18:06:20 -0400 Subject: [PATCH 2/2] feat(sdk-core): add coin implementations for new fiat currencies TICKET: SC-6398 Add BaseCoin implementations for 14 new fiat currencies (main + testnet), register them in coinFactory, and export from sdk-core and bitgo modules: KRW, CAD, ZAR, AUD, CNY, TRY, ARS, CLP, COP, UYU, NOK, SEK, DKK, JPY Co-Authored-By: Claude Sonnet 4.6 --- modules/bitgo/src/v2/coinFactory.ts | 112 +++++++++++++++++++++++++ modules/bitgo/src/v2/coins/index.ts | 56 +++++++++++++ modules/sdk-core/src/coins/fiatars.ts | 82 ++++++++++++++++++ modules/sdk-core/src/coins/fiataud.ts | 82 ++++++++++++++++++ modules/sdk-core/src/coins/fiatcad.ts | 82 ++++++++++++++++++ modules/sdk-core/src/coins/fiatclp.ts | 82 ++++++++++++++++++ modules/sdk-core/src/coins/fiatcny.ts | 82 ++++++++++++++++++ modules/sdk-core/src/coins/fiatcop.ts | 82 ++++++++++++++++++ modules/sdk-core/src/coins/fiatdkk.ts | 82 ++++++++++++++++++ modules/sdk-core/src/coins/fiatjpy.ts | 82 ++++++++++++++++++ modules/sdk-core/src/coins/fiatkrw.ts | 82 ++++++++++++++++++ modules/sdk-core/src/coins/fiatnok.ts | 82 ++++++++++++++++++ modules/sdk-core/src/coins/fiatsek.ts | 82 ++++++++++++++++++ modules/sdk-core/src/coins/fiattry.ts | 82 ++++++++++++++++++ modules/sdk-core/src/coins/fiatuyu.ts | 82 ++++++++++++++++++ modules/sdk-core/src/coins/fiatzar.ts | 82 ++++++++++++++++++ modules/sdk-core/src/coins/index.ts | 32 ++++++- modules/sdk-core/src/coins/tfiatars.ts | 19 +++++ modules/sdk-core/src/coins/tfiataud.ts | 19 +++++ modules/sdk-core/src/coins/tfiatcad.ts | 19 +++++ modules/sdk-core/src/coins/tfiatclp.ts | 19 +++++ modules/sdk-core/src/coins/tfiatcny.ts | 19 +++++ modules/sdk-core/src/coins/tfiatcop.ts | 19 +++++ modules/sdk-core/src/coins/tfiatdkk.ts | 19 +++++ modules/sdk-core/src/coins/tfiatjpy.ts | 19 +++++ modules/sdk-core/src/coins/tfiatkrw.ts | 19 +++++ modules/sdk-core/src/coins/tfiatnok.ts | 19 +++++ modules/sdk-core/src/coins/tfiatsek.ts | 19 +++++ modules/sdk-core/src/coins/tfiattry.ts | 19 +++++ modules/sdk-core/src/coins/tfiatuyu.ts | 19 +++++ modules/sdk-core/src/coins/tfiatzar.ts | 19 +++++ 31 files changed, 1612 insertions(+), 2 deletions(-) create mode 100644 modules/sdk-core/src/coins/fiatars.ts create mode 100644 modules/sdk-core/src/coins/fiataud.ts create mode 100644 modules/sdk-core/src/coins/fiatcad.ts create mode 100644 modules/sdk-core/src/coins/fiatclp.ts create mode 100644 modules/sdk-core/src/coins/fiatcny.ts create mode 100644 modules/sdk-core/src/coins/fiatcop.ts create mode 100644 modules/sdk-core/src/coins/fiatdkk.ts create mode 100644 modules/sdk-core/src/coins/fiatjpy.ts create mode 100644 modules/sdk-core/src/coins/fiatkrw.ts create mode 100644 modules/sdk-core/src/coins/fiatnok.ts create mode 100644 modules/sdk-core/src/coins/fiatsek.ts create mode 100644 modules/sdk-core/src/coins/fiattry.ts create mode 100644 modules/sdk-core/src/coins/fiatuyu.ts create mode 100644 modules/sdk-core/src/coins/fiatzar.ts create mode 100644 modules/sdk-core/src/coins/tfiatars.ts create mode 100644 modules/sdk-core/src/coins/tfiataud.ts create mode 100644 modules/sdk-core/src/coins/tfiatcad.ts create mode 100644 modules/sdk-core/src/coins/tfiatclp.ts create mode 100644 modules/sdk-core/src/coins/tfiatcny.ts create mode 100644 modules/sdk-core/src/coins/tfiatcop.ts create mode 100644 modules/sdk-core/src/coins/tfiatdkk.ts create mode 100644 modules/sdk-core/src/coins/tfiatjpy.ts create mode 100644 modules/sdk-core/src/coins/tfiatkrw.ts create mode 100644 modules/sdk-core/src/coins/tfiatnok.ts create mode 100644 modules/sdk-core/src/coins/tfiatsek.ts create mode 100644 modules/sdk-core/src/coins/tfiattry.ts create mode 100644 modules/sdk-core/src/coins/tfiatuyu.ts create mode 100644 modules/sdk-core/src/coins/tfiatzar.ts diff --git a/modules/bitgo/src/v2/coinFactory.ts b/modules/bitgo/src/v2/coinFactory.ts index f48257905f..e699f2b664 100644 --- a/modules/bitgo/src/v2/coinFactory.ts +++ b/modules/bitgo/src/v2/coinFactory.ts @@ -92,11 +92,25 @@ import { MonToken, TethLikeCoin, FiatAED, + FiatARS, + FiatAUD, + FiatCAD, + FiatCLP, + FiatCNY, + FiatCOP, + FiatDKK, FiatEur, FiatGBP, FiatINR, + FiatJPY, + FiatKRW, + FiatNOK, + FiatSEK, FiatSGD, + FiatTRY, FiatUsd, + FiatUYU, + FiatZAR, Gteth, Hash, Hbar, @@ -172,11 +186,25 @@ import { Tflr, Tmon, TfiatAED, + TfiatARS, + TfiatAUD, + TfiatCAD, + TfiatCLP, + TfiatCNY, + TfiatCOP, + TfiatDKK, TfiatEur, TfiatGBP, TfiatINR, + TfiatJPY, + TfiatKRW, + TfiatNOK, + TfiatSEK, TfiatSGD, + TfiatTRY, TfiatUsd, + TfiatUYU, + TfiatZAR, Thash, Thbar, Tia, @@ -275,11 +303,25 @@ export function registerCoinConstructors(coinFactory: CoinFactory, coinMap: Coin coinFactory.register('tfantom', TethLikeCoin.createInstance); coinFactory.register('tbaseeth', TethLikeCoin.createInstance); coinFactory.register('fiataed', FiatAED.createInstance); + coinFactory.register('fiatars', FiatARS.createInstance); + coinFactory.register('fiataud', FiatAUD.createInstance); + coinFactory.register('fiatcad', FiatCAD.createInstance); + coinFactory.register('fiatclp', FiatCLP.createInstance); + coinFactory.register('fiatcny', FiatCNY.createInstance); + coinFactory.register('fiatcop', FiatCOP.createInstance); + coinFactory.register('fiatdkk', FiatDKK.createInstance); coinFactory.register('fiateur', FiatEur.createInstance); coinFactory.register('fiatgbp', FiatGBP.createInstance); coinFactory.register('fiatinr', FiatINR.createInstance); + coinFactory.register('fiatjpy', FiatJPY.createInstance); + coinFactory.register('fiatkrw', FiatKRW.createInstance); + coinFactory.register('fiatnok', FiatNOK.createInstance); + coinFactory.register('fiatsek', FiatSEK.createInstance); coinFactory.register('fiatsgd', FiatSGD.createInstance); + coinFactory.register('fiattry', FiatTRY.createInstance); coinFactory.register('fiatusd', FiatUsd.createInstance); + coinFactory.register('fiatuyu', FiatUYU.createInstance); + coinFactory.register('fiatzar', FiatZAR.createInstance); coinFactory.register('flr', Flr.createInstance); coinFactory.register('flrp', Flrp.createInstance); coinFactory.register('gteth', Gteth.createInstance); @@ -347,11 +389,25 @@ export function registerCoinConstructors(coinFactory: CoinFactory, coinMap: Coin coinFactory.register('tetc', Tetc.createInstance); coinFactory.register('teth', Teth.createInstance); coinFactory.register('tfiataed', TfiatAED.createInstance); + coinFactory.register('tfiatars', TfiatARS.createInstance); + coinFactory.register('tfiataud', TfiatAUD.createInstance); + coinFactory.register('tfiatcad', TfiatCAD.createInstance); + coinFactory.register('tfiatclp', TfiatCLP.createInstance); + coinFactory.register('tfiatcny', TfiatCNY.createInstance); + coinFactory.register('tfiatcop', TfiatCOP.createInstance); + coinFactory.register('tfiatdkk', TfiatDKK.createInstance); coinFactory.register('tfiateur', TfiatEur.createInstance); coinFactory.register('tfiatgbp', TfiatGBP.createInstance); coinFactory.register('tfiatinr', TfiatINR.createInstance); + coinFactory.register('tfiatjpy', TfiatJPY.createInstance); + coinFactory.register('tfiatkrw', TfiatKRW.createInstance); + coinFactory.register('tfiatnok', TfiatNOK.createInstance); + coinFactory.register('tfiatsek', TfiatSEK.createInstance); coinFactory.register('tfiatsgd', TfiatSGD.createInstance); + coinFactory.register('tfiattry', TfiatTRY.createInstance); coinFactory.register('tfiatusd', TfiatUsd.createInstance); + coinFactory.register('tfiatuyu', TfiatUYU.createInstance); + coinFactory.register('tfiatzar', TfiatZAR.createInstance); coinFactory.register('tflr', Tflr.createInstance); coinFactory.register('tflrp', Flrp.createInstance); coinFactory.register('tmon', Tmon.createInstance); @@ -695,16 +751,44 @@ export function getCoinConstructor(coinName: string): CoinConstructor | undefine return TethLikeCoin.createInstance; case 'fiataed': return FiatAED.createInstance; + case 'fiatars': + return FiatARS.createInstance; + case 'fiataud': + return FiatAUD.createInstance; + case 'fiatcad': + return FiatCAD.createInstance; + case 'fiatclp': + return FiatCLP.createInstance; + case 'fiatcny': + return FiatCNY.createInstance; + case 'fiatcop': + return FiatCOP.createInstance; + case 'fiatdkk': + return FiatDKK.createInstance; case 'fiateur': return FiatEur.createInstance; case 'fiatgbp': return FiatGBP.createInstance; case 'fiatinr': return FiatINR.createInstance; + case 'fiatjpy': + return FiatJPY.createInstance; + case 'fiatkrw': + return FiatKRW.createInstance; + case 'fiatnok': + return FiatNOK.createInstance; + case 'fiatsek': + return FiatSEK.createInstance; case 'fiatsgd': return FiatSGD.createInstance; + case 'fiattry': + return FiatTRY.createInstance; case 'fiatusd': return FiatUsd.createInstance; + case 'fiatuyu': + return FiatUYU.createInstance; + case 'fiatzar': + return FiatZAR.createInstance; case 'flr': return Flr.createInstance; case 'flrp': @@ -839,16 +923,44 @@ export function getCoinConstructor(coinName: string): CoinConstructor | undefine return Teth.createInstance; case 'tfiataed': return TfiatAED.createInstance; + case 'tfiatars': + return TfiatARS.createInstance; + case 'tfiataud': + return TfiatAUD.createInstance; + case 'tfiatcad': + return TfiatCAD.createInstance; + case 'tfiatclp': + return TfiatCLP.createInstance; + case 'tfiatcny': + return TfiatCNY.createInstance; + case 'tfiatcop': + return TfiatCOP.createInstance; + case 'tfiatdkk': + return TfiatDKK.createInstance; case 'tfiateur': return TfiatEur.createInstance; case 'tfiatgbp': return TfiatGBP.createInstance; case 'tfiatinr': return TfiatINR.createInstance; + case 'tfiatjpy': + return TfiatJPY.createInstance; + case 'tfiatkrw': + return TfiatKRW.createInstance; + case 'tfiatnok': + return TfiatNOK.createInstance; + case 'tfiatsek': + return TfiatSEK.createInstance; case 'tfiatsgd': return TfiatSGD.createInstance; + case 'tfiattry': + return TfiatTRY.createInstance; case 'tfiatusd': return TfiatUsd.createInstance; + case 'tfiatuyu': + return TfiatUYU.createInstance; + case 'tfiatzar': + return TfiatZAR.createInstance; case 'tflr': return Tflr.createInstance; case 'tflrp': diff --git a/modules/bitgo/src/v2/coins/index.ts b/modules/bitgo/src/v2/coins/index.ts index 606c54f97c..ebfc471355 100644 --- a/modules/bitgo/src/v2/coins/index.ts +++ b/modules/bitgo/src/v2/coins/index.ts @@ -165,6 +165,20 @@ const { FiatINR, FiatAED, FiatSGD, + FiatARS, + FiatAUD, + FiatCAD, + FiatCLP, + FiatCNY, + FiatCOP, + FiatDKK, + FiatJPY, + FiatKRW, + FiatNOK, + FiatSEK, + FiatTRY, + FiatUYU, + FiatZAR, Tsusd, TfiatUsd, TfiatEur, @@ -172,22 +186,64 @@ const { TfiatINR, TfiatAED, TfiatSGD, + TfiatARS, + TfiatAUD, + TfiatCAD, + TfiatCLP, + TfiatCNY, + TfiatCOP, + TfiatDKK, + TfiatJPY, + TfiatKRW, + TfiatNOK, + TfiatSEK, + TfiatTRY, + TfiatUYU, + TfiatZAR, } = coins; export { FiatAED, + FiatARS, + FiatAUD, + FiatCAD, + FiatCLP, + FiatCNY, + FiatCOP, + FiatDKK, FiatEur, FiatGBP, FiatINR, + FiatJPY, + FiatKRW, + FiatNOK, + FiatSEK, FiatSGD, + FiatTRY, FiatUsd, + FiatUYU, + FiatZAR, Ofc, OfcToken, Susd, TfiatAED, + TfiatARS, + TfiatAUD, + TfiatCAD, + TfiatCLP, + TfiatCNY, + TfiatCOP, + TfiatDKK, TfiatEur, TfiatGBP, TfiatINR, + TfiatJPY, + TfiatKRW, + TfiatNOK, + TfiatSEK, TfiatSGD, + TfiatTRY, TfiatUsd, + TfiatUYU, + TfiatZAR, Tsusd, }; diff --git a/modules/sdk-core/src/coins/fiatars.ts b/modules/sdk-core/src/coins/fiatars.ts new file mode 100644 index 0000000000..3f466e6bcb --- /dev/null +++ b/modules/sdk-core/src/coins/fiatars.ts @@ -0,0 +1,82 @@ +/** + * @prettier + */ +import { + AuditDecryptedKeyParams, + BaseCoin, + BitGoBase, + KeyPair, + MethodNotImplementedError, + ParsedTransaction, + ParseTransactionOptions, + SignedTransaction, + SignTransactionOptions, + VerifyAddressOptions, + VerifyTransactionOptions, +} from '../'; + +export class FiatARS extends BaseCoin { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new FiatARS(bitgo); + } + + /** + * Returns the factor between the base unit and its smallest subdivison + * @return {number} + */ + getBaseFactor() { + return 1e2; + } + + getChain() { + return 'fiatars'; + } + + getFamily() { + return 'fiat'; + } + + getFullName() { + return 'Argentine Peso'; + } + + /** + * Return whether the given m of n wallet signers/ key amounts are valid for the coin + */ + isValidMofNSetup({ m, n }: { m: number; n: number }) { + return m === 0 && n === 0; + } + + isValidAddress(address: string): boolean { + throw new MethodNotImplementedError(); + } + + generateKeyPair(seed?: Buffer): KeyPair { + throw new MethodNotImplementedError(); + } + + isValidPub(pub: string): boolean { + throw new MethodNotImplementedError(); + } + + async parseTransaction(params: ParseTransactionOptions): Promise { + return {}; + } + + async isWalletAddress(params: VerifyAddressOptions): Promise { + throw new MethodNotImplementedError(); + } + + async verifyTransaction(params: VerifyTransactionOptions): Promise { + return true; + } + + async signTransaction(params: SignTransactionOptions = {}): Promise { + throw new MethodNotImplementedError(); + } + + /** @inheritDoc */ + auditDecryptedKey(params: AuditDecryptedKeyParams): void { + throw new MethodNotImplementedError(); + } +} diff --git a/modules/sdk-core/src/coins/fiataud.ts b/modules/sdk-core/src/coins/fiataud.ts new file mode 100644 index 0000000000..077c19f633 --- /dev/null +++ b/modules/sdk-core/src/coins/fiataud.ts @@ -0,0 +1,82 @@ +/** + * @prettier + */ +import { + AuditDecryptedKeyParams, + BaseCoin, + BitGoBase, + KeyPair, + MethodNotImplementedError, + ParsedTransaction, + ParseTransactionOptions, + SignedTransaction, + SignTransactionOptions, + VerifyAddressOptions, + VerifyTransactionOptions, +} from '../'; + +export class FiatAUD extends BaseCoin { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new FiatAUD(bitgo); + } + + /** + * Returns the factor between the base unit and its smallest subdivison + * @return {number} + */ + getBaseFactor() { + return 1e2; + } + + getChain() { + return 'fiataud'; + } + + getFamily() { + return 'fiat'; + } + + getFullName() { + return 'Australian Dollar'; + } + + /** + * Return whether the given m of n wallet signers/ key amounts are valid for the coin + */ + isValidMofNSetup({ m, n }: { m: number; n: number }) { + return m === 0 && n === 0; + } + + isValidAddress(address: string): boolean { + throw new MethodNotImplementedError(); + } + + generateKeyPair(seed?: Buffer): KeyPair { + throw new MethodNotImplementedError(); + } + + isValidPub(pub: string): boolean { + throw new MethodNotImplementedError(); + } + + async parseTransaction(params: ParseTransactionOptions): Promise { + return {}; + } + + async isWalletAddress(params: VerifyAddressOptions): Promise { + throw new MethodNotImplementedError(); + } + + async verifyTransaction(params: VerifyTransactionOptions): Promise { + return true; + } + + async signTransaction(params: SignTransactionOptions = {}): Promise { + throw new MethodNotImplementedError(); + } + + /** @inheritDoc */ + auditDecryptedKey(params: AuditDecryptedKeyParams): void { + throw new MethodNotImplementedError(); + } +} diff --git a/modules/sdk-core/src/coins/fiatcad.ts b/modules/sdk-core/src/coins/fiatcad.ts new file mode 100644 index 0000000000..c43535907d --- /dev/null +++ b/modules/sdk-core/src/coins/fiatcad.ts @@ -0,0 +1,82 @@ +/** + * @prettier + */ +import { + AuditDecryptedKeyParams, + BaseCoin, + BitGoBase, + KeyPair, + MethodNotImplementedError, + ParsedTransaction, + ParseTransactionOptions, + SignedTransaction, + SignTransactionOptions, + VerifyAddressOptions, + VerifyTransactionOptions, +} from '../'; + +export class FiatCAD extends BaseCoin { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new FiatCAD(bitgo); + } + + /** + * Returns the factor between the base unit and its smallest subdivison + * @return {number} + */ + getBaseFactor() { + return 1e2; + } + + getChain() { + return 'fiatcad'; + } + + getFamily() { + return 'fiat'; + } + + getFullName() { + return 'Canadian Dollar'; + } + + /** + * Return whether the given m of n wallet signers/ key amounts are valid for the coin + */ + isValidMofNSetup({ m, n }: { m: number; n: number }) { + return m === 0 && n === 0; + } + + isValidAddress(address: string): boolean { + throw new MethodNotImplementedError(); + } + + generateKeyPair(seed?: Buffer): KeyPair { + throw new MethodNotImplementedError(); + } + + isValidPub(pub: string): boolean { + throw new MethodNotImplementedError(); + } + + async parseTransaction(params: ParseTransactionOptions): Promise { + return {}; + } + + async isWalletAddress(params: VerifyAddressOptions): Promise { + throw new MethodNotImplementedError(); + } + + async verifyTransaction(params: VerifyTransactionOptions): Promise { + return true; + } + + async signTransaction(params: SignTransactionOptions = {}): Promise { + throw new MethodNotImplementedError(); + } + + /** @inheritDoc */ + auditDecryptedKey(params: AuditDecryptedKeyParams): void { + throw new MethodNotImplementedError(); + } +} diff --git a/modules/sdk-core/src/coins/fiatclp.ts b/modules/sdk-core/src/coins/fiatclp.ts new file mode 100644 index 0000000000..45dae66476 --- /dev/null +++ b/modules/sdk-core/src/coins/fiatclp.ts @@ -0,0 +1,82 @@ +/** + * @prettier + */ +import { + AuditDecryptedKeyParams, + BaseCoin, + BitGoBase, + KeyPair, + MethodNotImplementedError, + ParsedTransaction, + ParseTransactionOptions, + SignedTransaction, + SignTransactionOptions, + VerifyAddressOptions, + VerifyTransactionOptions, +} from '../'; + +export class FiatCLP extends BaseCoin { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new FiatCLP(bitgo); + } + + /** + * Returns the factor between the base unit and its smallest subdivison + * @return {number} + */ + getBaseFactor() { + return 1; + } + + getChain() { + return 'fiatclp'; + } + + getFamily() { + return 'fiat'; + } + + getFullName() { + return 'Chilean Peso'; + } + + /** + * Return whether the given m of n wallet signers/ key amounts are valid for the coin + */ + isValidMofNSetup({ m, n }: { m: number; n: number }) { + return m === 0 && n === 0; + } + + isValidAddress(address: string): boolean { + throw new MethodNotImplementedError(); + } + + generateKeyPair(seed?: Buffer): KeyPair { + throw new MethodNotImplementedError(); + } + + isValidPub(pub: string): boolean { + throw new MethodNotImplementedError(); + } + + async parseTransaction(params: ParseTransactionOptions): Promise { + return {}; + } + + async isWalletAddress(params: VerifyAddressOptions): Promise { + throw new MethodNotImplementedError(); + } + + async verifyTransaction(params: VerifyTransactionOptions): Promise { + return true; + } + + async signTransaction(params: SignTransactionOptions = {}): Promise { + throw new MethodNotImplementedError(); + } + + /** @inheritDoc */ + auditDecryptedKey(params: AuditDecryptedKeyParams): void { + throw new MethodNotImplementedError(); + } +} diff --git a/modules/sdk-core/src/coins/fiatcny.ts b/modules/sdk-core/src/coins/fiatcny.ts new file mode 100644 index 0000000000..8f9ff62bbb --- /dev/null +++ b/modules/sdk-core/src/coins/fiatcny.ts @@ -0,0 +1,82 @@ +/** + * @prettier + */ +import { + AuditDecryptedKeyParams, + BaseCoin, + BitGoBase, + KeyPair, + MethodNotImplementedError, + ParsedTransaction, + ParseTransactionOptions, + SignedTransaction, + SignTransactionOptions, + VerifyAddressOptions, + VerifyTransactionOptions, +} from '../'; + +export class FiatCNY extends BaseCoin { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new FiatCNY(bitgo); + } + + /** + * Returns the factor between the base unit and its smallest subdivison + * @return {number} + */ + getBaseFactor() { + return 1e2; + } + + getChain() { + return 'fiatcny'; + } + + getFamily() { + return 'fiat'; + } + + getFullName() { + return 'Chinese Yuan'; + } + + /** + * Return whether the given m of n wallet signers/ key amounts are valid for the coin + */ + isValidMofNSetup({ m, n }: { m: number; n: number }) { + return m === 0 && n === 0; + } + + isValidAddress(address: string): boolean { + throw new MethodNotImplementedError(); + } + + generateKeyPair(seed?: Buffer): KeyPair { + throw new MethodNotImplementedError(); + } + + isValidPub(pub: string): boolean { + throw new MethodNotImplementedError(); + } + + async parseTransaction(params: ParseTransactionOptions): Promise { + return {}; + } + + async isWalletAddress(params: VerifyAddressOptions): Promise { + throw new MethodNotImplementedError(); + } + + async verifyTransaction(params: VerifyTransactionOptions): Promise { + return true; + } + + async signTransaction(params: SignTransactionOptions = {}): Promise { + throw new MethodNotImplementedError(); + } + + /** @inheritDoc */ + auditDecryptedKey(params: AuditDecryptedKeyParams): void { + throw new MethodNotImplementedError(); + } +} diff --git a/modules/sdk-core/src/coins/fiatcop.ts b/modules/sdk-core/src/coins/fiatcop.ts new file mode 100644 index 0000000000..8e3eabb1ed --- /dev/null +++ b/modules/sdk-core/src/coins/fiatcop.ts @@ -0,0 +1,82 @@ +/** + * @prettier + */ +import { + AuditDecryptedKeyParams, + BaseCoin, + BitGoBase, + KeyPair, + MethodNotImplementedError, + ParsedTransaction, + ParseTransactionOptions, + SignedTransaction, + SignTransactionOptions, + VerifyAddressOptions, + VerifyTransactionOptions, +} from '../'; + +export class FiatCOP extends BaseCoin { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new FiatCOP(bitgo); + } + + /** + * Returns the factor between the base unit and its smallest subdivison + * @return {number} + */ + getBaseFactor() { + return 1; + } + + getChain() { + return 'fiatcop'; + } + + getFamily() { + return 'fiat'; + } + + getFullName() { + return 'Colombian Peso'; + } + + /** + * Return whether the given m of n wallet signers/ key amounts are valid for the coin + */ + isValidMofNSetup({ m, n }: { m: number; n: number }) { + return m === 0 && n === 0; + } + + isValidAddress(address: string): boolean { + throw new MethodNotImplementedError(); + } + + generateKeyPair(seed?: Buffer): KeyPair { + throw new MethodNotImplementedError(); + } + + isValidPub(pub: string): boolean { + throw new MethodNotImplementedError(); + } + + async parseTransaction(params: ParseTransactionOptions): Promise { + return {}; + } + + async isWalletAddress(params: VerifyAddressOptions): Promise { + throw new MethodNotImplementedError(); + } + + async verifyTransaction(params: VerifyTransactionOptions): Promise { + return true; + } + + async signTransaction(params: SignTransactionOptions = {}): Promise { + throw new MethodNotImplementedError(); + } + + /** @inheritDoc */ + auditDecryptedKey(params: AuditDecryptedKeyParams): void { + throw new MethodNotImplementedError(); + } +} diff --git a/modules/sdk-core/src/coins/fiatdkk.ts b/modules/sdk-core/src/coins/fiatdkk.ts new file mode 100644 index 0000000000..164b91f4c8 --- /dev/null +++ b/modules/sdk-core/src/coins/fiatdkk.ts @@ -0,0 +1,82 @@ +/** + * @prettier + */ +import { + AuditDecryptedKeyParams, + BaseCoin, + BitGoBase, + KeyPair, + MethodNotImplementedError, + ParsedTransaction, + ParseTransactionOptions, + SignedTransaction, + SignTransactionOptions, + VerifyAddressOptions, + VerifyTransactionOptions, +} from '../'; + +export class FiatDKK extends BaseCoin { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new FiatDKK(bitgo); + } + + /** + * Returns the factor between the base unit and its smallest subdivison + * @return {number} + */ + getBaseFactor() { + return 1e2; + } + + getChain() { + return 'fiatdkk'; + } + + getFamily() { + return 'fiat'; + } + + getFullName() { + return 'Danish Krone'; + } + + /** + * Return whether the given m of n wallet signers/ key amounts are valid for the coin + */ + isValidMofNSetup({ m, n }: { m: number; n: number }) { + return m === 0 && n === 0; + } + + isValidAddress(address: string): boolean { + throw new MethodNotImplementedError(); + } + + generateKeyPair(seed?: Buffer): KeyPair { + throw new MethodNotImplementedError(); + } + + isValidPub(pub: string): boolean { + throw new MethodNotImplementedError(); + } + + async parseTransaction(params: ParseTransactionOptions): Promise { + return {}; + } + + async isWalletAddress(params: VerifyAddressOptions): Promise { + throw new MethodNotImplementedError(); + } + + async verifyTransaction(params: VerifyTransactionOptions): Promise { + return true; + } + + async signTransaction(params: SignTransactionOptions = {}): Promise { + throw new MethodNotImplementedError(); + } + + /** @inheritDoc */ + auditDecryptedKey(params: AuditDecryptedKeyParams): void { + throw new MethodNotImplementedError(); + } +} diff --git a/modules/sdk-core/src/coins/fiatjpy.ts b/modules/sdk-core/src/coins/fiatjpy.ts new file mode 100644 index 0000000000..4167904ba4 --- /dev/null +++ b/modules/sdk-core/src/coins/fiatjpy.ts @@ -0,0 +1,82 @@ +/** + * @prettier + */ +import { + AuditDecryptedKeyParams, + BaseCoin, + BitGoBase, + KeyPair, + MethodNotImplementedError, + ParsedTransaction, + ParseTransactionOptions, + SignedTransaction, + SignTransactionOptions, + VerifyAddressOptions, + VerifyTransactionOptions, +} from '../'; + +export class FiatJPY extends BaseCoin { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new FiatJPY(bitgo); + } + + /** + * Returns the factor between the base unit and its smallest subdivison + * @return {number} + */ + getBaseFactor() { + return 1; + } + + getChain() { + return 'fiatjpy'; + } + + getFamily() { + return 'fiat'; + } + + getFullName() { + return 'Japanese Yen'; + } + + /** + * Return whether the given m of n wallet signers/ key amounts are valid for the coin + */ + isValidMofNSetup({ m, n }: { m: number; n: number }) { + return m === 0 && n === 0; + } + + isValidAddress(address: string): boolean { + throw new MethodNotImplementedError(); + } + + generateKeyPair(seed?: Buffer): KeyPair { + throw new MethodNotImplementedError(); + } + + isValidPub(pub: string): boolean { + throw new MethodNotImplementedError(); + } + + async parseTransaction(params: ParseTransactionOptions): Promise { + return {}; + } + + async isWalletAddress(params: VerifyAddressOptions): Promise { + throw new MethodNotImplementedError(); + } + + async verifyTransaction(params: VerifyTransactionOptions): Promise { + return true; + } + + async signTransaction(params: SignTransactionOptions = {}): Promise { + throw new MethodNotImplementedError(); + } + + /** @inheritDoc */ + auditDecryptedKey(params: AuditDecryptedKeyParams): void { + throw new MethodNotImplementedError(); + } +} diff --git a/modules/sdk-core/src/coins/fiatkrw.ts b/modules/sdk-core/src/coins/fiatkrw.ts new file mode 100644 index 0000000000..72da93b24b --- /dev/null +++ b/modules/sdk-core/src/coins/fiatkrw.ts @@ -0,0 +1,82 @@ +/** + * @prettier + */ +import { + AuditDecryptedKeyParams, + BaseCoin, + BitGoBase, + KeyPair, + MethodNotImplementedError, + ParsedTransaction, + ParseTransactionOptions, + SignedTransaction, + SignTransactionOptions, + VerifyAddressOptions, + VerifyTransactionOptions, +} from '../'; + +export class FiatKRW extends BaseCoin { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new FiatKRW(bitgo); + } + + /** + * Returns the factor between the base unit and its smallest subdivison + * @return {number} + */ + getBaseFactor() { + return 1; + } + + getChain() { + return 'fiatkrw'; + } + + getFamily() { + return 'fiat'; + } + + getFullName() { + return 'South Korean Won'; + } + + /** + * Return whether the given m of n wallet signers/ key amounts are valid for the coin + */ + isValidMofNSetup({ m, n }: { m: number; n: number }) { + return m === 0 && n === 0; + } + + isValidAddress(address: string): boolean { + throw new MethodNotImplementedError(); + } + + generateKeyPair(seed?: Buffer): KeyPair { + throw new MethodNotImplementedError(); + } + + isValidPub(pub: string): boolean { + throw new MethodNotImplementedError(); + } + + async parseTransaction(params: ParseTransactionOptions): Promise { + return {}; + } + + async isWalletAddress(params: VerifyAddressOptions): Promise { + throw new MethodNotImplementedError(); + } + + async verifyTransaction(params: VerifyTransactionOptions): Promise { + return true; + } + + async signTransaction(params: SignTransactionOptions = {}): Promise { + throw new MethodNotImplementedError(); + } + + /** @inheritDoc */ + auditDecryptedKey(params: AuditDecryptedKeyParams): void { + throw new MethodNotImplementedError(); + } +} diff --git a/modules/sdk-core/src/coins/fiatnok.ts b/modules/sdk-core/src/coins/fiatnok.ts new file mode 100644 index 0000000000..667d76c32c --- /dev/null +++ b/modules/sdk-core/src/coins/fiatnok.ts @@ -0,0 +1,82 @@ +/** + * @prettier + */ +import { + AuditDecryptedKeyParams, + BaseCoin, + BitGoBase, + KeyPair, + MethodNotImplementedError, + ParsedTransaction, + ParseTransactionOptions, + SignedTransaction, + SignTransactionOptions, + VerifyAddressOptions, + VerifyTransactionOptions, +} from '../'; + +export class FiatNOK extends BaseCoin { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new FiatNOK(bitgo); + } + + /** + * Returns the factor between the base unit and its smallest subdivison + * @return {number} + */ + getBaseFactor() { + return 1e2; + } + + getChain() { + return 'fiatnok'; + } + + getFamily() { + return 'fiat'; + } + + getFullName() { + return 'Norwegian Krone'; + } + + /** + * Return whether the given m of n wallet signers/ key amounts are valid for the coin + */ + isValidMofNSetup({ m, n }: { m: number; n: number }) { + return m === 0 && n === 0; + } + + isValidAddress(address: string): boolean { + throw new MethodNotImplementedError(); + } + + generateKeyPair(seed?: Buffer): KeyPair { + throw new MethodNotImplementedError(); + } + + isValidPub(pub: string): boolean { + throw new MethodNotImplementedError(); + } + + async parseTransaction(params: ParseTransactionOptions): Promise { + return {}; + } + + async isWalletAddress(params: VerifyAddressOptions): Promise { + throw new MethodNotImplementedError(); + } + + async verifyTransaction(params: VerifyTransactionOptions): Promise { + return true; + } + + async signTransaction(params: SignTransactionOptions = {}): Promise { + throw new MethodNotImplementedError(); + } + + /** @inheritDoc */ + auditDecryptedKey(params: AuditDecryptedKeyParams): void { + throw new MethodNotImplementedError(); + } +} diff --git a/modules/sdk-core/src/coins/fiatsek.ts b/modules/sdk-core/src/coins/fiatsek.ts new file mode 100644 index 0000000000..d28eb7e5eb --- /dev/null +++ b/modules/sdk-core/src/coins/fiatsek.ts @@ -0,0 +1,82 @@ +/** + * @prettier + */ +import { + AuditDecryptedKeyParams, + BaseCoin, + BitGoBase, + KeyPair, + MethodNotImplementedError, + ParsedTransaction, + ParseTransactionOptions, + SignedTransaction, + SignTransactionOptions, + VerifyAddressOptions, + VerifyTransactionOptions, +} from '../'; + +export class FiatSEK extends BaseCoin { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new FiatSEK(bitgo); + } + + /** + * Returns the factor between the base unit and its smallest subdivison + * @return {number} + */ + getBaseFactor() { + return 1e2; + } + + getChain() { + return 'fiatsek'; + } + + getFamily() { + return 'fiat'; + } + + getFullName() { + return 'Swedish Krona'; + } + + /** + * Return whether the given m of n wallet signers/ key amounts are valid for the coin + */ + isValidMofNSetup({ m, n }: { m: number; n: number }) { + return m === 0 && n === 0; + } + + isValidAddress(address: string): boolean { + throw new MethodNotImplementedError(); + } + + generateKeyPair(seed?: Buffer): KeyPair { + throw new MethodNotImplementedError(); + } + + isValidPub(pub: string): boolean { + throw new MethodNotImplementedError(); + } + + async parseTransaction(params: ParseTransactionOptions): Promise { + return {}; + } + + async isWalletAddress(params: VerifyAddressOptions): Promise { + throw new MethodNotImplementedError(); + } + + async verifyTransaction(params: VerifyTransactionOptions): Promise { + return true; + } + + async signTransaction(params: SignTransactionOptions = {}): Promise { + throw new MethodNotImplementedError(); + } + + /** @inheritDoc */ + auditDecryptedKey(params: AuditDecryptedKeyParams): void { + throw new MethodNotImplementedError(); + } +} diff --git a/modules/sdk-core/src/coins/fiattry.ts b/modules/sdk-core/src/coins/fiattry.ts new file mode 100644 index 0000000000..023ed0c993 --- /dev/null +++ b/modules/sdk-core/src/coins/fiattry.ts @@ -0,0 +1,82 @@ +/** + * @prettier + */ +import { + AuditDecryptedKeyParams, + BaseCoin, + BitGoBase, + KeyPair, + MethodNotImplementedError, + ParsedTransaction, + ParseTransactionOptions, + SignedTransaction, + SignTransactionOptions, + VerifyAddressOptions, + VerifyTransactionOptions, +} from '../'; + +export class FiatTRY extends BaseCoin { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new FiatTRY(bitgo); + } + + /** + * Returns the factor between the base unit and its smallest subdivison + * @return {number} + */ + getBaseFactor() { + return 1e2; + } + + getChain() { + return 'fiattry'; + } + + getFamily() { + return 'fiat'; + } + + getFullName() { + return 'Turkish Lira'; + } + + /** + * Return whether the given m of n wallet signers/ key amounts are valid for the coin + */ + isValidMofNSetup({ m, n }: { m: number; n: number }) { + return m === 0 && n === 0; + } + + isValidAddress(address: string): boolean { + throw new MethodNotImplementedError(); + } + + generateKeyPair(seed?: Buffer): KeyPair { + throw new MethodNotImplementedError(); + } + + isValidPub(pub: string): boolean { + throw new MethodNotImplementedError(); + } + + async parseTransaction(params: ParseTransactionOptions): Promise { + return {}; + } + + async isWalletAddress(params: VerifyAddressOptions): Promise { + throw new MethodNotImplementedError(); + } + + async verifyTransaction(params: VerifyTransactionOptions): Promise { + return true; + } + + async signTransaction(params: SignTransactionOptions = {}): Promise { + throw new MethodNotImplementedError(); + } + + /** @inheritDoc */ + auditDecryptedKey(params: AuditDecryptedKeyParams): void { + throw new MethodNotImplementedError(); + } +} diff --git a/modules/sdk-core/src/coins/fiatuyu.ts b/modules/sdk-core/src/coins/fiatuyu.ts new file mode 100644 index 0000000000..450482b18b --- /dev/null +++ b/modules/sdk-core/src/coins/fiatuyu.ts @@ -0,0 +1,82 @@ +/** + * @prettier + */ +import { + AuditDecryptedKeyParams, + BaseCoin, + BitGoBase, + KeyPair, + MethodNotImplementedError, + ParsedTransaction, + ParseTransactionOptions, + SignedTransaction, + SignTransactionOptions, + VerifyAddressOptions, + VerifyTransactionOptions, +} from '../'; + +export class FiatUYU extends BaseCoin { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new FiatUYU(bitgo); + } + + /** + * Returns the factor between the base unit and its smallest subdivison + * @return {number} + */ + getBaseFactor() { + return 1e2; + } + + getChain() { + return 'fiatuyu'; + } + + getFamily() { + return 'fiat'; + } + + getFullName() { + return 'Uruguayan Peso'; + } + + /** + * Return whether the given m of n wallet signers/ key amounts are valid for the coin + */ + isValidMofNSetup({ m, n }: { m: number; n: number }) { + return m === 0 && n === 0; + } + + isValidAddress(address: string): boolean { + throw new MethodNotImplementedError(); + } + + generateKeyPair(seed?: Buffer): KeyPair { + throw new MethodNotImplementedError(); + } + + isValidPub(pub: string): boolean { + throw new MethodNotImplementedError(); + } + + async parseTransaction(params: ParseTransactionOptions): Promise { + return {}; + } + + async isWalletAddress(params: VerifyAddressOptions): Promise { + throw new MethodNotImplementedError(); + } + + async verifyTransaction(params: VerifyTransactionOptions): Promise { + return true; + } + + async signTransaction(params: SignTransactionOptions = {}): Promise { + throw new MethodNotImplementedError(); + } + + /** @inheritDoc */ + auditDecryptedKey(params: AuditDecryptedKeyParams): void { + throw new MethodNotImplementedError(); + } +} diff --git a/modules/sdk-core/src/coins/fiatzar.ts b/modules/sdk-core/src/coins/fiatzar.ts new file mode 100644 index 0000000000..d3b9e1341e --- /dev/null +++ b/modules/sdk-core/src/coins/fiatzar.ts @@ -0,0 +1,82 @@ +/** + * @prettier + */ +import { + AuditDecryptedKeyParams, + BaseCoin, + BitGoBase, + KeyPair, + MethodNotImplementedError, + ParsedTransaction, + ParseTransactionOptions, + SignedTransaction, + SignTransactionOptions, + VerifyAddressOptions, + VerifyTransactionOptions, +} from '../'; + +export class FiatZAR extends BaseCoin { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new FiatZAR(bitgo); + } + + /** + * Returns the factor between the base unit and its smallest subdivison + * @return {number} + */ + getBaseFactor() { + return 1e2; + } + + getChain() { + return 'fiatzar'; + } + + getFamily() { + return 'fiat'; + } + + getFullName() { + return 'South African Rand'; + } + + /** + * Return whether the given m of n wallet signers/ key amounts are valid for the coin + */ + isValidMofNSetup({ m, n }: { m: number; n: number }) { + return m === 0 && n === 0; + } + + isValidAddress(address: string): boolean { + throw new MethodNotImplementedError(); + } + + generateKeyPair(seed?: Buffer): KeyPair { + throw new MethodNotImplementedError(); + } + + isValidPub(pub: string): boolean { + throw new MethodNotImplementedError(); + } + + async parseTransaction(params: ParseTransactionOptions): Promise { + return {}; + } + + async isWalletAddress(params: VerifyAddressOptions): Promise { + throw new MethodNotImplementedError(); + } + + async verifyTransaction(params: VerifyTransactionOptions): Promise { + return true; + } + + async signTransaction(params: SignTransactionOptions = {}): Promise { + throw new MethodNotImplementedError(); + } + + /** @inheritDoc */ + auditDecryptedKey(params: AuditDecryptedKeyParams): void { + throw new MethodNotImplementedError(); + } +} diff --git a/modules/sdk-core/src/coins/index.ts b/modules/sdk-core/src/coins/index.ts index 1950836c54..935bef272e 100644 --- a/modules/sdk-core/src/coins/index.ts +++ b/modules/sdk-core/src/coins/index.ts @@ -1,15 +1,43 @@ export * from './fiataed'; export * from './tfiataed'; -export * from './fiatsgd'; -export * from './tfiatsgd'; +export * from './fiatars'; +export * from './tfiatars'; +export * from './fiataud'; +export * from './tfiataud'; +export * from './fiatcad'; +export * from './tfiatcad'; +export * from './fiatclp'; +export * from './tfiatclp'; +export * from './fiatcny'; +export * from './tfiatcny'; +export * from './fiatcop'; +export * from './tfiatcop'; +export * from './fiatdkk'; +export * from './tfiatdkk'; export * from './fiateur'; export * from './tfiateur'; export * from './fiatgbp'; export * from './tfiatgbp'; export * from './fiatinr'; export * from './tfiatinr'; +export * from './fiatjpy'; +export * from './tfiatjpy'; +export * from './fiatkrw'; +export * from './tfiatkrw'; +export * from './fiatnok'; +export * from './tfiatnok'; +export * from './fiatsek'; +export * from './tfiatsek'; +export * from './fiatsgd'; +export * from './tfiatsgd'; +export * from './fiattry'; +export * from './tfiattry'; export * from './fiatusd'; export * from './tfiatusd'; +export * from './fiatuyu'; +export * from './tfiatuyu'; +export * from './fiatzar'; +export * from './tfiatzar'; export * from './ofc'; export * from './ofcToken'; export * from './susd'; diff --git a/modules/sdk-core/src/coins/tfiatars.ts b/modules/sdk-core/src/coins/tfiatars.ts new file mode 100644 index 0000000000..2e55a4aa8a --- /dev/null +++ b/modules/sdk-core/src/coins/tfiatars.ts @@ -0,0 +1,19 @@ +/** + * @prettier + */ +import { BaseCoin, BitGoBase } from '../'; +import { FiatARS } from './fiatars'; + +export class TfiatARS extends FiatARS { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new TfiatARS(bitgo); + } + + getChain() { + return 'tfiatars'; + } + + getFullName() { + return 'Testnet Argentine Peso'; + } +} diff --git a/modules/sdk-core/src/coins/tfiataud.ts b/modules/sdk-core/src/coins/tfiataud.ts new file mode 100644 index 0000000000..f739c8a766 --- /dev/null +++ b/modules/sdk-core/src/coins/tfiataud.ts @@ -0,0 +1,19 @@ +/** + * @prettier + */ +import { BaseCoin, BitGoBase } from '../'; +import { FiatAUD } from './fiataud'; + +export class TfiatAUD extends FiatAUD { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new TfiatAUD(bitgo); + } + + getChain() { + return 'tfiataud'; + } + + getFullName() { + return 'Testnet Australian Dollar'; + } +} diff --git a/modules/sdk-core/src/coins/tfiatcad.ts b/modules/sdk-core/src/coins/tfiatcad.ts new file mode 100644 index 0000000000..b7a9e90b02 --- /dev/null +++ b/modules/sdk-core/src/coins/tfiatcad.ts @@ -0,0 +1,19 @@ +/** + * @prettier + */ +import { BaseCoin, BitGoBase } from '../'; +import { FiatCAD } from './fiatcad'; + +export class TfiatCAD extends FiatCAD { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new TfiatCAD(bitgo); + } + + getChain() { + return 'tfiatcad'; + } + + getFullName() { + return 'Testnet Canadian Dollar'; + } +} diff --git a/modules/sdk-core/src/coins/tfiatclp.ts b/modules/sdk-core/src/coins/tfiatclp.ts new file mode 100644 index 0000000000..ea002addba --- /dev/null +++ b/modules/sdk-core/src/coins/tfiatclp.ts @@ -0,0 +1,19 @@ +/** + * @prettier + */ +import { BaseCoin, BitGoBase } from '../'; +import { FiatCLP } from './fiatclp'; + +export class TfiatCLP extends FiatCLP { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new TfiatCLP(bitgo); + } + + getChain() { + return 'tfiatclp'; + } + + getFullName() { + return 'Testnet Chilean Peso'; + } +} diff --git a/modules/sdk-core/src/coins/tfiatcny.ts b/modules/sdk-core/src/coins/tfiatcny.ts new file mode 100644 index 0000000000..e2667ac9ad --- /dev/null +++ b/modules/sdk-core/src/coins/tfiatcny.ts @@ -0,0 +1,19 @@ +/** + * @prettier + */ +import { BaseCoin, BitGoBase } from '../'; +import { FiatCNY } from './fiatcny'; + +export class TfiatCNY extends FiatCNY { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new TfiatCNY(bitgo); + } + + getChain() { + return 'tfiatcny'; + } + + getFullName() { + return 'Testnet Chinese Yuan'; + } +} diff --git a/modules/sdk-core/src/coins/tfiatcop.ts b/modules/sdk-core/src/coins/tfiatcop.ts new file mode 100644 index 0000000000..9959ac1269 --- /dev/null +++ b/modules/sdk-core/src/coins/tfiatcop.ts @@ -0,0 +1,19 @@ +/** + * @prettier + */ +import { BaseCoin, BitGoBase } from '../'; +import { FiatCOP } from './fiatcop'; + +export class TfiatCOP extends FiatCOP { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new TfiatCOP(bitgo); + } + + getChain() { + return 'tfiatcop'; + } + + getFullName() { + return 'Testnet Colombian Peso'; + } +} diff --git a/modules/sdk-core/src/coins/tfiatdkk.ts b/modules/sdk-core/src/coins/tfiatdkk.ts new file mode 100644 index 0000000000..e342a3d8d8 --- /dev/null +++ b/modules/sdk-core/src/coins/tfiatdkk.ts @@ -0,0 +1,19 @@ +/** + * @prettier + */ +import { BaseCoin, BitGoBase } from '../'; +import { FiatDKK } from './fiatdkk'; + +export class TfiatDKK extends FiatDKK { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new TfiatDKK(bitgo); + } + + getChain() { + return 'tfiatdkk'; + } + + getFullName() { + return 'Testnet Danish Krone'; + } +} diff --git a/modules/sdk-core/src/coins/tfiatjpy.ts b/modules/sdk-core/src/coins/tfiatjpy.ts new file mode 100644 index 0000000000..cac22aaa25 --- /dev/null +++ b/modules/sdk-core/src/coins/tfiatjpy.ts @@ -0,0 +1,19 @@ +/** + * @prettier + */ +import { BaseCoin, BitGoBase } from '../'; +import { FiatJPY } from './fiatjpy'; + +export class TfiatJPY extends FiatJPY { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new TfiatJPY(bitgo); + } + + getChain() { + return 'tfiatjpy'; + } + + getFullName() { + return 'Testnet Japanese Yen'; + } +} diff --git a/modules/sdk-core/src/coins/tfiatkrw.ts b/modules/sdk-core/src/coins/tfiatkrw.ts new file mode 100644 index 0000000000..6fbe28425c --- /dev/null +++ b/modules/sdk-core/src/coins/tfiatkrw.ts @@ -0,0 +1,19 @@ +/** + * @prettier + */ +import { BaseCoin, BitGoBase } from '../'; +import { FiatKRW } from './fiatkrw'; + +export class TfiatKRW extends FiatKRW { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new TfiatKRW(bitgo); + } + + getChain() { + return 'tfiatkrw'; + } + + getFullName() { + return 'Testnet South Korean Won'; + } +} diff --git a/modules/sdk-core/src/coins/tfiatnok.ts b/modules/sdk-core/src/coins/tfiatnok.ts new file mode 100644 index 0000000000..53b8e69fdb --- /dev/null +++ b/modules/sdk-core/src/coins/tfiatnok.ts @@ -0,0 +1,19 @@ +/** + * @prettier + */ +import { BaseCoin, BitGoBase } from '../'; +import { FiatNOK } from './fiatnok'; + +export class TfiatNOK extends FiatNOK { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new TfiatNOK(bitgo); + } + + getChain() { + return 'tfiatnok'; + } + + getFullName() { + return 'Testnet Norwegian Krone'; + } +} diff --git a/modules/sdk-core/src/coins/tfiatsek.ts b/modules/sdk-core/src/coins/tfiatsek.ts new file mode 100644 index 0000000000..ac6d37613b --- /dev/null +++ b/modules/sdk-core/src/coins/tfiatsek.ts @@ -0,0 +1,19 @@ +/** + * @prettier + */ +import { BaseCoin, BitGoBase } from '../'; +import { FiatSEK } from './fiatsek'; + +export class TfiatSEK extends FiatSEK { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new TfiatSEK(bitgo); + } + + getChain() { + return 'tfiatsek'; + } + + getFullName() { + return 'Testnet Swedish Krona'; + } +} diff --git a/modules/sdk-core/src/coins/tfiattry.ts b/modules/sdk-core/src/coins/tfiattry.ts new file mode 100644 index 0000000000..62186e7336 --- /dev/null +++ b/modules/sdk-core/src/coins/tfiattry.ts @@ -0,0 +1,19 @@ +/** + * @prettier + */ +import { BaseCoin, BitGoBase } from '../'; +import { FiatTRY } from './fiattry'; + +export class TfiatTRY extends FiatTRY { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new TfiatTRY(bitgo); + } + + getChain() { + return 'tfiattry'; + } + + getFullName() { + return 'Testnet Turkish Lira'; + } +} diff --git a/modules/sdk-core/src/coins/tfiatuyu.ts b/modules/sdk-core/src/coins/tfiatuyu.ts new file mode 100644 index 0000000000..a9db4edf1f --- /dev/null +++ b/modules/sdk-core/src/coins/tfiatuyu.ts @@ -0,0 +1,19 @@ +/** + * @prettier + */ +import { BaseCoin, BitGoBase } from '../'; +import { FiatUYU } from './fiatuyu'; + +export class TfiatUYU extends FiatUYU { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new TfiatUYU(bitgo); + } + + getChain() { + return 'tfiatuyu'; + } + + getFullName() { + return 'Testnet Uruguayan Peso'; + } +} diff --git a/modules/sdk-core/src/coins/tfiatzar.ts b/modules/sdk-core/src/coins/tfiatzar.ts new file mode 100644 index 0000000000..d7dec7dcc6 --- /dev/null +++ b/modules/sdk-core/src/coins/tfiatzar.ts @@ -0,0 +1,19 @@ +/** + * @prettier + */ +import { BaseCoin, BitGoBase } from '../'; +import { FiatZAR } from './fiatzar'; + +export class TfiatZAR extends FiatZAR { + static createInstance(bitgo: BitGoBase): BaseCoin { + return new TfiatZAR(bitgo); + } + + getChain() { + return 'tfiatzar'; + } + + getFullName() { + return 'Testnet South African Rand'; + } +}