@rango-dev/provider-tonconnect 0.1.1-next.0

package/dist/helpers.d.ts

@@ -0,0 +1,163 @@
+import type { TonConnectUI } from '@tonconnect/ui';
+export declare function getTonConnectUIModule(): Promise<{
+    default: typeof import("@tonconnect/ui");
+    THEME: typeof import("@tonconnect/ui").THEME;
+    TonConnectUI: typeof TonConnectUI;
+    TonConnectUIError: typeof import("@tonconnect/ui").TonConnectUIError;
+    createConnectionCompletedEvent(version: import("@tonconnect/sdk").Version, wallet: import("@tonconnect/sdk").Wallet | null): import("@tonconnect/sdk").ConnectionCompletedEvent;
+    createConnectionErrorEvent(version: import("@tonconnect/sdk").Version, error_message: string, errorCode: void | import("@tonconnect/sdk").CONNECT_EVENT_ERROR_CODES): import("@tonconnect/sdk").ConnectionErrorEvent;
+    createConnectionRestoringCompletedEvent(version: import("@tonconnect/sdk").Version, wallet: import("@tonconnect/sdk").Wallet | null): import("@tonconnect/sdk").ConnectionRestoringCompletedEvent;
+    createConnectionRestoringErrorEvent(version: import("@tonconnect/sdk").Version, errorMessage: string): import("@tonconnect/sdk").ConnectionRestoringErrorEvent;
+    createConnectionRestoringStartedEvent(version: import("@tonconnect/sdk").Version): import("@tonconnect/sdk").ConnectionRestoringStartedEvent;
+    createConnectionStartedEvent(version: import("@tonconnect/sdk").Version): import("@tonconnect/sdk").ConnectionStartedEvent;
+    createDisconnectionEvent(version: import("@tonconnect/sdk").Version, wallet: import("@tonconnect/sdk").Wallet | null, scope: "dapp" | "wallet"): import("@tonconnect/sdk").DisconnectionEvent;
+    createRequestVersionEvent(): import("@tonconnect/sdk").RequestVersionEvent;
+    createResponseVersionEvent(version: string): import("@tonconnect/sdk").ResponseVersionEvent;
+    createTransactionSentForSignatureEvent(version: import("@tonconnect/sdk").Version, wallet: import("@tonconnect/sdk").Wallet | null, transaction: import("@tonconnect/sdk").SendTransactionRequest): import("@tonconnect/sdk").TransactionSentForSignatureEvent;
+    createTransactionSignedEvent(version: import("@tonconnect/sdk").Version, wallet: import("@tonconnect/sdk").Wallet | null, transaction: import("@tonconnect/sdk").SendTransactionRequest, signedTransaction: import("@tonconnect/sdk").SendTransactionResponse): import("@tonconnect/sdk").TransactionSignedEvent;
+    createTransactionSigningFailedEvent(version: import("@tonconnect/sdk").Version, wallet: import("@tonconnect/sdk").Wallet | null, transaction: import("@tonconnect/sdk").SendTransactionRequest, errorMessage: string, errorCode: void | import("@tonconnect/sdk").SEND_TRANSACTION_ERROR_CODES): import("@tonconnect/sdk").TransactionSigningFailedEvent;
+    createVersionInfo(version: import("@tonconnect/sdk").Version): import("@tonconnect/sdk").Version;
+    encodeTelegramUrlParameters(parameters: string): string;
+    isTelegramUrl(link: string | undefined): link is string;
+    isWalletInfoCurrentlyEmbedded(value: import("@tonconnect/sdk").WalletInfo): value is import("@tonconnect/sdk").WalletInfoCurrentlyEmbedded;
+    isWalletInfoCurrentlyInjected(value: import("@tonconnect/sdk").WalletInfo): value is import("@tonconnect/sdk").WalletInfoCurrentlyInjected;
+    isWalletInfoInjectable(value: import("@tonconnect/sdk").WalletInfo): value is import("@tonconnect/sdk").WalletInfoInjectable;
+    isWalletInfoInjected(value: import("@tonconnect/sdk").WalletInfo): value is import("@tonconnect/sdk").WalletInfoInjected;
+    isWalletInfoRemote(value: import("@tonconnect/sdk").WalletInfo): value is import("@tonconnect/sdk").WalletInfoRemote;
+    toUserFriendlyAddress(hexAddress: string, testOnly?: boolean | undefined): string;
+    BadRequestError: typeof import("@tonconnect/sdk").BadRequestError;
+    BrowserEventDispatcher: typeof import("@tonconnect/sdk").BrowserEventDispatcher;
+    CHAIN: typeof import("@tonconnect/sdk").CHAIN;
+    CONNECT_EVENT_ERROR_CODES: typeof import("@tonconnect/sdk").CONNECT_EVENT_ERROR_CODES;
+    CONNECT_ITEM_ERROR_CODES: typeof import("@tonconnect/sdk").CONNECT_ITEM_ERROR_CODES;
+    FetchWalletsError: typeof import("@tonconnect/sdk").FetchWalletsError;
+    LocalstorageNotFoundError: typeof import("@tonconnect/sdk").LocalstorageNotFoundError;
+    ParseHexError: typeof import("@tonconnect/sdk").ParseHexError;
+    SEND_TRANSACTION_ERROR_CODES: typeof import("@tonconnect/sdk").SEND_TRANSACTION_ERROR_CODES;
+    TonConnect: typeof import("@tonconnect/sdk").TonConnect;
+    TonConnectError: typeof import("@tonconnect/sdk").TonConnectError;
+    UnknownAppError: typeof import("@tonconnect/sdk").UnknownAppError;
+    UnknownError: typeof import("@tonconnect/sdk").UnknownError;
+    UserRejectsError: typeof import("@tonconnect/sdk").UserRejectsError;
+    WalletAlreadyConnectedError: typeof import("@tonconnect/sdk").WalletAlreadyConnectedError;
+    WalletNotConnectedError: typeof import("@tonconnect/sdk").WalletNotConnectedError;
+    WalletNotInjectedError: typeof import("@tonconnect/sdk").WalletNotInjectedError;
+    WalletsListManager: typeof import("@tonconnect/sdk").WalletsListManager;
+    WrongAddressError: typeof import("@tonconnect/sdk").WrongAddressError;
+}>;
+export declare function getTonCoreModule(): Promise<{
+    default: typeof import("@ton/core");
+    Address: typeof import("@ton/core").Address;
+    address: typeof import("@ton/core").address;
+    ExternalAddress: typeof import("@ton/core").ExternalAddress;
+    ADNLAddress: typeof import("@ton/core").ADNLAddress;
+    contractAddress: typeof import("@ton/core").contractAddress;
+    BitString: typeof import("@ton/core").BitString;
+    BitReader: typeof import("@ton/core").BitReader;
+    BitBuilder: typeof import("@ton/core").BitBuilder;
+    Builder: typeof import("@ton/core").Builder;
+    beginCell: typeof import("@ton/core").beginCell;
+    Slice: typeof import("@ton/core").Slice;
+    CellType: typeof import("@ton/core").CellType;
+    Cell: typeof import("@ton/core").Cell;
+    Dictionary: typeof import("@ton/core").Dictionary;
+    exoticMerkleProof: typeof import("@ton/core").exoticMerkleProof;
+    convertToMerkleProof: typeof import("@ton/core").convertToMerkleProof;
+    exoticMerkleUpdate: typeof import("@ton/core").exoticMerkleUpdate;
+    exoticPruned: typeof import("@ton/core").exoticPruned;
+    generateMerkleProof: typeof import("@ton/core").generateMerkleProof;
+    generateMerkleProofDirect: typeof import("@ton/core").generateMerkleProofDirect;
+    generateMerkleUpdate: typeof import("@ton/core").generateMerkleUpdate;
+    parseTuple: typeof import("@ton/core").parseTuple;
+    serializeTuple: typeof import("@ton/core").serializeTuple;
+    TupleReader: typeof import("@ton/core").TupleReader;
+    TupleBuilder: typeof import("@ton/core").TupleBuilder;
+    openContract: typeof import("@ton/core").openContract;
+    ComputeError: typeof import("@ton/core").ComputeError;
+    toNano: typeof import("@ton/core").toNano;
+    fromNano: typeof import("@ton/core").fromNano;
+    crc16: typeof import("@ton/core").crc16;
+    crc32c: typeof import("@ton/core").crc32c;
+    base32Decode: typeof import("@ton/core").base32Decode;
+    base32Encode: typeof import("@ton/core").base32Encode;
+    getMethodId: typeof import("@ton/core").getMethodId;
+    safeSign: typeof import("@ton/core").safeSign;
+    safeSignVerify: typeof import("@ton/core").safeSignVerify;
+    internal: typeof import("@ton/core").internal;
+    external: typeof import("@ton/core").external;
+    comment: typeof import("@ton/core").comment;
+    loadAccount: typeof import("@ton/core").loadAccount;
+    storeAccount: typeof import("@ton/core").storeAccount;
+    loadAccountState: typeof import("@ton/core").loadAccountState;
+    storeAccountState: typeof import("@ton/core").storeAccountState;
+    loadAccountStatus: typeof import("@ton/core").loadAccountStatus;
+    storeAccountStatus: typeof import("@ton/core").storeAccountStatus;
+    loadAccountStatusChange: typeof import("@ton/core").loadAccountStatusChange;
+    storeAccountStatusChange: typeof import("@ton/core").storeAccountStatusChange;
+    loadAccountStorage: typeof import("@ton/core").loadAccountStorage;
+    storeAccountStorage: typeof import("@ton/core").storeAccountStorage;
+    loadOutAction: typeof import("@ton/core").loadOutAction;
+    storeOutAction: typeof import("@ton/core").storeOutAction;
+    loadOutList: typeof import("@ton/core").loadOutList;
+    storeOutList: typeof import("@ton/core").storeOutList;
+    loadCommonMessageInfo: typeof import("@ton/core").loadCommonMessageInfo;
+    storeCommonMessageInfo: typeof import("@ton/core").storeCommonMessageInfo;
+    loadCommonMessageInfoRelaxed: typeof import("@ton/core").loadCommonMessageInfoRelaxed;
+    storeCommonMessageInfoRelaxed: typeof import("@ton/core").storeCommonMessageInfoRelaxed;
+    loadComputeSkipReason: typeof import("@ton/core").loadComputeSkipReason;
+    storeComputeSkipReason: typeof import("@ton/core").storeComputeSkipReason;
+    loadCurrencyCollection: typeof import("@ton/core").loadCurrencyCollection;
+    storeCurrencyCollection: typeof import("@ton/core").storeCurrencyCollection;
+    loadDepthBalanceInfo: typeof import("@ton/core").loadDepthBalanceInfo;
+    storeDepthBalanceInfo: typeof import("@ton/core").storeDepthBalanceInfo;
+    loadHashUpdate: typeof import("@ton/core").loadHashUpdate;
+    storeHashUpdate: typeof import("@ton/core").storeHashUpdate;
+    loadMasterchainStateExtra: typeof import("@ton/core").loadMasterchainStateExtra;
+    loadMessage: typeof import("@ton/core").loadMessage;
+    storeMessage: typeof import("@ton/core").storeMessage;
+    loadMessageRelaxed: typeof import("@ton/core").loadMessageRelaxed;
+    storeMessageRelaxed: typeof import("@ton/core").storeMessageRelaxed;
+    SendMode: typeof import("@ton/core").SendMode;
+    ReserveMode: typeof import("@ton/core").ReserveMode;
+    loadShardAccount: typeof import("@ton/core").loadShardAccount;
+    storeShardAccount: typeof import("@ton/core").storeShardAccount;
+    ShardAccountRefValue: import("@ton/core").DictionaryValue<import("@ton/core").ShardAccountRef>;
+    loadShardAccounts: typeof import("@ton/core").loadShardAccounts;
+    storeShardAccounts: typeof import("@ton/core").storeShardAccounts;
+    loadShardIdent: typeof import("@ton/core").loadShardIdent;
+    storeShardIdent: typeof import("@ton/core").storeShardIdent;
+    loadShardStateUnsplit: typeof import("@ton/core").loadShardStateUnsplit;
+    loadSimpleLibrary: typeof import("@ton/core").loadSimpleLibrary;
+    storeSimpleLibrary: typeof import("@ton/core").storeSimpleLibrary;
+    loadLibRef: typeof import("@ton/core").loadLibRef;
+    storeLibRef: typeof import("@ton/core").storeLibRef;
+    loadSplitMergeInfo: typeof import("@ton/core").loadSplitMergeInfo;
+    storeSplitMergeInfo: typeof import("@ton/core").storeSplitMergeInfo;
+    loadStateInit: typeof import("@ton/core").loadStateInit;
+    storeStateInit: typeof import("@ton/core").storeStateInit;
+    loadStorageInfo: typeof import("@ton/core").loadStorageInfo;
+    storeStorageInfo: typeof import("@ton/core").storeStorageInfo;
+    loadStorageUsed: typeof import("@ton/core").loadStorageUsed;
+    storeStorageUsed: typeof import("@ton/core").storeStorageUsed;
+    loadStorageUsedShort: typeof import("@ton/core").loadStorageUsedShort;
+    storeStorageUsedShort: typeof import("@ton/core").storeStorageUsedShort;
+    loadTickTock: typeof import("@ton/core").loadTickTock;
+    storeTickTock: typeof import("@ton/core").storeTickTock;
+    loadTransaction: typeof import("@ton/core").loadTransaction;
+    storeTransaction: typeof import("@ton/core").storeTransaction;
+    loadTransactionActionPhase: typeof import("@ton/core").loadTransactionActionPhase;
+    storeTransactionActionPhase: typeof import("@ton/core").storeTransactionActionPhase;
+    loadTransactionBouncePhase: typeof import("@ton/core").loadTransactionBouncePhase;
+    storeTransactionBouncePhase: typeof import("@ton/core").storeTransactionBouncePhase;
+    loadTransactionComputePhase: typeof import("@ton/core").loadTransactionComputePhase;
+    storeTransactionComputePhase: typeof import("@ton/core").storeTransactionComputePhase;
+    loadTransactionCreditPhase: typeof import("@ton/core").loadTransactionCreditPhase;
+    storeTransactionCreditPhase: typeof import("@ton/core").storeTransactionCreditPhase;
+    loadTransactionDescription: typeof import("@ton/core").loadTransactionDescription;
+    storeTransactionDescription: typeof import("@ton/core").storeTransactionDescription;
+    loadTransactionStoragePhase: typeof import("@ton/core").loadTransactionStoragePhase;
+    storeTransactionsStoragePhase: typeof import("@ton/core").storeTransactionsStoragePhase;
+}>;
+export declare function waitForConnection(tonConnectUI: TonConnectUI): Promise<string>;
+export declare function parseAddress(rawAddress: string): Promise<string>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAEnD,wBAAsB,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAG1C;AAED,wBAAsB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGrC;AAED,wBAAsB,iBAAiB,CACrC,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,MAAM,CAAC,CA2BjB;AAED,wBAAsB,YAAY,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAGtE"}

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import type { Environments } from './types.js';
+import type { CanEagerConnect, CanSwitchNetwork, Connect, Disconnect, GetInstance, WalletInfo } from '@rango-dev/wallets-shared';
+import type { TonConnectUI } from '@tonconnect/ui';
+import type { BlockchainMeta, SignerFactory } from 'rango-types';
+import { WalletTypes } from '@rango-dev/wallets-shared';
+export declare const config: {
+    type: WalletTypes;
+    isAsyncInstance: boolean;
+    checkInstallation: boolean;
+};
+export type { Environments };
+export declare const init: (environments: Environments) => void;
+export declare const getInstance: GetInstance;
+export declare const connect: Connect;
+export declare const canEagerConnect: CanEagerConnect;
+export declare const canSwitchNetworkTo: CanSwitchNetwork;
+export declare const getSigners: (provider: TonConnectUI) => Promise<SignerFactory>;
+export declare const getWalletInfo: (allBlockChains: BlockchainMeta[]) => WalletInfo;
+export declare const disconnect: Disconnect;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,KAAK,EACV,eAAe,EACf,gBAAgB,EAChB,OAAO,EACP,UAAU,EACV,WAAW,EACX,UAAU,EACX,MAAM,2BAA2B,CAAC;AACnC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjE,OAAO,EAAY,WAAW,EAAE,MAAM,2BAA2B,CAAC;AAgBlE,eAAO,MAAM,MAAM;;;;CAIlB,CAAC;AAEF,YAAY,EAAE,YAAY,EAAE,CAAC;AAE7B,eAAO,MAAM,IAAI,iBAAkB,YAAY,SAE9C,CAAC;AAIF,eAAO,MAAM,WAAW,EAAE,WAMzB,CAAC;AAEF,eAAO,MAAM,OAAO,EAAE,OAiBrB,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,eAI7B,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,gBAA8B,CAAC;AAEhE,eAAO,MAAM,UAAU,EAAE,CAAC,QAAQ,EAAE,YAAY,KAAK,OAAO,CAAC,aAAa,CAClE,CAAC;AAET,eAAO,MAAM,aAAa,EAAE,CAAC,cAAc,EAAE,cAAc,EAAE,KAAK,UAWjE,CAAC;AAEF,eAAO,MAAM,UAAU,EAAE,UAGxB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+var l=Object.defineProperty;var o=(n,t)=>l(n,"name",{value:t,configurable:!0});var w=(n,t)=>()=>(n&&(t=n(n=0)),t);var h=(n,t)=>{for(var e in t)l(n,e,{get:t[e],enumerable:!0})};var g={};h(g,{CustomTonSigner:()=>i});import{Cell as U}from"@ton/core";import{CHAIN as S}from"@tonconnect/ui";import{SignerError as x}from"rango-types";var i,u=w(()=>{"use strict";i=class{static{o(this,"CustomTonSigner")}provider;constructor(t){this.provider=t}async signMessage(){throw x.UnimplementedError("signMessage")}async signAndSendTx(t){let{blockChain:e,type:c,...s}=t,r=await this.provider.sendTransaction({...s,network:S.MAINNET});return{hash:U.fromBase64(r.boc).hash().toString("hex")}}}});import{Networks as f,WalletTypes as E}from"@rango-dev/wallets-shared";import{tonBlockchain as k}from"rango-types";async function m(){return await import("@tonconnect/ui")}o(m,"getTonConnectUIModule");async function I(){return await import("@ton/core")}o(I,"getTonCoreModule");async function C(n){return new Promise((t,e)=>{let c=n.onStatusChange(r=>{!!r?.account.address&&(c(),t(r.account.address))},r=>{c(),e(r)}),s=n.onModalStateChange(r=>{r.closeReason==="action-cancelled"&&(c(),s(),e(new Error("The action was canceled by the user")))})})}o(C,"waitForConnection");async function a(n){return(await I()).Address.parse(n).toString({bounceable:!1})}o(a,"parseAddress");import{DefaultSignerFactory as b,TransactionType as N}from"rango-types";async function p(n){let t=new b,{CustomTonSigner:e}=await Promise.resolve().then(()=>(u(),g));return t.registerSigner(N.TON,new e(n)),t}o(p,"getSigners");var T={manifestUrl:""},v=E.TON_CONNECT,q={type:v,isAsyncInstance:!0,checkInstallation:!1},z=o(n=>{T=n},"init"),d=null,J=o(async()=>{if(!d){let{TonConnectUI:n}=await m();d=new n(T)}return d},"getInstance"),K=o(async({instance:n})=>{let t=n;if(await t.connectionRestored&&t.account?.address)return{accounts:[await a(t.account.address)],chainId:f.TON};await t.openModal();let c=await C(t);return{accounts:[await a(c)],chainId:f.TON}},"connect"),Q=o(async({instance:n})=>await n.connectionRestored,"canEagerConnect"),V=o(()=>!1,"canSwitchNetworkTo"),X=p,Y=o(n=>({name:"TON Connect",img:"https://raw.githubusercontent.com/rango-exchange/assets/7fb19ed5d5019b4d6a41ce91b39cde64f86af4c6/wallets/tonconnect/icon.svg",installLink:"",color:"#fff",supportedChains:k(n)}),"getWalletInfo"),Z=o(async({instance:n})=>{await n.disconnect()},"disconnect");export{Q as canEagerConnect,V as canSwitchNetworkTo,q as config,K as connect,Z as disconnect,J as getInstance,X as getSigners,Y as getWalletInfo,z as init};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/ton-signer.ts", "../src/index.ts", "../src/helpers.ts", "../src/signer.ts"],
+  "sourcesContent": ["import type { TonConnectUI } from '@tonconnect/ui';\nimport type { GenericSigner, TonTransaction } from 'rango-types';\n\nimport { Cell } from '@ton/core';\nimport { CHAIN } from '@tonconnect/ui';\nimport { SignerError } from 'rango-types';\n\nexport class CustomTonSigner implements GenericSigner<TonTransaction> {\n  private provider: TonConnectUI;\n\n  constructor(provider: TonConnectUI) {\n    this.provider = provider;\n  }\n\n  async signMessage(): Promise<string> {\n    throw SignerError.UnimplementedError('signMessage');\n  }\n\n  async signAndSendTx(tx: TonTransaction): Promise<{ hash: string }> {\n    const { blockChain, type, ...txObjectForSign } = tx;\n    const result = await this.provider.sendTransaction({\n      ...txObjectForSign,\n      network: CHAIN.MAINNET,\n    });\n\n    const hash = Cell.fromBase64(result.boc).hash().toString('hex');\n    return { hash };\n  }\n}\n", "import type { Environments } from './types.js';\nimport type {\n  CanEagerConnect,\n  CanSwitchNetwork,\n  Connect,\n  Disconnect,\n  GetInstance,\n  WalletInfo,\n} from '@rango-dev/wallets-shared';\nimport type { TonConnectUI } from '@tonconnect/ui';\nimport type { BlockchainMeta, SignerFactory } from 'rango-types';\n\nimport { Networks, WalletTypes } from '@rango-dev/wallets-shared';\nimport { tonBlockchain } from 'rango-types';\n\nimport {\n  getTonConnectUIModule,\n  parseAddress,\n  waitForConnection,\n} from './helpers.js';\nimport signer from './signer.js';\n\nlet envs: Environments = {\n  manifestUrl: '',\n};\n\nconst WALLET = WalletTypes.TON_CONNECT;\n\nexport const config = {\n  type: WALLET,\n  isAsyncInstance: true,\n  checkInstallation: false,\n};\n\nexport type { Environments };\n\nexport const init = (environments: Environments) => {\n  envs = environments;\n};\n\nlet instance: TonConnectUI | null = null;\n\nexport const getInstance: GetInstance = async () => {\n  if (!instance) {\n    const { TonConnectUI } = await getTonConnectUIModule();\n    instance = new TonConnectUI(envs);\n  }\n  return instance;\n};\n\nexport const connect: Connect = async ({ instance }) => {\n  const tonConnectUI: TonConnectUI = instance;\n  const connectionRestored = await tonConnectUI.connectionRestored;\n\n  if (connectionRestored && tonConnectUI.account?.address) {\n    const parsedAddress = await parseAddress(tonConnectUI.account.address);\n    return { accounts: [parsedAddress], chainId: Networks.TON };\n  }\n\n  await tonConnectUI.openModal();\n  const result = await waitForConnection(tonConnectUI);\n  const parsedAddress = await parseAddress(result);\n\n  return {\n    accounts: [parsedAddress],\n    chainId: Networks.TON,\n  };\n};\n\nexport const canEagerConnect: CanEagerConnect = async ({ instance }) => {\n  const tonConnectUI = instance as TonConnectUI;\n  const connectionRestored = await tonConnectUI.connectionRestored;\n  return connectionRestored;\n};\n\nexport const canSwitchNetworkTo: CanSwitchNetwork = () => false;\n\nexport const getSigners: (provider: TonConnectUI) => Promise<SignerFactory> =\n  signer;\n\nexport const getWalletInfo: (allBlockChains: BlockchainMeta[]) => WalletInfo = (\n  allBlockChains\n) => {\n  const ton = tonBlockchain(allBlockChains);\n  return {\n    name: 'TON Connect',\n    img: 'https://raw.githubusercontent.com/rango-exchange/assets/7fb19ed5d5019b4d6a41ce91b39cde64f86af4c6/wallets/tonconnect/icon.svg',\n    installLink: '',\n    color: '#fff',\n    supportedChains: ton,\n  };\n};\n\nexport const disconnect: Disconnect = async ({ instance }) => {\n  const tonConnectUI = instance as TonConnectUI;\n  await tonConnectUI.disconnect();\n};\n", "import type { TonConnectUI } from '@tonconnect/ui';\n\nexport async function getTonConnectUIModule() {\n  const tonConnectUI = await import('@tonconnect/ui');\n  return tonConnectUI;\n}\n\nexport async function getTonCoreModule() {\n  const tonCore = await import('@ton/core');\n  return tonCore;\n}\n\nexport async function waitForConnection(\n  tonConnectUI: TonConnectUI\n): Promise<string> {\n  return new Promise((resolve, reject) => {\n    const unsubscribeStatusChange = tonConnectUI.onStatusChange(\n      (state) => {\n        const walletConnected = !!state?.account.address;\n\n        if (walletConnected) {\n          unsubscribeStatusChange();\n          resolve(state.account.address);\n        }\n      },\n      (error) => {\n        unsubscribeStatusChange();\n        reject(error);\n      }\n    );\n\n    const unsubscribeModalStateChange = tonConnectUI.onModalStateChange(\n      (modalState) => {\n        if (modalState.closeReason === 'action-cancelled') {\n          unsubscribeStatusChange();\n          unsubscribeModalStateChange();\n          reject(new Error('The action was canceled by the user'));\n        }\n      }\n    );\n  });\n}\n\nexport async function parseAddress(rawAddress: string): Promise<string> {\n  const tonCore = await getTonCoreModule();\n  return tonCore.Address.parse(rawAddress).toString({ bounceable: false });\n}\n", "import type { TonConnectUI } from '@tonconnect/ui';\nimport type { SignerFactory } from 'rango-types';\n\nimport { DefaultSignerFactory, TransactionType as TxType } from 'rango-types';\n\nexport default async function getSigners(\n  provider: TonConnectUI\n): Promise<SignerFactory> {\n  const signers = new DefaultSignerFactory();\n  const { CustomTonSigner } = await import('./ton-signer.js');\n  signers.registerSigner(TxType.TON, new CustomTonSigner(provider));\n  return signers;\n}\n"],
+  "mappings": "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",
+  "names": ["ton_signer_exports", "__export", "CustomTonSigner", "Cell", "CHAIN", "SignerError", "init_ton_signer", "__esmMin", "__name", "provider", "tx", "blockChain", "type", "txObjectForSign", "result", "Networks", "WalletTypes", "tonBlockchain", "getTonConnectUIModule", "__name", "getTonCoreModule", "waitForConnection", "tonConnectUI", "resolve", "reject", "unsubscribeStatusChange", "state", "error", "unsubscribeModalStateChange", "modalState", "parseAddress", "rawAddress", "DefaultSignerFactory", "TxType", "getSigners", "provider", "signers", "DefaultSignerFactory", "CustomTonSigner", "TxType", "__name", "envs", "WALLET", "WalletTypes", "config", "init", "__name", "environments", "instance", "getInstance", "TonConnectUI", "getTonConnectUIModule", "connect", "tonConnectUI", "parseAddress", "Networks", "result", "waitForConnection", "canEagerConnect", "canSwitchNetworkTo", "getSigners", "getWalletInfo", "allBlockChains", "tonBlockchain", "disconnect"]
+}

package/dist/provider-tonconnect.build.json

@@ -0,0 +1 @@
+{"inputs":{"src/helpers.ts":{"bytes":1325,"imports":[{"path":"@tonconnect/ui","kind":"dynamic-import","external":true},{"path":"@ton/core","kind":"dynamic-import","external":true},{"path":"<runtime>","kind":"import-statement","external":true}],"format":"esm"},"src/ton-signer.ts":{"bytes":868,"imports":[{"path":"@ton/core","kind":"import-statement","external":true},{"path":"@tonconnect/ui","kind":"import-statement","external":true},{"path":"rango-types","kind":"import-statement","external":true},{"path":"<runtime>","kind":"import-statement","external":true}],"format":"esm"},"src/signer.ts":{"bytes":476,"imports":[{"path":"rango-types","kind":"import-statement","external":true},{"path":"src/ton-signer.ts","kind":"dynamic-import","original":"./ton-signer.js"},{"path":"<runtime>","kind":"import-statement","external":true}],"format":"esm"},"src/index.ts":{"bytes":2624,"imports":[{"path":"@rango-dev/wallets-shared","kind":"import-statement","external":true},{"path":"rango-types","kind":"import-statement","external":true},{"path":"src/helpers.ts","kind":"import-statement","original":"./helpers.js"},{"path":"src/signer.ts","kind":"import-statement","original":"./signer.js"},{"path":"<runtime>","kind":"import-statement","external":true}],"format":"esm"}},"outputs":{"dist/index.js.map":{"imports":[],"exports":[],"inputs":{},"bytes":8980},"dist/index.js":{"imports":[{"path":"@ton/core","kind":"import-statement","external":true},{"path":"@tonconnect/ui","kind":"import-statement","external":true},{"path":"rango-types","kind":"import-statement","external":true},{"path":"@rango-dev/wallets-shared","kind":"import-statement","external":true},{"path":"rango-types","kind":"import-statement","external":true},{"path":"@tonconnect/ui","kind":"dynamic-import","external":true},{"path":"@ton/core","kind":"dynamic-import","external":true},{"path":"rango-types","kind":"import-statement","external":true}],"exports":["canEagerConnect","canSwitchNetworkTo","config","connect","disconnect","getInstance","getSigners","getWalletInfo","init"],"entryPoint":"src/index.ts","inputs":{"src/ton-signer.ts":{"bytesInOutput":502},"src/index.ts":{"bytesInOutput":953},"src/helpers.ts":{"bytesInOutput":556},"src/signer.ts":{"bytesInOutput":226}},"bytes":2604}}}

package/dist/signer.d.ts

@@ -0,0 +1,4 @@
+import type { TonConnectUI } from '@tonconnect/ui';
+import type { SignerFactory } from 'rango-types';
+export default function getSigners(provider: TonConnectUI): Promise<SignerFactory>;
+//# sourceMappingURL=signer.d.ts.map

package/dist/signer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.d.ts","sourceRoot":"","sources":["../src/signer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAIjD,wBAA8B,UAAU,CACtC,QAAQ,EAAE,YAAY,GACrB,OAAO,CAAC,aAAa,CAAC,CAKxB"}

package/dist/ton-signer.d.ts

@@ -0,0 +1,11 @@
+import type { TonConnectUI } from '@tonconnect/ui';
+import type { GenericSigner, TonTransaction } from 'rango-types';
+export declare class CustomTonSigner implements GenericSigner<TonTransaction> {
+    private provider;
+    constructor(provider: TonConnectUI);
+    signMessage(): Promise<string>;
+    signAndSendTx(tx: TonTransaction): Promise<{
+        hash: string;
+    }>;
+}
+//# sourceMappingURL=ton-signer.d.ts.map

package/dist/ton-signer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ton-signer.d.ts","sourceRoot":"","sources":["../src/ton-signer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AACnD,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAMjE,qBAAa,eAAgB,YAAW,aAAa,CAAC,cAAc,CAAC;IACnE,OAAO,CAAC,QAAQ,CAAe;gBAEnB,QAAQ,EAAE,YAAY;IAI5B,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC;IAI9B,aAAa,CAAC,EAAE,EAAE,cAAc,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAUnE"}

package/dist/types.d.ts

@@ -0,0 +1,4 @@
+export interface Environments extends Record<string, string | undefined> {
+    manifestUrl: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAa,SAAQ,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAC;IACtE,WAAW,EAAE,MAAM,CAAC;CACrB"}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@rango-dev/provider-tonconnect",
+  "version": "0.1.1-next.0",
+  "license": "MIT",
+  "type": "module",
+  "source": "./src/index.ts",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "node ../../scripts/build/command.mjs --path wallets/provider-tonconnect",
+    "ts-check": "tsc --declaration --emitDeclarationOnly -p ./tsconfig.json",
+    "clean": "rimraf dist",
+    "format": "prettier --write '{.,src}/**/*.{ts,tsx}'",
+    "lint": "eslint \"**/*.{ts,tsx}\" --ignore-path ../../.eslintignore"
+  },
+  "dependencies": {
+    "@rango-dev/wallets-shared": "^0.39.1-next.0",
+    "@ton/core": "^0.59.0",
+    "@ton/crypto": "^3.3.0",
+    "@tonconnect/ui": "^2.0.9",
+    "rango-types": "^0.1.75"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/readme.md

@@ -0,0 +1,3 @@
+# @rango-dev/provider-tonconnect
+
+TonConnect

package/src/helpers.ts

@@ -0,0 +1,47 @@
+import type { TonConnectUI } from '@tonconnect/ui';
+
+export async function getTonConnectUIModule() {
+  const tonConnectUI = await import('@tonconnect/ui');
+  return tonConnectUI;
+}
+
+export async function getTonCoreModule() {
+  const tonCore = await import('@ton/core');
+  return tonCore;
+}
+
+export async function waitForConnection(
+  tonConnectUI: TonConnectUI
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const unsubscribeStatusChange = tonConnectUI.onStatusChange(
+      (state) => {
+        const walletConnected = !!state?.account.address;
+
+        if (walletConnected) {
+          unsubscribeStatusChange();
+          resolve(state.account.address);
+        }
+      },
+      (error) => {
+        unsubscribeStatusChange();
+        reject(error);
+      }
+    );
+
+    const unsubscribeModalStateChange = tonConnectUI.onModalStateChange(
+      (modalState) => {
+        if (modalState.closeReason === 'action-cancelled') {
+          unsubscribeStatusChange();
+          unsubscribeModalStateChange();
+          reject(new Error('The action was canceled by the user'));
+        }
+      }
+    );
+  });
+}
+
+export async function parseAddress(rawAddress: string): Promise<string> {
+  const tonCore = await getTonCoreModule();
+  return tonCore.Address.parse(rawAddress).toString({ bounceable: false });
+}

package/src/index.ts

@@ -0,0 +1,97 @@
+import type { Environments } from './types.js';
+import type {
+  CanEagerConnect,
+  CanSwitchNetwork,
+  Connect,
+  Disconnect,
+  GetInstance,
+  WalletInfo,
+} from '@rango-dev/wallets-shared';
+import type { TonConnectUI } from '@tonconnect/ui';
+import type { BlockchainMeta, SignerFactory } from 'rango-types';
+
+import { Networks, WalletTypes } from '@rango-dev/wallets-shared';
+import { tonBlockchain } from 'rango-types';
+
+import {
+  getTonConnectUIModule,
+  parseAddress,
+  waitForConnection,
+} from './helpers.js';
+import signer from './signer.js';
+
+let envs: Environments = {
+  manifestUrl: '',
+};
+
+const WALLET = WalletTypes.TON_CONNECT;
+
+export const config = {
+  type: WALLET,
+  isAsyncInstance: true,
+  checkInstallation: false,
+};
+
+export type { Environments };
+
+export const init = (environments: Environments) => {
+  envs = environments;
+};
+
+let instance: TonConnectUI | null = null;
+
+export const getInstance: GetInstance = async () => {
+  if (!instance) {
+    const { TonConnectUI } = await getTonConnectUIModule();
+    instance = new TonConnectUI(envs);
+  }
+  return instance;
+};
+
+export const connect: Connect = async ({ instance }) => {
+  const tonConnectUI: TonConnectUI = instance;
+  const connectionRestored = await tonConnectUI.connectionRestored;
+
+  if (connectionRestored && tonConnectUI.account?.address) {
+    const parsedAddress = await parseAddress(tonConnectUI.account.address);
+    return { accounts: [parsedAddress], chainId: Networks.TON };
+  }
+
+  await tonConnectUI.openModal();
+  const result = await waitForConnection(tonConnectUI);
+  const parsedAddress = await parseAddress(result);
+
+  return {
+    accounts: [parsedAddress],
+    chainId: Networks.TON,
+  };
+};
+
+export const canEagerConnect: CanEagerConnect = async ({ instance }) => {
+  const tonConnectUI = instance as TonConnectUI;
+  const connectionRestored = await tonConnectUI.connectionRestored;
+  return connectionRestored;
+};
+
+export const canSwitchNetworkTo: CanSwitchNetwork = () => false;
+
+export const getSigners: (provider: TonConnectUI) => Promise<SignerFactory> =
+  signer;
+
+export const getWalletInfo: (allBlockChains: BlockchainMeta[]) => WalletInfo = (
+  allBlockChains
+) => {
+  const ton = tonBlockchain(allBlockChains);
+  return {
+    name: 'TON Connect',
+    img: 'https://raw.githubusercontent.com/rango-exchange/assets/7fb19ed5d5019b4d6a41ce91b39cde64f86af4c6/wallets/tonconnect/icon.svg',
+    installLink: '',
+    color: '#fff',
+    supportedChains: ton,
+  };
+};
+
+export const disconnect: Disconnect = async ({ instance }) => {
+  const tonConnectUI = instance as TonConnectUI;
+  await tonConnectUI.disconnect();
+};

package/src/signer.ts

@@ -0,0 +1,13 @@
+import type { TonConnectUI } from '@tonconnect/ui';
+import type { SignerFactory } from 'rango-types';
+
+import { DefaultSignerFactory, TransactionType as TxType } from 'rango-types';
+
+export default async function getSigners(
+  provider: TonConnectUI
+): Promise<SignerFactory> {
+  const signers = new DefaultSignerFactory();
+  const { CustomTonSigner } = await import('./ton-signer.js');
+  signers.registerSigner(TxType.TON, new CustomTonSigner(provider));
+  return signers;
+}

package/src/ton-signer.ts

@@ -0,0 +1,29 @@
+import type { TonConnectUI } from '@tonconnect/ui';
+import type { GenericSigner, TonTransaction } from 'rango-types';
+
+import { Cell } from '@ton/core';
+import { CHAIN } from '@tonconnect/ui';
+import { SignerError } from 'rango-types';
+
+export class CustomTonSigner implements GenericSigner<TonTransaction> {
+  private provider: TonConnectUI;
+
+  constructor(provider: TonConnectUI) {
+    this.provider = provider;
+  }
+
+  async signMessage(): Promise<string> {
+    throw SignerError.UnimplementedError('signMessage');
+  }
+
+  async signAndSendTx(tx: TonTransaction): Promise<{ hash: string }> {
+    const { blockChain, type, ...txObjectForSign } = tx;
+    const result = await this.provider.sendTransaction({
+      ...txObjectForSign,
+      network: CHAIN.MAINNET,
+    });
+
+    const hash = Cell.fromBase64(result.boc).hash().toString('hex');
+    return { hash };
+  }
+}

package/src/types.ts

@@ -0,0 +1,3 @@
+export interface Environments extends Record<string, string | undefined> {
+  manifestUrl: string;
+}